• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.10.5 API Reference
  • KDE Home
  • Contact Us
 

KHTML

  • khtml
khtml_settings.cpp
Go to the documentation of this file.
1 /* This file is part of the KDE project
2  Copyright (C) 1999 David Faure <faure@kde.org>
3 
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License as published by the Free Software Foundation; either
7  version 2 of the License, or (at your option) any later version.
8 
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Library General Public License for more details.
13 
14  You should have received a copy of the GNU Library General Public License
15  along with this library; see the file COPYING.LIB. If not, write to
16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  Boston, MA 02110-1301, USA.
18 */
19 
20 #include "khtml_settings.h"
21 #include "khtmldefaults.h"
22 
23 #include <kconfig.h>
24 #include <kconfiggroup.h>
25 #include <kdebug.h>
26 #include <kglobal.h>
27 #include <kglobalsettings.h>
28 #include <klocale.h>
29 #include <kmessagebox.h>
30 #include <khtml_filter_p.h>
31 #include <kstandarddirs.h>
32 #include <kjob.h>
33 #include <kio/job.h>
34 
35 #include <QFile>
36 #include <QFileInfo>
37 #include <QtGui/QFontDatabase>
38 #include <QByteArray>
39 
44 struct KPerDomainSettings {
45  bool m_bEnableJava : 1;
46  bool m_bEnableJavaScript : 1;
47  bool m_bEnablePlugins : 1;
48  // don't forget to maintain the bitfields as the enums grow
49  KHTMLSettings::KJSWindowOpenPolicy m_windowOpenPolicy : 2;
50  KHTMLSettings::KJSWindowStatusPolicy m_windowStatusPolicy : 1;
51  KHTMLSettings::KJSWindowFocusPolicy m_windowFocusPolicy : 1;
52  KHTMLSettings::KJSWindowMovePolicy m_windowMovePolicy : 1;
53  KHTMLSettings::KJSWindowResizePolicy m_windowResizePolicy : 1;
54 
55 #ifdef DEBUG_SETTINGS
56  void dump(const QString &infix = QString()) const {
57  kDebug() << "KPerDomainSettings " << infix << " @" << this << ":";
58  kDebug() << " m_bEnableJava: " << m_bEnableJava;
59  kDebug() << " m_bEnableJavaScript: " << m_bEnableJavaScript;
60  kDebug() << " m_bEnablePlugins: " << m_bEnablePlugins;
61  kDebug() << " m_windowOpenPolicy: " << m_windowOpenPolicy;
62  kDebug() << " m_windowStatusPolicy: " << m_windowStatusPolicy;
63  kDebug() << " m_windowFocusPolicy: " << m_windowFocusPolicy;
64  kDebug() << " m_windowMovePolicy: " << m_windowMovePolicy;
65  kDebug() << " m_windowResizePolicy: " << m_windowResizePolicy;
66  }
67 #endif
68 };
69 
70 QString *KHTMLSettings::avFamilies = 0;
71 typedef QMap<QString,KPerDomainSettings> PolicyMap;
72 
73 // The "struct" that contains all the data. Must be copiable (no pointers).
74 class KHTMLSettingsData
75 {
76 public:
77  bool m_bChangeCursor : 1;
78  bool m_bOpenMiddleClick : 1;
79  bool m_underlineLink : 1;
80  bool m_hoverLink : 1;
81  bool m_bEnableJavaScriptDebug : 1;
82  bool m_bEnableJavaScriptErrorReporting : 1;
83  bool enforceCharset : 1;
84  bool m_bAutoLoadImages : 1;
85  bool m_bUnfinishedImageFrame : 1;
86  bool m_formCompletionEnabled : 1;
87  bool m_autoDelayedActionsEnabled : 1;
88  bool m_jsErrorsEnabled : 1;
89  bool m_follow_system_colors : 1;
90  bool m_allowTabulation : 1;
91  bool m_autoSpellCheck : 1;
92  bool m_adFilterEnabled : 1;
93  bool m_hideAdsEnabled : 1;
94  bool m_jsPopupBlockerPassivePopup : 1;
95  bool m_accessKeysEnabled : 1;
96 
97  // the virtual global "domain"
98  KPerDomainSettings global;
99 
100  int m_fontSize;
101  int m_minFontSize;
102  int m_maxFormCompletionItems;
103  KHTMLSettings::KAnimationAdvice m_showAnimations;
104  KHTMLSettings::KSmoothScrollingMode m_smoothScrolling;
105  KHTMLSettings::KDNSPrefetch m_dnsPrefetch;
106 
107  QString m_encoding;
108  QString m_userSheet;
109 
110  QColor m_textColor;
111  QColor m_baseColor;
112  QColor m_linkColor;
113  QColor m_vLinkColor;
114 
115  PolicyMap domainPolicy;
116  QStringList fonts;
117  QStringList defaultFonts;
118 
119  khtml::FilterSet adBlackList;
120  khtml::FilterSet adWhiteList;
121  QList< QPair< QString, QChar > > m_fallbackAccessKeysAssignments;
122 };
123 
124 class KHTMLSettingsPrivate : public QObject, public KHTMLSettingsData
125 {
126  Q_OBJECT
127 public:
128 
129  void adblockFilterLoadList(const QString& filename)
130  {
131  kDebug(6000) << "Loading filter list from" << filename;
133  QFile file(filename);
134  if (file.open(QIODevice::ReadOnly)) {
135  QTextStream ts(&file);
136  QString line = ts.readLine();
137 #ifndef NDEBUG
138  int whiteCounter = 0, blackCounter = 0;
139 #endif // NDEBUG
140  while (!line.isEmpty()) {
142  if (line.startsWith(QLatin1String("@@")))
143  {
144 #ifndef NDEBUG
145  ++whiteCounter;
146 #endif // NDEBUG
147  adWhiteList.addFilter(line);
148  }
149  else
150  {
151 #ifndef NDEBUG
152  ++blackCounter;
153 #endif // NDEBUG
154  adBlackList.addFilter(line);
155  }
156 
157  line = ts.readLine();
158  }
159  file.close();
160 
161 #ifndef NDEBUG
162  kDebug(6000) << "Filter list loaded" << whiteCounter << "white list entries and" << blackCounter << "black list entries";
163 #endif // NDEBUG
164  }
165  }
166 
167 public slots:
168  void adblockFilterResult(KJob *job)
169  {
170  KIO::StoredTransferJob *tJob = qobject_cast<KIO::StoredTransferJob*>(job);
171  Q_ASSERT(tJob);
172 
173  if ( tJob->error() ) {
174  kDebug(6000) << "Failed to download" << tJob->url() << "with message:" << tJob->errorText();
175  }
176  else if ( tJob->isErrorPage() ) { // 4XX error code
177  kDebug(6000) << "Failed to fetch filter list" << tJob->url();
178  }
179  else {
180  const QByteArray byteArray = tJob->data();
181  const QString localFileName = tJob->property( "khtmlsettings_adBlock_filename" ).toString();
182 
183  QFile file(localFileName);
184  if ( file.open(QFile::WriteOnly) ) {
185  bool success = file.write(byteArray) == byteArray.size();
186  file.close();
187  if ( success )
188  adblockFilterLoadList(localFileName);
189  else
190  kDebug(6000) << "Could not write" << byteArray.size() << "to file" << localFileName;
191  }
192  else
193  kDebug(6000) << "Cannot open file" << localFileName << "for filter list";
194  }
195 
196  }
197 };
198 
199 
203 static KPerDomainSettings &setup_per_domain_policy(
204  KHTMLSettingsPrivate* const d,
205  const QString &domain) {
206  if (domain.isEmpty()) {
207  kWarning(6000) << "setup_per_domain_policy: domain is empty";
208  }
209  const QString ldomain = domain.toLower();
210  PolicyMap::iterator it = d->domainPolicy.find(ldomain);
211  if (it == d->domainPolicy.end()) {
212  // simply copy global domain settings (they should have been initialized
213  // by this time)
214  it = d->domainPolicy.insert(ldomain,d->global);
215  }
216  return *it;
217 }
218 
219 
220 KHTMLSettings::KJavaScriptAdvice KHTMLSettings::strToAdvice(const QString& _str)
221 {
222  return static_cast<KJavaScriptAdvice>(KParts::HtmlSettingsInterface::textToJavascriptAdvice(_str));
223 }
224 
225 const char* KHTMLSettings::adviceToStr(KJavaScriptAdvice _advice)
226 {
227  return KParts::HtmlSettingsInterface::javascriptAdviceToText(static_cast<KParts::HtmlSettingsInterface::JavaScriptAdvice>(_advice));
228 }
229 
230 
231 void KHTMLSettings::splitDomainAdvice(const QString& configStr, QString &domain,
232  KJavaScriptAdvice &javaAdvice, KJavaScriptAdvice& javaScriptAdvice)
233 {
234  KParts::HtmlSettingsInterface::JavaScriptAdvice jAdvice, jsAdvice;
235  KParts::HtmlSettingsInterface::splitDomainAdvice(configStr, domain, jAdvice, jsAdvice);
236  javaAdvice = static_cast<KJavaScriptAdvice>(jAdvice);
237  javaScriptAdvice = static_cast<KJavaScriptAdvice>(jsAdvice);
238 }
239 
240 void KHTMLSettings::readDomainSettings(const KConfigGroup &config, bool reset,
241  bool global, KPerDomainSettings &pd_settings) {
242  QString jsPrefix = global ? QString()
243  : QString::fromLatin1("javascript.");
244  QString javaPrefix = global ? QString()
245  : QString::fromLatin1("java.");
246  QString pluginsPrefix = global ? QString()
247  : QString::fromLatin1("plugins.");
248 
249  // The setting for Java
250  QString key = javaPrefix + QLatin1String("EnableJava");
251  if ( (global && reset) || config.hasKey( key ) )
252  pd_settings.m_bEnableJava = config.readEntry( key, false );
253  else if ( !global )
254  pd_settings.m_bEnableJava = d->global.m_bEnableJava;
255 
256  // The setting for Plugins
257  key = pluginsPrefix + QLatin1String("EnablePlugins");
258  if ( (global && reset) || config.hasKey( key ) )
259  pd_settings.m_bEnablePlugins = config.readEntry( key, true );
260  else if ( !global )
261  pd_settings.m_bEnablePlugins = d->global.m_bEnablePlugins;
262 
263  // The setting for JavaScript
264  key = jsPrefix + QLatin1String("EnableJavaScript");
265  if ( (global && reset) || config.hasKey( key ) )
266  pd_settings.m_bEnableJavaScript = config.readEntry( key, true );
267  else if ( !global )
268  pd_settings.m_bEnableJavaScript = d->global.m_bEnableJavaScript;
269 
270  // window property policies
271  key = jsPrefix + QLatin1String("WindowOpenPolicy");
272  if ( (global && reset) || config.hasKey( key ) )
273  pd_settings.m_windowOpenPolicy = (KJSWindowOpenPolicy)
274  config.readEntry( key, uint(KJSWindowOpenSmart) );
275  else if ( !global )
276  pd_settings.m_windowOpenPolicy = d->global.m_windowOpenPolicy;
277 
278  key = jsPrefix + QLatin1String("WindowMovePolicy");
279  if ( (global && reset) || config.hasKey( key ) )
280  pd_settings.m_windowMovePolicy = (KJSWindowMovePolicy)
281  config.readEntry( key, uint(KJSWindowMoveAllow) );
282  else if ( !global )
283  pd_settings.m_windowMovePolicy = d->global.m_windowMovePolicy;
284 
285  key = jsPrefix + QLatin1String("WindowResizePolicy");
286  if ( (global && reset) || config.hasKey( key ) )
287  pd_settings.m_windowResizePolicy = (KJSWindowResizePolicy)
288  config.readEntry( key, uint(KJSWindowResizeAllow) );
289  else if ( !global )
290  pd_settings.m_windowResizePolicy = d->global.m_windowResizePolicy;
291 
292  key = jsPrefix + QLatin1String("WindowStatusPolicy");
293  if ( (global && reset) || config.hasKey( key ) )
294  pd_settings.m_windowStatusPolicy = (KJSWindowStatusPolicy)
295  config.readEntry( key, uint(KJSWindowStatusAllow) );
296  else if ( !global )
297  pd_settings.m_windowStatusPolicy = d->global.m_windowStatusPolicy;
298 
299  key = jsPrefix + QLatin1String("WindowFocusPolicy");
300  if ( (global && reset) || config.hasKey( key ) )
301  pd_settings.m_windowFocusPolicy = (KJSWindowFocusPolicy)
302  config.readEntry( key, uint(KJSWindowFocusAllow) );
303  else if ( !global )
304  pd_settings.m_windowFocusPolicy = d->global.m_windowFocusPolicy;
305 
306 }
307 
308 
309 KHTMLSettings::KHTMLSettings()
310  :d (new KHTMLSettingsPrivate())
311 {
312  init();
313 }
314 
315 KHTMLSettings::KHTMLSettings(const KHTMLSettings &other)
316  :d(new KHTMLSettingsPrivate())
317 {
318  KHTMLSettingsData* data = d;
319  *data = *other.d;
320 }
321 
322 KHTMLSettings::~KHTMLSettings()
323 {
324  delete d;
325 }
326 
327 bool KHTMLSettings::changeCursor() const
328 {
329  return d->m_bChangeCursor;
330 }
331 
332 bool KHTMLSettings::underlineLink() const
333 {
334  return d->m_underlineLink;
335 }
336 
337 bool KHTMLSettings::hoverLink() const
338 {
339  return d->m_hoverLink;
340 }
341 
342 void KHTMLSettings::init()
343 {
344  KConfig global( "khtmlrc", KConfig::NoGlobals );
345  init( &global, true );
346 
347  KSharedConfig::Ptr local = KGlobal::config();
348  if ( !local )
349  return;
350 
351  init( local.data(), false );
352 }
353 
354 void KHTMLSettings::init( KConfig * config, bool reset )
355 {
356  KConfigGroup cg( config, "MainView Settings" );
357  if (reset || cg.exists() )
358  {
359  if ( reset || cg.hasKey( "OpenMiddleClick" ) )
360  d->m_bOpenMiddleClick = cg.readEntry( "OpenMiddleClick", true );
361  }
362 
363  KConfigGroup cgAccess(config,"Access Keys" );
364  if (reset || cgAccess.exists() ) {
365  d->m_accessKeysEnabled = cgAccess.readEntry( "Enabled", true );
366  }
367 
368  KConfigGroup cgFilter( config, "Filter Settings" );
369 
370  if (reset || cgFilter.exists() )
371  {
372  d->m_adFilterEnabled = cgFilter.readEntry("Enabled", false);
373  d->m_hideAdsEnabled = cgFilter.readEntry("Shrink", false);
374 
375  d->adBlackList.clear();
376  d->adWhiteList.clear();
377 
378  if (d->m_adFilterEnabled) {
379 
381  int htmlFilterListMaxAgeDays = cgFilter.readEntry(QString("HTMLFilterListMaxAgeDays")).toInt();
382  if (htmlFilterListMaxAgeDays < 1)
383  htmlFilterListMaxAgeDays = 1;
384 
385  QMap<QString,QString> entryMap = cgFilter.entryMap();
386  QMap<QString,QString>::ConstIterator it;
387  for( it = entryMap.constBegin(); it != entryMap.constEnd(); ++it )
388  {
389  int id = -1;
390  QString name = it.key();
391  QString url = it.value();
392 
393  if (name.startsWith("Filter"))
394  {
395  if (url.startsWith(QLatin1String("@@")))
396  d->adWhiteList.addFilter(url);
397  else
398  d->adBlackList.addFilter(url);
399  } else if (name.startsWith("HTMLFilterListName-") && (id = name.mid(19).toInt()) > 0)
400  {
402  bool filterEnabled = cgFilter.readEntry(QString("HTMLFilterListEnabled-").append(QString::number(id))) != QLatin1String("false");
403 
405  KUrl url(cgFilter.readEntry(QString("HTMLFilterListURL-").append(QString::number(id))));
406 
407  if (filterEnabled && url.isValid()) {
409  QString localFile = cgFilter.readEntry(QString("HTMLFilterListLocalFilename-").append(QString::number(id)));
410  localFile = KStandardDirs::locateLocal("data", "khtml/" + localFile);
411 
413  QFileInfo fileInfo(localFile);
414 
416  if (fileInfo.exists())
417  d->adblockFilterLoadList( localFile );
418 
420  if (!fileInfo.exists() || fileInfo.lastModified().daysTo(QDateTime::currentDateTime()) > htmlFilterListMaxAgeDays)
421  {
423  kDebug(6000) << "Asynchronously fetching filter list from" << url << "to" << localFile;
424 
425  KIO::StoredTransferJob *job = KIO::storedGet( url, KIO::Reload, KIO::HideProgressInfo );
426  QObject::connect( job, SIGNAL(result(KJob*)), d, SLOT(adblockFilterResult(KJob*)) );
428  job->setProperty("khtmlsettings_adBlock_filename", localFile);
429  }
430  }
431  }
432  }
433  }
434 
435  }
436 
437  KConfigGroup cgHtml( config, "HTML Settings" );
438  if (reset || cgHtml.exists() )
439  {
440  // Fonts and colors
441  if( reset ) {
442  d->defaultFonts = QStringList();
443  d->defaultFonts.append( cgHtml.readEntry( "StandardFont", KGlobalSettings::generalFont().family() ) );
444  d->defaultFonts.append( cgHtml.readEntry( "FixedFont", KGlobalSettings::fixedFont().family() ) );
445  d->defaultFonts.append( cgHtml.readEntry( "SerifFont", HTML_DEFAULT_VIEW_SERIF_FONT ) );
446  d->defaultFonts.append( cgHtml.readEntry( "SansSerifFont", HTML_DEFAULT_VIEW_SANSSERIF_FONT ) );
447  d->defaultFonts.append( cgHtml.readEntry( "CursiveFont", HTML_DEFAULT_VIEW_CURSIVE_FONT ) );
448  d->defaultFonts.append( cgHtml.readEntry( "FantasyFont", HTML_DEFAULT_VIEW_FANTASY_FONT ) );
449  d->defaultFonts.append( QString( "0" ) ); // font size adjustment
450  }
451 
452  if ( reset || cgHtml.hasKey( "MinimumFontSize" ) )
453  d->m_minFontSize = cgHtml.readEntry( "MinimumFontSize", HTML_DEFAULT_MIN_FONT_SIZE );
454 
455  if ( reset || cgHtml.hasKey( "MediumFontSize" ) )
456  d->m_fontSize = cgHtml.readEntry( "MediumFontSize", 12 );
457 
458  d->fonts = cgHtml.readEntry( "Fonts", QStringList() );
459 
460  if ( reset || cgHtml.hasKey( "DefaultEncoding" ) )
461  d->m_encoding = cgHtml.readEntry( "DefaultEncoding", "" );
462 
463  if ( reset || cgHtml.hasKey( "EnforceDefaultCharset" ) )
464  d->enforceCharset = cgHtml.readEntry( "EnforceDefaultCharset", false );
465 
466  // Behavior
467  if ( reset || cgHtml.hasKey( "ChangeCursor" ) )
468  d->m_bChangeCursor = cgHtml.readEntry( "ChangeCursor", KDE_DEFAULT_CHANGECURSOR );
469 
470  if ( reset || cgHtml.hasKey("UnderlineLinks") )
471  d->m_underlineLink = cgHtml.readEntry( "UnderlineLinks", true );
472 
473  if ( reset || cgHtml.hasKey( "HoverLinks" ) )
474  {
475  if ( (d->m_hoverLink = cgHtml.readEntry( "HoverLinks", false )))
476  d->m_underlineLink = false;
477  }
478 
479  if ( reset || cgHtml.hasKey( "AllowTabulation" ) )
480  d->m_allowTabulation = cgHtml.readEntry( "AllowTabulation", false );
481 
482  if ( reset || cgHtml.hasKey( "AutoSpellCheck" ) )
483  d->m_autoSpellCheck = cgHtml.readEntry( "AutoSpellCheck", true );
484 
485  // Other
486  if ( reset || cgHtml.hasKey( "AutoLoadImages" ) )
487  d->m_bAutoLoadImages = cgHtml.readEntry( "AutoLoadImages", true );
488 
489  if ( reset || cgHtml.hasKey( "UnfinishedImageFrame" ) )
490  d->m_bUnfinishedImageFrame = cgHtml.readEntry( "UnfinishedImageFrame", true );
491 
492  if ( reset || cgHtml.hasKey( "ShowAnimations" ) )
493  {
494  QString value = cgHtml.readEntry( "ShowAnimations").toLower();
495  if (value == "disabled")
496  d->m_showAnimations = KAnimationDisabled;
497  else if (value == "looponce")
498  d->m_showAnimations = KAnimationLoopOnce;
499  else
500  d->m_showAnimations = KAnimationEnabled;
501  }
502 
503  if ( reset || cgHtml.hasKey( "SmoothScrolling" ) )
504  {
505  QString value = cgHtml.readEntry( "SmoothScrolling", "whenefficient" ).toLower();
506  if (value == "disabled")
507  d->m_smoothScrolling = KSmoothScrollingDisabled;
508  else if (value == "whenefficient")
509  d->m_smoothScrolling = KSmoothScrollingWhenEfficient;
510  else
511  d->m_smoothScrolling = KSmoothScrollingEnabled;
512  }
513 
514  if ( reset || cgHtml.hasKey( "DNSPrefetch" ) )
515  {
516  // Enabled, Disabled, OnlyWWWAndSLD
517  QString value = cgHtml.readEntry( "DNSPrefetch", "Enabled" ).toLower();
518  if (value == "enabled")
519  d->m_dnsPrefetch = KDNSPrefetchEnabled;
520  else if (value == "onlywwwandsld")
521  d->m_dnsPrefetch = KDNSPrefetchOnlyWWWAndSLD;
522  else
523  d->m_dnsPrefetch = KDNSPrefetchDisabled;
524  }
525 
526  if ( cgHtml.readEntry( "UserStyleSheetEnabled", false ) == true ) {
527  if ( reset || cgHtml.hasKey( "UserStyleSheet" ) )
528  d->m_userSheet = cgHtml.readEntry( "UserStyleSheet", "" );
529  }
530 
531  d->m_formCompletionEnabled = cgHtml.readEntry("FormCompletion", true);
532  d->m_maxFormCompletionItems = cgHtml.readEntry("MaxFormCompletionItems", 10);
533  d->m_autoDelayedActionsEnabled = cgHtml.readEntry ("AutoDelayedActions", true);
534  d->m_jsErrorsEnabled = cgHtml.readEntry("ReportJSErrors", true);
535  const QStringList accesskeys = cgHtml.readEntry("FallbackAccessKeysAssignments", QStringList());
536  d->m_fallbackAccessKeysAssignments.clear();
537  for( QStringList::ConstIterator it = accesskeys.begin(); it != accesskeys.end(); ++it )
538  if( (*it).length() > 2 && (*it)[ 1 ] == ':' )
539  d->m_fallbackAccessKeysAssignments.append( qMakePair( (*it).mid( 2 ), (*it)[ 0 ] ));
540  }
541 
542  // Colors
543  //In which group ?????
544  if ( reset || cg.hasKey( "FollowSystemColors" ) )
545  d->m_follow_system_colors = cg.readEntry( "FollowSystemColors", false );
546 
547  KConfigGroup cgGeneral( config, "General" );
548  if ( reset || cgGeneral.exists( ) )
549  {
550  if ( reset || cgGeneral.hasKey( "foreground" ) ) {
551  QColor def(HTML_DEFAULT_TXT_COLOR);
552  d->m_textColor = cgGeneral.readEntry( "foreground", def );
553  }
554 
555  if ( reset || cgGeneral.hasKey( "linkColor" ) ) {
556  QColor def(HTML_DEFAULT_LNK_COLOR);
557  d->m_linkColor = cgGeneral.readEntry( "linkColor", def );
558  }
559 
560  if ( reset || cgGeneral.hasKey( "visitedLinkColor" ) ) {
561  QColor def(HTML_DEFAULT_VLNK_COLOR);
562  d->m_vLinkColor = cgGeneral.readEntry( "visitedLinkColor", def);
563  }
564 
565  if ( reset || cgGeneral.hasKey( "background" ) ) {
566  QColor def(HTML_DEFAULT_BASE_COLOR);
567  d->m_baseColor = cgGeneral.readEntry( "background", def);
568  }
569  }
570 
571  KConfigGroup cgJava( config, "Java/JavaScript Settings" );
572  if( reset || cgJava.exists() )
573  {
574  // The global setting for JavaScript debugging
575  // This is currently always enabled by default
576  if ( reset || cgJava.hasKey( "EnableJavaScriptDebug" ) )
577  d->m_bEnableJavaScriptDebug = cgJava.readEntry( "EnableJavaScriptDebug", false );
578 
579  // The global setting for JavaScript error reporting
580  if ( reset || cgJava.hasKey( "ReportJavaScriptErrors" ) )
581  d->m_bEnableJavaScriptErrorReporting = cgJava.readEntry( "ReportJavaScriptErrors", false );
582 
583  // The global setting for popup block passive popup
584  if ( reset || cgJava.hasKey( "PopupBlockerPassivePopup" ) )
585  d->m_jsPopupBlockerPassivePopup = cgJava.readEntry("PopupBlockerPassivePopup", true );
586 
587  // Read options from the global "domain"
588  readDomainSettings(cgJava,reset,true,d->global);
589 #ifdef DEBUG_SETTINGS
590  d->global.dump("init global");
591 #endif
592 
593  // The domain-specific settings.
594 
595  static const char *const domain_keys[] = { // always keep order of keys
596  "ECMADomains", "JavaDomains", "PluginDomains"
597  };
598  bool check_old_ecma_settings = true;
599  bool check_old_java_settings = true;
600  // merge all domains into one list
601  QMap<QString,int> domainList; // why can't Qt have a QSet?
602  for (unsigned i = 0; i < sizeof domain_keys/sizeof domain_keys[0]; ++i) {
603  if ( reset || cgJava.hasKey(domain_keys[i]) ) {
604  if (i == 0) check_old_ecma_settings = false;
605  else if (i == 1) check_old_java_settings = false;
606  const QStringList dl = cgJava.readEntry( domain_keys[i], QStringList() );
607  const QMap<QString,int>::Iterator notfound = domainList.end();
608  QStringList::ConstIterator it = dl.begin();
609  const QStringList::ConstIterator itEnd = dl.end();
610  for (; it != itEnd; ++it) {
611  const QString domain = (*it).toLower();
612  QMap<QString,int>::Iterator pos = domainList.find(domain);
613  if (pos == notfound) domainList.insert(domain,0);
614  }/*next it*/
615  }
616  }/*next i*/
617 
618  if (reset)
619  d->domainPolicy.clear();
620 
621  {
622  QMap<QString,int>::ConstIterator it = domainList.constBegin();
623  const QMap<QString,int>::ConstIterator itEnd = domainList.constEnd();
624  for ( ; it != itEnd; ++it)
625  {
626  const QString domain = it.key();
627  KConfigGroup cg( config, domain );
628  readDomainSettings(cg,reset,false,d->domainPolicy[domain]);
629 #ifdef DEBUG_SETTINGS
630  d->domainPolicy[domain].dump("init "+domain);
631 #endif
632  }
633  }
634 
635  bool check_old_java = true;
636  if( ( reset || cgJava.hasKey( "JavaDomainSettings" ) )
637  && check_old_java_settings )
638  {
639  check_old_java = false;
640  const QStringList domainList = cgJava.readEntry( "JavaDomainSettings", QStringList() );
641  QStringList::ConstIterator it = domainList.constBegin();
642  const QStringList::ConstIterator itEnd = domainList.constEnd();
643  for ( ; it != itEnd; ++it)
644  {
645  QString domain;
646  KJavaScriptAdvice javaAdvice;
647  KJavaScriptAdvice javaScriptAdvice;
648  splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
649  setup_per_domain_policy(d,domain).m_bEnableJava =
650  javaAdvice == KJavaScriptAccept;
651 #ifdef DEBUG_SETTINGS
652  setup_per_domain_policy(d,domain).dump("JavaDomainSettings 4 "+domain);
653 #endif
654  }
655  }
656 
657  bool check_old_ecma = true;
658  if( ( reset || cgJava.hasKey( "ECMADomainSettings" ) )
659  && check_old_ecma_settings )
660  {
661  check_old_ecma = false;
662  const QStringList domainList = cgJava.readEntry( "ECMADomainSettings", QStringList() );
663  QStringList::ConstIterator it = domainList.constBegin();
664  const QStringList::ConstIterator itEnd = domainList.constEnd();
665  for ( ; it != itEnd; ++it)
666  {
667  QString domain;
668  KJavaScriptAdvice javaAdvice;
669  KJavaScriptAdvice javaScriptAdvice;
670  splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
671  setup_per_domain_policy(d,domain).m_bEnableJavaScript =
672  javaScriptAdvice == KJavaScriptAccept;
673 #ifdef DEBUG_SETTINGS
674  setup_per_domain_policy(d,domain).dump("ECMADomainSettings 4 "+domain);
675 #endif
676  }
677  }
678 
679  if( ( reset || cgJava.hasKey( "JavaScriptDomainAdvice" ) )
680  && ( check_old_java || check_old_ecma )
681  && ( check_old_ecma_settings || check_old_java_settings ) )
682  {
683  const QStringList domainList = cgJava.readEntry( "JavaScriptDomainAdvice", QStringList() );
684  QStringList::ConstIterator it = domainList.constBegin();
685  const QStringList::ConstIterator itEnd = domainList.constEnd();
686  for ( ; it != itEnd; ++it)
687  {
688  QString domain;
689  KJavaScriptAdvice javaAdvice;
690  KJavaScriptAdvice javaScriptAdvice;
691  splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
692  if( check_old_java )
693  setup_per_domain_policy(d,domain).m_bEnableJava =
694  javaAdvice == KJavaScriptAccept;
695  if( check_old_ecma )
696  setup_per_domain_policy(d,domain).m_bEnableJavaScript =
697  javaScriptAdvice == KJavaScriptAccept;
698 #ifdef DEBUG_SETTINGS
699  setup_per_domain_policy(d,domain).dump("JavaScriptDomainAdvice 4 "+domain);
700 #endif
701  }
702 
703  //save all the settings into the new keywords if they don't exist
704 #if 0
705  if( check_old_java )
706  {
707  QStringList domainConfig;
708  PolicyMap::Iterator it;
709  for( it = d->javaDomainPolicy.begin(); it != d->javaDomainPolicy.end(); ++it )
710  {
711  QByteArray javaPolicy = adviceToStr( it.value() );
712  QByteArray javaScriptPolicy = adviceToStr( KJavaScriptDunno );
713  domainConfig.append(QString::fromLatin1("%1:%2:%3").arg(it.key()).arg(javaPolicy).arg(javaScriptPolicy));
714  }
715  cg.writeEntry( "JavaDomainSettings", domainConfig );
716  }
717 
718  if( check_old_ecma )
719  {
720  QStringList domainConfig;
721  PolicyMap::Iterator it;
722  for( it = d->javaScriptDomainPolicy.begin(); it != d->javaScriptDomainPolicy.end(); ++it )
723  {
724  QByteArray javaPolicy = adviceToStr( KJavaScriptDunno );
725  QByteArray javaScriptPolicy = adviceToStr( it.value() );
726  domainConfig.append(QString::fromLatin1("%1:%2:%3").arg(it.key()).arg(javaPolicy).arg(javaScriptPolicy));
727  }
728  cg.writeEntry( "ECMADomainSettings", domainConfig );
729  }
730 #endif
731  }
732  }
733 }
734 
735 
740 static const KPerDomainSettings &lookup_hostname_policy(
741  const KHTMLSettingsPrivate* const d,
742  const QString& hostname)
743 {
744 #ifdef DEBUG_SETTINGS
745  kDebug() << "lookup_hostname_policy(" << hostname << ")";
746 #endif
747  if (hostname.isEmpty()) {
748 #ifdef DEBUG_SETTINGS
749  d->global.dump("global");
750 #endif
751  return d->global;
752  }
753 
754  const PolicyMap::const_iterator notfound = d->domainPolicy.constEnd();
755 
756  // First check whether there is a perfect match.
757  PolicyMap::const_iterator it = d->domainPolicy.find(hostname);
758  if( it != notfound ) {
759 #ifdef DEBUG_SETTINGS
760  kDebug() << "perfect match";
761  (*it).dump(hostname);
762 #endif
763  // yes, use it (unless dunno)
764  return *it;
765  }
766 
767  // Now, check for partial match. Chop host from the left until
768  // there's no dots left.
769  QString host_part = hostname;
770  int dot_idx = -1;
771  while( (dot_idx = host_part.indexOf(QChar('.'))) >= 0 ) {
772  host_part.remove(0,dot_idx);
773  it = d->domainPolicy.find(host_part);
774  Q_ASSERT(notfound == d->domainPolicy.end());
775  if( it != notfound ) {
776 #ifdef DEBUG_SETTINGS
777  kDebug() << "partial match";
778  (*it).dump(host_part);
779 #endif
780  return *it;
781  }
782  // assert(host_part[0] == QChar('.'));
783  host_part.remove(0,1); // Chop off the dot.
784  }
785 
786  // No domain-specific entry: use global domain
787 #ifdef DEBUG_SETTINGS
788  kDebug() << "no match";
789  d->global.dump("global");
790 #endif
791  return d->global;
792 }
793 
794 bool KHTMLSettings::isOpenMiddleClickEnabled()
795 {
796  return d->m_bOpenMiddleClick;
797 }
798 
799 bool KHTMLSettings::isBackRightClickEnabled()
800 {
801  return false; // ## the feature moved to konqueror
802 }
803 
804 bool KHTMLSettings::accessKeysEnabled() const
805 {
806  return d->m_accessKeysEnabled;
807 }
808 
809 bool KHTMLSettings::isAdFilterEnabled() const
810 {
811  return d->m_adFilterEnabled;
812 }
813 
814 bool KHTMLSettings::isHideAdsEnabled() const
815 {
816  return d->m_hideAdsEnabled;
817 }
818 
819 bool KHTMLSettings::isAdFiltered( const QString &url ) const
820 {
821  if (d->m_adFilterEnabled)
822  {
823  if (!url.startsWith("data:"))
824  {
825  // Check the blacklist, and only if that matches, the whitelist
826  return d->adBlackList.isUrlMatched(url) && !d->adWhiteList.isUrlMatched(url);
827  }
828  }
829  return false;
830 }
831 
832 QString KHTMLSettings::adFilteredBy( const QString &url, bool *isWhiteListed ) const
833 {
834  QString m = d->adWhiteList.urlMatchedBy(url);
835  if (!m.isEmpty())
836  {
837  if (isWhiteListed != 0)
838  *isWhiteListed = true;
839  return (m);
840  }
841 
842  m = d->adBlackList.urlMatchedBy(url);
843  if (!m.isEmpty())
844  {
845  if (isWhiteListed != 0)
846  *isWhiteListed = false;
847  return (m);
848  }
849 
850  return (QString());
851 }
852 
853 void KHTMLSettings::addAdFilter( const QString &url )
854 {
855  KConfigGroup config = KSharedConfig::openConfig( "khtmlrc", KConfig::NoGlobals )->group( "Filter Settings" );
856 
857  QRegExp rx;
858 
859  // Try compiling to avoid invalid stuff. Only support the basic syntax here...
860  // ### refactor somewhat
861  if (url.length()>2 && url[0]=='/' && url[url.length()-1] == '/')
862  {
863  QString inside = url.mid(1, url.length()-2);
864  rx.setPattern(inside);
865  }
866  else
867  {
868  rx.setPatternSyntax(QRegExp::Wildcard);
869  rx.setPattern(url);
870  }
871 
872  if (rx.isValid())
873  {
874  int last=config.readEntry("Count", 0);
875  QString key = "Filter-" + QString::number(last);
876  config.writeEntry(key, url);
877  config.writeEntry("Count",last+1);
878  config.sync();
879  if (url.startsWith(QLatin1String("@@")))
880  d->adWhiteList.addFilter(url);
881  else
882  d->adBlackList.addFilter(url);
883  }
884  else
885  {
886  KMessageBox::error(0,
887  rx.errorString(),
888  i18n("Filter error"));
889  }
890 }
891 
892 bool KHTMLSettings::isJavaEnabled( const QString& hostname ) const
893 {
894  return lookup_hostname_policy(d,hostname.toLower()).m_bEnableJava;
895 }
896 
897 bool KHTMLSettings::isJavaScriptEnabled( const QString& hostname ) const
898 {
899  return lookup_hostname_policy(d,hostname.toLower()).m_bEnableJavaScript;
900 }
901 
902 bool KHTMLSettings::isJavaScriptDebugEnabled( const QString& /*hostname*/ ) const
903 {
904  // debug setting is global for now, but could change in the future
905  return d->m_bEnableJavaScriptDebug;
906 }
907 
908 bool KHTMLSettings::isJavaScriptErrorReportingEnabled( const QString& /*hostname*/ ) const
909 {
910  // error reporting setting is global for now, but could change in the future
911  return d->m_bEnableJavaScriptErrorReporting;
912 }
913 
914 bool KHTMLSettings::isPluginsEnabled( const QString& hostname ) const
915 {
916  return lookup_hostname_policy(d,hostname.toLower()).m_bEnablePlugins;
917 }
918 
919 KHTMLSettings::KJSWindowOpenPolicy KHTMLSettings::windowOpenPolicy(
920  const QString& hostname) const {
921  return lookup_hostname_policy(d,hostname.toLower()).m_windowOpenPolicy;
922 }
923 
924 KHTMLSettings::KJSWindowMovePolicy KHTMLSettings::windowMovePolicy(
925  const QString& hostname) const {
926  return lookup_hostname_policy(d,hostname.toLower()).m_windowMovePolicy;
927 }
928 
929 KHTMLSettings::KJSWindowResizePolicy KHTMLSettings::windowResizePolicy(
930  const QString& hostname) const {
931  return lookup_hostname_policy(d,hostname.toLower()).m_windowResizePolicy;
932 }
933 
934 KHTMLSettings::KJSWindowStatusPolicy KHTMLSettings::windowStatusPolicy(
935  const QString& hostname) const {
936  return lookup_hostname_policy(d,hostname.toLower()).m_windowStatusPolicy;
937 }
938 
939 KHTMLSettings::KJSWindowFocusPolicy KHTMLSettings::windowFocusPolicy(
940  const QString& hostname) const {
941  return lookup_hostname_policy(d,hostname.toLower()).m_windowFocusPolicy;
942 }
943 
944 int KHTMLSettings::mediumFontSize() const
945 {
946  return d->m_fontSize;
947 }
948 
949 int KHTMLSettings::minFontSize() const
950 {
951  return d->m_minFontSize;
952 }
953 
954 QString KHTMLSettings::settingsToCSS() const
955 {
956  // lets start with the link properties
957  QString str = "a:link {\ncolor: ";
958  str += d->m_linkColor.name();
959  str += ';';
960  if(d->m_underlineLink)
961  str += "\ntext-decoration: underline;";
962 
963  if( d->m_bChangeCursor )
964  {
965  str += "\ncursor: pointer;";
966  str += "\n}\ninput[type=image] { cursor: pointer;";
967  }
968  str += "\n}\n";
969  str += "a:visited {\ncolor: ";
970  str += d->m_vLinkColor.name();
971  str += ';';
972  if(d->m_underlineLink)
973  str += "\ntext-decoration: underline;";
974 
975  if( d->m_bChangeCursor )
976  str += "\ncursor: pointer;";
977  str += "\n}\n";
978 
979  if(d->m_hoverLink)
980  str += "a:link:hover, a:visited:hover { text-decoration: underline; }\n";
981 
982  return str;
983 }
984 
985 const QString &KHTMLSettings::availableFamilies()
986 {
987  if ( !avFamilies ) {
988  avFamilies = new QString;
989  QFontDatabase db;
990  QStringList families = db.families();
991  QStringList s;
992  QRegExp foundryExp(" \\[.+\\]");
993 
994  //remove foundry info
995  QStringList::Iterator f = families.begin();
996  const QStringList::Iterator fEnd = families.end();
997 
998  for ( ; f != fEnd; ++f ) {
999  (*f).replace( foundryExp, "");
1000  if (!s.contains(*f))
1001  s << *f;
1002  }
1003  s.sort();
1004 
1005  *avFamilies = ',' + s.join(",") + ',';
1006  }
1007 
1008  return *avFamilies;
1009 }
1010 
1011 QString KHTMLSettings::lookupFont(int i) const
1012 {
1013  QString font;
1014  if (d->fonts.count() > i)
1015  font = d->fonts[i];
1016  if (font.isEmpty())
1017  font = d->defaultFonts[i];
1018  return font;
1019 }
1020 
1021 QString KHTMLSettings::stdFontName() const
1022 {
1023  return lookupFont(0);
1024 }
1025 
1026 QString KHTMLSettings::fixedFontName() const
1027 {
1028  return lookupFont(1);
1029 }
1030 
1031 QString KHTMLSettings::serifFontName() const
1032 {
1033  return lookupFont(2);
1034 }
1035 
1036 QString KHTMLSettings::sansSerifFontName() const
1037 {
1038  return lookupFont(3);
1039 }
1040 
1041 QString KHTMLSettings::cursiveFontName() const
1042 {
1043  return lookupFont(4);
1044 }
1045 
1046 QString KHTMLSettings::fantasyFontName() const
1047 {
1048  return lookupFont(5);
1049 }
1050 
1051 void KHTMLSettings::setStdFontName(const QString &n)
1052 {
1053  while(d->fonts.count() <= 0)
1054  d->fonts.append(QString());
1055  d->fonts[0] = n;
1056 }
1057 
1058 void KHTMLSettings::setFixedFontName(const QString &n)
1059 {
1060  while(d->fonts.count() <= 1)
1061  d->fonts.append(QString());
1062  d->fonts[1] = n;
1063 }
1064 
1065 QString KHTMLSettings::userStyleSheet() const
1066 {
1067  return d->m_userSheet;
1068 }
1069 
1070 bool KHTMLSettings::isFormCompletionEnabled() const
1071 {
1072  return d->m_formCompletionEnabled;
1073 }
1074 
1075 int KHTMLSettings::maxFormCompletionItems() const
1076 {
1077  return d->m_maxFormCompletionItems;
1078 }
1079 
1080 const QString &KHTMLSettings::encoding() const
1081 {
1082  return d->m_encoding;
1083 }
1084 
1085 bool KHTMLSettings::followSystemColors() const
1086 {
1087  return d->m_follow_system_colors;
1088 }
1089 
1090 const QColor& KHTMLSettings::textColor() const
1091 {
1092  return d->m_textColor;
1093 }
1094 
1095 const QColor& KHTMLSettings::baseColor() const
1096 {
1097  return d->m_baseColor;
1098 }
1099 
1100 const QColor& KHTMLSettings::linkColor() const
1101 {
1102  return d->m_linkColor;
1103 }
1104 
1105 const QColor& KHTMLSettings::vLinkColor() const
1106 {
1107  return d->m_vLinkColor;
1108 }
1109 
1110 bool KHTMLSettings::autoLoadImages() const
1111 {
1112  return d->m_bAutoLoadImages;
1113 }
1114 
1115 bool KHTMLSettings::unfinishedImageFrame() const
1116 {
1117  return d->m_bUnfinishedImageFrame;
1118 }
1119 
1120 KHTMLSettings::KAnimationAdvice KHTMLSettings::showAnimations() const
1121 {
1122  return d->m_showAnimations;
1123 }
1124 
1125 KHTMLSettings::KSmoothScrollingMode KHTMLSettings::smoothScrolling() const
1126 {
1127  return d->m_smoothScrolling;
1128 }
1129 
1130 KHTMLSettings::KDNSPrefetch KHTMLSettings::dnsPrefetch() const
1131 {
1132  return d->m_dnsPrefetch;
1133 }
1134 
1135 bool KHTMLSettings::isAutoDelayedActionsEnabled() const
1136 {
1137  return d->m_autoDelayedActionsEnabled;
1138 }
1139 
1140 bool KHTMLSettings::jsErrorsEnabled() const
1141 {
1142  return d->m_jsErrorsEnabled;
1143 }
1144 
1145 void KHTMLSettings::setJSErrorsEnabled(bool enabled)
1146 {
1147  d->m_jsErrorsEnabled = enabled;
1148  // save it
1149  KConfigGroup cg( KGlobal::config(), "HTML Settings");
1150  cg.writeEntry("ReportJSErrors", enabled);
1151  cg.sync();
1152 }
1153 
1154 bool KHTMLSettings::allowTabulation() const
1155 {
1156  return d->m_allowTabulation;
1157 }
1158 
1159 bool KHTMLSettings::autoSpellCheck() const
1160 {
1161  return d->m_autoSpellCheck;
1162 }
1163 
1164 QList< QPair< QString, QChar > > KHTMLSettings::fallbackAccessKeysAssignments() const
1165 {
1166  return d->m_fallbackAccessKeysAssignments;
1167 }
1168 
1169 void KHTMLSettings::setJSPopupBlockerPassivePopup(bool enabled)
1170 {
1171  d->m_jsPopupBlockerPassivePopup = enabled;
1172  // save it
1173  KConfigGroup cg( KGlobal::config(), "Java/JavaScript Settings");
1174  cg.writeEntry("PopupBlockerPassivePopup", enabled);
1175  cg.sync();
1176 }
1177 
1178 bool KHTMLSettings::jsPopupBlockerPassivePopup() const
1179 {
1180  return d->m_jsPopupBlockerPassivePopup;
1181 }
1182 
1183 #include "khtml_settings.moc"
KHTMLSettings::isHideAdsEnabled
bool isHideAdsEnabled() const
Definition: khtml_settings.cpp:814
KHTMLSettings
Settings for the HTML view.
Definition: khtml_settings.h:41
QColor
i18n
QString i18n(const char *text)
KHTMLSettings::fantasyFontName
QString fantasyFontName() const
Definition: khtml_settings.cpp:1046
KHTMLSettings::changeCursor
bool changeCursor() const
Definition: khtml_settings.cpp:327
KHTMLSettings::KJSWindowStatusAllow
Definition: khtml_settings.h:86
KSharedPtr< KSharedConfig >
KHTMLSettings::sansSerifFontName
QString sansSerifFontName() const
Definition: khtml_settings.cpp:1036
KHTMLSettings::KAnimationDisabled
Definition: khtml_settings.h:55
KHTMLSettings::fallbackAccessKeysAssignments
QList< QPair< QString, QChar > > fallbackAccessKeysAssignments() const
Definition: khtml_settings.cpp:1164
KHTMLSettings::isFormCompletionEnabled
bool isFormCompletionEnabled() const
Definition: khtml_settings.cpp:1070
HTML_DEFAULT_VIEW_SERIF_FONT
#define HTML_DEFAULT_VIEW_SERIF_FONT
Definition: khtmldefaults.h:29
KHTMLSettings::isJavaScriptDebugEnabled
bool isJavaScriptDebugEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:902
kdebug.h
KHTMLSettings::setFixedFontName
void setFixedFontName(const QString &n)
Definition: khtml_settings.cpp:1058
KSharedPtr::data
T * data()
KHTMLSettings::isAdFilterEnabled
bool isAdFilterEnabled() const
Definition: khtml_settings.cpp:809
KHTMLSettings::maxFormCompletionItems
int maxFormCompletionItems() const
Definition: khtml_settings.cpp:1075
KHTMLSettings::setJSErrorsEnabled
void setJSErrorsEnabled(bool enabled)
Definition: khtml_settings.cpp:1145
kglobalsettings.h
KParts::HtmlSettingsInterface::splitDomainAdvice
static void splitDomainAdvice(const QString &text, QString &domain, JavaScriptAdvice &javaAdvice, JavaScriptAdvice &javaScriptAdvice)
KHTMLSettings::KSmoothScrollingWhenEfficient
Definition: khtml_settings.h:62
setup_per_domain_policy
static KPerDomainSettings & setup_per_domain_policy(KHTMLSettingsPrivate *const d, const QString &domain)
Returns a writeable per-domains settings instance for the given domain or a deep copy of the global s...
Definition: khtml_settings.cpp:203
d
#define d
Definition: khtmlfind.cpp:42
KHTMLSettings::KJSWindowFocusAllow
Definition: khtml_settings.h:110
KHTMLSettings::minFontSize
int minFontSize() const
Definition: khtml_settings.cpp:949
KHTMLSettings::KAnimationAdvice
KAnimationAdvice
Definition: khtml_settings.h:54
KIO::HideProgressInfo
KHTMLSettings::adFilteredBy
QString adFilteredBy(const QString &url, bool *isWhiteListed=0) const
identify the filter which matches url.
Definition: khtml_settings.cpp:832
kconfig.h
KIO::StoredTransferJob
HTML_DEFAULT_VLNK_COLOR
#define HTML_DEFAULT_VLNK_COLOR
Definition: khtmldefaults.h:24
KHTMLSettings::settingsToCSS
QString settingsToCSS() const
Definition: khtml_settings.cpp:954
KHTMLSettings::availableFamilies
static const QString & availableFamilies()
Definition: khtml_settings.cpp:985
KHTMLSettings::windowStatusPolicy
KJSWindowStatusPolicy windowStatusPolicy(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:934
KHTMLSettings::autoLoadImages
bool autoLoadImages() const
Definition: khtml_settings.cpp:1110
name
const char * name(StandardAction id)
KHTMLSettings::readDomainSettings
void readDomainSettings(const KConfigGroup &config, bool reset, bool global, KPerDomainSettings &pd_settings)
reads from config&#39;s current group, forcing initialization if reset is true.
Definition: khtml_settings.cpp:240
KHTMLSettings::isJavaEnabled
bool isJavaEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:892
KConfig::group
KConfigGroup group(const QByteArray &group)
KHTMLSettings::linkColor
const QColor & linkColor() const
Definition: khtml_settings.cpp:1100
KConfigGroup::writeEntry
void writeEntry(const QString &key, const QVariant &value, WriteConfigFlags pFlags=Normal)
KHTMLSettings::adviceToStr
static const char * adviceToStr(KJavaScriptAdvice _advice)
Definition: khtml_settings.cpp:225
KHTMLSettings::isJavaScriptEnabled
bool isJavaScriptEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:897
KHTMLSettings::textColor
const QColor & textColor() const
Definition: khtml_settings.cpp:1090
QString
KHTMLSettings::~KHTMLSettings
virtual ~KHTMLSettings()
Destructor.
Definition: khtml_settings.cpp:322
KHTMLSettings::KJSWindowMovePolicy
KJSWindowMovePolicy
This enum specifies the policy for window.moveBy and .moveTo.
Definition: khtml_settings.h:93
QObject
kDebug
static QDebug kDebug(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
klocale.h
KHTMLSettings::smoothScrolling
KSmoothScrollingMode smoothScrolling() const
Definition: khtml_settings.cpp:1125
KHTMLSettings::followSystemColors
bool followSystemColors() const
Definition: khtml_settings.cpp:1085
KHTMLSettings::setStdFontName
void setStdFontName(const QString &n)
Definition: khtml_settings.cpp:1051
KIO::StoredTransferJob::data
QByteArray data() const
KHTMLSettings::fixedFontName
QString fixedFontName() const
Definition: khtml_settings.cpp:1026
KUrl
KHTMLSettings::serifFontName
QString serifFontName() const
Definition: khtml_settings.cpp:1031
KHTMLSettings::encoding
const QString & encoding() const
Definition: khtml_settings.cpp:1080
KGlobal::config
KSharedConfigPtr config()
KHTMLSettings::KSmoothScrollingEnabled
Definition: khtml_settings.h:63
lookup_hostname_policy
static const KPerDomainSettings & lookup_hostname_policy(const KHTMLSettingsPrivate *const d, const QString &hostname)
Local helper for retrieving per-domain settings.
Definition: khtml_settings.cpp:740
KHTMLSettings::isBackRightClickEnabled
bool isBackRightClickEnabled()
Definition: khtml_settings.cpp:799
kglobal.h
KConfig::NoGlobals
KConfigGroup::exists
bool exists() const
KParts::HtmlSettingsInterface::JavaScriptAdvice
JavaScriptAdvice
khtml_filter_p.h
KHTMLSettings::KDNSPrefetch
KDNSPrefetch
Definition: khtml_settings.h:66
KHTMLSettings::KJavaScriptDunno
Definition: khtml_settings.h:49
KHTMLSettings::windowOpenPolicy
KJSWindowOpenPolicy windowOpenPolicy(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:919
KHTMLSettings::isAdFiltered
bool isAdFiltered(const QString &url) const
tests whether url is filtered.
Definition: khtml_settings.cpp:819
QStringList
KDE_DEFAULT_CHANGECURSOR
#define KDE_DEFAULT_CHANGECURSOR
HTML_DEFAULT_VIEW_CURSIVE_FONT
#define HTML_DEFAULT_VIEW_CURSIVE_FONT
Definition: khtmldefaults.h:31
KHTMLSettings::isOpenMiddleClickEnabled
bool isOpenMiddleClickEnabled()
Definition: khtml_settings.cpp:794
KHTMLSettings::windowMovePolicy
KJSWindowMovePolicy windowMovePolicy(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:924
KHTMLSettings::KDNSPrefetchEnabled
Definition: khtml_settings.h:69
KHTMLSettings::KJavaScriptAccept
Definition: khtml_settings.h:50
KHTMLSettings::KHTMLSettings
KHTMLSettings()
Definition: khtml_settings.cpp:309
KHTMLSettings::KAnimationLoopOnce
Definition: khtml_settings.h:56
KHTMLSettings::KDNSPrefetchOnlyWWWAndSLD
Definition: khtml_settings.h:68
KHTMLSettings::KJSWindowMoveAllow
Definition: khtml_settings.h:94
if
if(yyss+yystacksize-1<=yyssp)
Definition: parser.cpp:1327
KHTMLSettings::jsPopupBlockerPassivePopup
bool jsPopupBlockerPassivePopup() const
Definition: khtml_settings.cpp:1178
KHTMLSettings::KJSWindowStatusPolicy
KJSWindowStatusPolicy
This enum specifies the policy for window.status and .defaultStatus.
Definition: khtml_settings.h:85
KIO::storedGet
StoredTransferJob * storedGet(const KUrl &url, LoadType reload=NoReload, JobFlags flags=DefaultFlags)
KHTMLSettings::addAdFilter
void addAdFilter(const QString &url)
Definition: khtml_settings.cpp:853
khtml::FilterSet
Definition: khtml_filter_p.h:59
KHTMLSettings::isJavaScriptErrorReportingEnabled
bool isJavaScriptErrorReportingEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:908
KHTMLSettings::showAnimations
KAnimationAdvice showAnimations() const
Definition: khtml_settings.cpp:1120
khtmldefaults.h
KIO::Reload
KHTMLSettings::accessKeysEnabled
bool accessKeysEnabled() const
Definition: khtml_settings.cpp:804
KHTMLSettings::jsErrorsEnabled
bool jsErrorsEnabled() const
Definition: khtml_settings.cpp:1140
KConfigGroup::hasKey
bool hasKey(const QString &key) const
KParts::HtmlSettingsInterface::textToJavascriptAdvice
static JavaScriptAdvice textToJavascriptAdvice(const QString &text)
KHTMLSettings::KSmoothScrollingDisabled
Definition: khtml_settings.h:61
job.h
KHTMLSettings::KDNSPrefetchDisabled
Definition: khtml_settings.h:67
KConfigGroup
KHTMLSettings::autoSpellCheck
bool autoSpellCheck() const
Definition: khtml_settings.cpp:1159
PolicyMap
QMap< QString, KPerDomainSettings > PolicyMap
Definition: khtml_settings.cpp:71
KConfig
KHTMLSettings::userStyleSheet
QString userStyleSheet() const
Definition: khtml_settings.cpp:1065
KGlobalSettings::generalFont
static QFont generalFont()
KHTMLSettings::underlineLink
bool underlineLink() const
Definition: khtml_settings.cpp:332
HTML_DEFAULT_MIN_FONT_SIZE
#define HTML_DEFAULT_MIN_FONT_SIZE
Definition: khtmldefaults.h:33
KHTMLSettings::setJSPopupBlockerPassivePopup
void setJSPopupBlockerPassivePopup(bool enabled)
Definition: khtml_settings.cpp:1169
KStandardDirs::locateLocal
static QString locateLocal(const char *type, const QString &filename, const KComponentData &cData=KGlobal::mainComponent())
KHTMLSettings::mediumFontSize
int mediumFontSize() const
Definition: khtml_settings.cpp:944
kstandarddirs.h
KHTMLSettings::KJSWindowResizeAllow
Definition: khtml_settings.h:102
KHTMLSettings::hoverLink
bool hoverLink() const
Definition: khtml_settings.cpp:337
KHTMLSettings::strToAdvice
static KJavaScriptAdvice strToAdvice(const QString &_str)
Definition: khtml_settings.cpp:220
KHTMLSettings::stdFontName
QString stdFontName() const
Definition: khtml_settings.cpp:1021
kWarning
static QDebug kWarning(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
KHTMLSettings::KSmoothScrollingMode
KSmoothScrollingMode
Definition: khtml_settings.h:60
HTML_DEFAULT_BASE_COLOR
#define HTML_DEFAULT_BASE_COLOR
Definition: khtmldefaults.h:25
KHTMLSettings::KJSWindowOpenPolicy
KJSWindowOpenPolicy
This enum specifies the policy for window.open.
Definition: khtml_settings.h:75
KHTMLSettings::allowTabulation
bool allowTabulation() const
Definition: khtml_settings.cpp:1154
KParts::HtmlSettingsInterface::javascriptAdviceToText
static const char * javascriptAdviceToText(JavaScriptAdvice advice)
KHTMLSettings::init
void init()
Called by constructor and reparseConfiguration.
Definition: khtml_settings.cpp:342
KHTMLSettings::isPluginsEnabled
bool isPluginsEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:914
KHTMLSettings::windowResizePolicy
KJSWindowResizePolicy windowResizePolicy(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:929
kjob.h
KHTMLSettings::baseColor
const QColor & baseColor() const
Definition: khtml_settings.cpp:1095
HTML_DEFAULT_VIEW_SANSSERIF_FONT
#define HTML_DEFAULT_VIEW_SANSSERIF_FONT
Definition: khtmldefaults.h:30
KConfigGroup::sync
void sync()
HTML_DEFAULT_TXT_COLOR
#define HTML_DEFAULT_TXT_COLOR
Definition: khtmldefaults.h:23
KHTMLSettings::unfinishedImageFrame
bool unfinishedImageFrame() const
Definition: khtml_settings.cpp:1115
KSharedConfig::openConfig
static KSharedConfig::Ptr openConfig(const QString &fileName=QString(), OpenFlags mode=FullConfig, const char *resourceType="config")
KHTMLSettings::vLinkColor
const QColor & vLinkColor() const
Definition: khtml_settings.cpp:1105
KHTMLSettings::KJavaScriptAdvice
KJavaScriptAdvice
This enum specifies whether Java/JavaScript execution is allowed.
Definition: khtml_settings.h:48
kmessagebox.h
KHTMLSettings::splitDomainAdvice
static void splitDomainAdvice(const QString &configStr, QString &domain, KJavaScriptAdvice &javaAdvice, KJavaScriptAdvice &javaScriptAdvice)
Definition: khtml_settings.cpp:231
khtml_settings.h
HTML_DEFAULT_VIEW_FANTASY_FONT
#define HTML_DEFAULT_VIEW_FANTASY_FONT
Definition: khtmldefaults.h:32
KConfigGroup::readEntry
T readEntry(const QString &key, const T &aDefault) const
KJob
KHTMLSettings::isAutoDelayedActionsEnabled
bool isAutoDelayedActionsEnabled() const
Definition: khtml_settings.cpp:1135
DOM::enabled
static bool enabled(KHTMLPart *)
Definition: jsediting.cpp:383
KHTMLSettings::KJSWindowResizePolicy
KJSWindowResizePolicy
This enum specifies the policy for window.resizeBy and .resizeTo.
Definition: khtml_settings.h:101
KHTMLSettings::KJSWindowOpenSmart
Definition: khtml_settings.h:79
KMessageBox::error
static void error(QWidget *parent, const QString &text, const QString &caption=QString(), Options options=Notify)
KConfigGroup::entryMap
QMap< QString, QString > entryMap() const
QMap< QString, KPerDomainSettings >
KHTMLSettings::cursiveFontName
QString cursiveFontName() const
Definition: khtml_settings.cpp:1041
KGlobalSettings::fixedFont
static QFont fixedFont()
kconfiggroup.h
KCompositeJob::errorText
QString errorText() const
KHTMLSettings::KAnimationEnabled
Definition: khtml_settings.h:57
HTML_DEFAULT_LNK_COLOR
#define HTML_DEFAULT_LNK_COLOR
Definition: khtmldefaults.h:22
QList
KCompositeJob::error
int error() const
KHTMLSettings::KJSWindowFocusPolicy
KJSWindowFocusPolicy
This enum specifies the policy for window.focus.
Definition: khtml_settings.h:109
KHTMLSettings::dnsPrefetch
KDNSPrefetch dnsPrefetch() const
Definition: khtml_settings.cpp:1130
KHTMLSettings::windowFocusPolicy
KJSWindowFocusPolicy windowFocusPolicy(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:939
This file is part of the KDE documentation.
Documentation copyright © 1996-2014 The KDE developers.
Generated on Sun May 4 2014 08:38:28 by doxygen 1.8.5 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KHTML

Skip menu "KHTML"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.10.5 API Reference

Skip menu "kdelibs-4.10.5 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal