khtml Library API Documentation

khtml_settings.cc

00001 /* This file is part of the KDE project
00002    Copyright (C) 1999 David Faure <faure@kde.org>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License as published by the Free Software Foundation; either
00007    version 2 of the License, or (at your option) any later version.
00008 
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017    Boston, MA 02111-1307, USA.
00018 */
00019 
00020 #include <qfontdatabase.h>
00021 
00022 #include "khtml_settings.h"
00023 #include "khtmldefaults.h"
00024 #include <kglobalsettings.h>
00025 #include <kconfig.h>
00026 #include <kglobal.h>
00027 #include <klocale.h>
00028 #include <kdebug.h>
00029 #include <qregexp.h>
00030 
00035 struct KPerDomainSettings {
00036     bool m_bEnableJava : 1;
00037     bool m_bEnableJavaScript : 1;
00038     bool m_bEnablePlugins : 1;
00039     // don't forget to maintain the bitfields as the enums grow
00040     KHTMLSettings::KJSWindowOpenPolicy m_windowOpenPolicy : 2;
00041     KHTMLSettings::KJSWindowStatusPolicy m_windowStatusPolicy : 1;
00042     KHTMLSettings::KJSWindowFocusPolicy m_windowFocusPolicy : 1;
00043     KHTMLSettings::KJSWindowMovePolicy m_windowMovePolicy : 1;
00044     KHTMLSettings::KJSWindowResizePolicy m_windowResizePolicy : 1;
00045 
00046 #ifdef DEBUG_SETTINGS
00047     void dump(const QString &infix = QString::null) const {
00048       kdDebug() << "KPerDomainSettings " << infix << " @" << this << ":" << endl;
00049       kdDebug() << "  m_bEnableJava: " << m_bEnableJava << endl;
00050       kdDebug() << "  m_bEnableJavaScript: " << m_bEnableJavaScript << endl;
00051       kdDebug() << "  m_bEnablePlugins: " << m_bEnablePlugins << endl;
00052       kdDebug() << "  m_windowOpenPolicy: " << m_windowOpenPolicy << endl;
00053       kdDebug() << "  m_windowStatusPolicy: " << m_windowStatusPolicy << endl;
00054       kdDebug() << "  m_windowFocusPolicy: " << m_windowFocusPolicy << endl;
00055       kdDebug() << "  m_windowMovePolicy: " << m_windowMovePolicy << endl;
00056       kdDebug() << "  m_windowResizePolicy: " << m_windowResizePolicy << endl;
00057     }
00058 #endif
00059 };
00060 
00061 typedef QMap<QString,KPerDomainSettings> PolicyMap;
00062 
00063 class KHTMLSettingsPrivate
00064 {
00065 public:
00066     bool m_bChangeCursor : 1;
00067     bool m_bOpenMiddleClick : 1;
00068     bool m_bBackRightClick : 1;
00069     bool m_underlineLink : 1;
00070     bool m_hoverLink : 1;
00071     bool m_bEnableJavaScriptDebug : 1;
00072     bool m_bEnableJavaScriptErrorReporting : 1;
00073     bool enforceCharset : 1;
00074     bool m_bAutoLoadImages : 1;
00075     bool m_bUnfinishedImageFrame : 1;
00076     bool m_formCompletionEnabled : 1;
00077     bool m_autoDelayedActionsEnabled : 1;
00078     bool m_jsErrorsEnabled : 1;
00079     bool m_follow_system_colors : 1;
00080     bool m_allowTabulation : 1;
00081     bool m_autoSpellCheck : 1;
00082 
00083     // the virtual global "domain"
00084     KPerDomainSettings global;
00085 
00086     int m_fontSize;
00087     int m_minFontSize;
00088     int m_maxFormCompletionItems;
00089     KHTMLSettings::KAnimationAdvice m_showAnimations;
00090 
00091     QString m_encoding;
00092     QString m_userSheet;
00093 
00094     QColor m_textColor;
00095     QColor m_baseColor;
00096     QColor m_linkColor;
00097     QColor m_vLinkColor;
00098 
00099     PolicyMap domainPolicy;
00100     QStringList fonts;
00101     QStringList defaultFonts;
00102 };
00103 
00104 
00108 static KPerDomainSettings &setup_per_domain_policy(
00109                 KHTMLSettingsPrivate *d,
00110                 const QString &domain) {
00111   if (domain.isEmpty()) {
00112     kdWarning() << "setup_per_domain_policy: domain is empty" << endl;
00113   }
00114   const QString ldomain = domain.lower();
00115   PolicyMap::iterator it = d->domainPolicy.find(ldomain);
00116   if (it == d->domainPolicy.end()) {
00117     // simply copy global domain settings (they should have been initialized
00118     // by this time)
00119     it = d->domainPolicy.insert(ldomain,d->global);
00120   }
00121   return *it;
00122 }
00123 
00124 
00125 KHTMLSettings::KJavaScriptAdvice KHTMLSettings::strToAdvice(const QString& _str)
00126 {
00127   KJavaScriptAdvice ret = KJavaScriptDunno;
00128 
00129   if (!_str)
00130         ret = KJavaScriptDunno;
00131 
00132   if (_str.lower() == QString::fromLatin1("accept"))
00133         ret = KJavaScriptAccept;
00134   else if (_str.lower() == QString::fromLatin1("reject"))
00135         ret = KJavaScriptReject;
00136 
00137   return ret;
00138 }
00139 
00140 const char* KHTMLSettings::adviceToStr(KJavaScriptAdvice _advice)
00141 {
00142     switch( _advice ) {
00143     case KJavaScriptAccept: return I18N_NOOP("Accept");
00144     case KJavaScriptReject: return I18N_NOOP("Reject");
00145     default: return 0;
00146     }
00147         return 0;
00148 }
00149 
00150 
00151 void KHTMLSettings::splitDomainAdvice(const QString& configStr, QString &domain,
00152                                       KJavaScriptAdvice &javaAdvice, KJavaScriptAdvice& javaScriptAdvice)
00153 {
00154     QString tmp(configStr);
00155     int splitIndex = tmp.find(':');
00156     if ( splitIndex == -1)
00157     {
00158         domain = configStr.lower();
00159         javaAdvice = KJavaScriptDunno;
00160         javaScriptAdvice = KJavaScriptDunno;
00161     }
00162     else
00163     {
00164         domain = tmp.left(splitIndex).lower();
00165         QString adviceString = tmp.mid( splitIndex+1, tmp.length() );
00166         int splitIndex2 = adviceString.find( ':' );
00167         if( splitIndex2 == -1 ) {
00168             // Java advice only
00169             javaAdvice = strToAdvice( adviceString );
00170             javaScriptAdvice = KJavaScriptDunno;
00171         } else {
00172             // Java and JavaScript advice
00173             javaAdvice = strToAdvice( adviceString.left( splitIndex2 ) );
00174             javaScriptAdvice = strToAdvice( adviceString.mid( splitIndex2+1,
00175                                                               adviceString.length() ) );
00176         }
00177     }
00178 }
00179 
00180 void KHTMLSettings::readDomainSettings(KConfig *config, bool reset,
00181     bool global, KPerDomainSettings &pd_settings) {
00182   QString jsPrefix = global ? QString::null
00183                 : QString::fromLatin1("javascript.");
00184   QString javaPrefix = global ? QString::null
00185                 : QString::fromLatin1("java.");
00186   QString pluginsPrefix = global ? QString::null
00187                 : QString::fromLatin1("plugins.");
00188 
00189   // The setting for Java
00190   QString key = javaPrefix + QString::fromLatin1("EnableJava");
00191   if ( (global && reset) || config->hasKey( key ) )
00192     pd_settings.m_bEnableJava = config->readBoolEntry( key, false );
00193   else if ( !global )
00194     pd_settings.m_bEnableJava = d->global.m_bEnableJava;
00195 
00196   // The setting for Plugins
00197   key = pluginsPrefix + QString::fromLatin1("EnablePlugins");
00198   if ( (global && reset) || config->hasKey( key ) )
00199     pd_settings.m_bEnablePlugins = config->readBoolEntry( key, true );
00200   else if ( !global )
00201     pd_settings.m_bEnablePlugins = d->global.m_bEnablePlugins;
00202 
00203   // The setting for JavaScript
00204   key = jsPrefix + QString::fromLatin1("EnableJavaScript");
00205   if ( (global && reset) || config->hasKey( key ) )
00206     pd_settings.m_bEnableJavaScript = config->readBoolEntry( key, true );
00207   else if ( !global )
00208     pd_settings.m_bEnableJavaScript = d->global.m_bEnableJavaScript;
00209 
00210   // window property policies
00211   key = jsPrefix + QString::fromLatin1("WindowOpenPolicy");
00212   if ( (global && reset) || config->hasKey( key ) )
00213     pd_settings.m_windowOpenPolicy = (KJSWindowOpenPolicy)
00214             config->readUnsignedNumEntry( key, KJSWindowOpenAllow );
00215   else if ( !global )
00216     pd_settings.m_windowOpenPolicy = d->global.m_windowOpenPolicy;
00217 
00218   key = jsPrefix + QString::fromLatin1("WindowMovePolicy");
00219   if ( (global && reset) || config->hasKey( key ) )
00220     pd_settings.m_windowMovePolicy = (KJSWindowMovePolicy)
00221             config->readUnsignedNumEntry( key, KJSWindowMoveAllow );
00222   else if ( !global )
00223     pd_settings.m_windowMovePolicy = d->global.m_windowMovePolicy;
00224 
00225   key = jsPrefix + QString::fromLatin1("WindowResizePolicy");
00226   if ( (global && reset) || config->hasKey( key ) )
00227     pd_settings.m_windowResizePolicy = (KJSWindowResizePolicy)
00228             config->readUnsignedNumEntry( key, KJSWindowResizeAllow );
00229   else if ( !global )
00230     pd_settings.m_windowResizePolicy = d->global.m_windowResizePolicy;
00231 
00232   key = jsPrefix + QString::fromLatin1("WindowStatusPolicy");
00233   if ( (global && reset) || config->hasKey( key ) )
00234     pd_settings.m_windowStatusPolicy = (KJSWindowStatusPolicy)
00235             config->readUnsignedNumEntry( key, KJSWindowStatusAllow );
00236   else if ( !global )
00237     pd_settings.m_windowStatusPolicy = d->global.m_windowStatusPolicy;
00238 
00239   key = jsPrefix + QString::fromLatin1("WindowFocusPolicy");
00240   if ( (global && reset) || config->hasKey( key ) )
00241     pd_settings.m_windowFocusPolicy = (KJSWindowFocusPolicy)
00242             config->readUnsignedNumEntry( key, KJSWindowFocusAllow );
00243   else if ( !global )
00244     pd_settings.m_windowFocusPolicy = d->global.m_windowFocusPolicy;
00245 
00246 }
00247 
00248 
00249 KHTMLSettings::KHTMLSettings()
00250 {
00251   d = new KHTMLSettingsPrivate();
00252   init();
00253 }
00254 
00255 KHTMLSettings::KHTMLSettings(const KHTMLSettings &other)
00256 {
00257   d = new KHTMLSettingsPrivate();
00258   *d = *other.d;
00259 }
00260 
00261 KHTMLSettings::~KHTMLSettings()
00262 {
00263   delete d;
00264 }
00265 
00266 bool KHTMLSettings::changeCursor() const
00267 {
00268   return d->m_bChangeCursor;
00269 }
00270 
00271 bool KHTMLSettings::underlineLink() const
00272 {
00273   return d->m_underlineLink;
00274 }
00275 
00276 bool KHTMLSettings::hoverLink() const
00277 {
00278   return d->m_hoverLink;
00279 }
00280 
00281 void KHTMLSettings::init()
00282 {
00283   KConfig global( "khtmlrc", true, false );
00284   init( &global, true );
00285 
00286   KConfig *local = KGlobal::config();
00287   if ( !local )
00288     return;
00289 
00290   init( local, false );
00291 }
00292 
00293 void KHTMLSettings::init( KConfig * config, bool reset )
00294 {
00295   QString group_save = config->group();
00296   if (reset || config->hasGroup("MainView Settings"))
00297   {
00298     config->setGroup( "MainView Settings" );
00299 
00300     if ( reset || config->hasKey( "OpenMiddleClick" ) )
00301         d->m_bOpenMiddleClick = config->readBoolEntry( "OpenMiddleClick", true );
00302 
00303     if ( reset || config->hasKey( "BackRightClick" ) )
00304         d->m_bBackRightClick = config->readBoolEntry( "BackRightClick", false );
00305   }
00306 
00307   if (reset || config->hasGroup("HTML Settings"))
00308   {
00309     config->setGroup( "HTML Settings" );
00310     // Fonts and colors
00311     if( reset ) {
00312         d->defaultFonts = QStringList();
00313         d->defaultFonts.append( config->readEntry( "StandardFont", KGlobalSettings::generalFont().family() ) );
00314         d->defaultFonts.append( config->readEntry( "FixedFont", KGlobalSettings::fixedFont().family() ) );
00315         d->defaultFonts.append( config->readEntry( "SerifFont", HTML_DEFAULT_VIEW_SERIF_FONT ) );
00316         d->defaultFonts.append( config->readEntry( "SansSerifFont", HTML_DEFAULT_VIEW_SANSSERIF_FONT ) );
00317         d->defaultFonts.append( config->readEntry( "CursiveFont", HTML_DEFAULT_VIEW_CURSIVE_FONT ) );
00318         d->defaultFonts.append( config->readEntry( "FantasyFont", HTML_DEFAULT_VIEW_FANTASY_FONT ) );
00319         d->defaultFonts.append( QString( "0" ) ); // font size adjustment
00320     }
00321 
00322     if ( reset || config->hasKey( "MinimumFontSize" ) )
00323         d->m_minFontSize = config->readNumEntry( "MinimumFontSize", HTML_DEFAULT_MIN_FONT_SIZE );
00324 
00325     if ( reset || config->hasKey( "MediumFontSize" ) )
00326         d->m_fontSize = config->readNumEntry( "MediumFontSize", 12 );
00327 
00328     d->fonts = config->readListEntry( "Fonts" );
00329 
00330     if ( reset || config->hasKey( "DefaultEncoding" ) )
00331         d->m_encoding = config->readEntry( "DefaultEncoding", "" );
00332 
00333     if ( reset || config->hasKey( "EnforceDefaultCharset" ) )
00334         d->enforceCharset = config->readBoolEntry( "EnforceDefaultCharset", false );
00335 
00336     // Behavior
00337     if ( reset || config->hasKey( "ChangeCursor" ) )
00338         d->m_bChangeCursor = config->readBoolEntry( "ChangeCursor", KDE_DEFAULT_CHANGECURSOR );
00339 
00340     if ( reset || config->hasKey("UnderlineLinks") )
00341         d->m_underlineLink = config->readBoolEntry( "UnderlineLinks", true );
00342 
00343     if ( reset || config->hasKey( "HoverLinks" ) )
00344     {
00345         if ( ( d->m_hoverLink = config->readBoolEntry( "HoverLinks", false ) ) )
00346             d->m_underlineLink = false;
00347     }
00348 
00349     if ( reset || config->hasKey( "AllowTabulation" ) )
00350         d->m_allowTabulation = config->readBoolEntry( "AllowTabulation", false );
00351 
00352     if ( reset || config->hasKey( "AutoSpellCheck" ) )
00353         d->m_autoSpellCheck = config->readBoolEntry( "AutoSpellCheck", true );
00354 
00355     // Other
00356     if ( reset || config->hasKey( "AutoLoadImages" ) )
00357       d->m_bAutoLoadImages = config->readBoolEntry( "AutoLoadImages", true );
00358 
00359     if ( reset || config->hasKey( "UnfinishedImageFrame" ) )
00360       d->m_bUnfinishedImageFrame = config->readBoolEntry( "UnfinishedImageFrame", true );
00361 
00362     if ( reset || config->hasKey( "ShowAnimations" ) )
00363     {
00364       QString value = config->readEntry( "ShowAnimations").lower();
00365       if (value == "disabled")
00366          d->m_showAnimations = KAnimationDisabled;
00367       else if (value == "looponce")
00368          d->m_showAnimations = KAnimationLoopOnce;
00369       else
00370          d->m_showAnimations = KAnimationEnabled;
00371     }
00372 
00373     if ( config->readBoolEntry( "UserStyleSheetEnabled", false ) == true ) {
00374         if ( reset || config->hasKey( "UserStyleSheet" ) )
00375             d->m_userSheet = config->readEntry( "UserStyleSheet", "" );
00376     }
00377 
00378     d->m_formCompletionEnabled = config->readBoolEntry("FormCompletion", true);
00379     d->m_maxFormCompletionItems = config->readNumEntry("MaxFormCompletionItems", 10);
00380     d->m_autoDelayedActionsEnabled = config->readBoolEntry ("AutoDelayedActions", true);
00381     d->m_jsErrorsEnabled = config->readBoolEntry("ReportJSErrors", true);
00382   }
00383 
00384   // Colors
00385 
00386   if ( reset || config->hasKey( "FollowSystemColors" ) )
00387       d->m_follow_system_colors = config->readBoolEntry( "FollowSystemColors", false );
00388 
00389   if ( reset || config->hasGroup( "General" ) )
00390   {
00391     config->setGroup( "General" ); // group will be restored by cgs anyway
00392     if ( reset || config->hasKey( "foreground" ) )
00393       d->m_textColor = config->readColorEntry( "foreground", &HTML_DEFAULT_TXT_COLOR );
00394 
00395     if ( reset || config->hasKey( "linkColor" ) )
00396       d->m_linkColor = config->readColorEntry( "linkColor", &HTML_DEFAULT_LNK_COLOR );
00397 
00398     if ( reset || config->hasKey( "visitedLinkColor" ) )
00399       d->m_vLinkColor = config->readColorEntry( "visitedLinkColor", &HTML_DEFAULT_VLNK_COLOR);
00400 
00401     if ( reset || config->hasKey( "background" ) )
00402       d->m_baseColor = config->readColorEntry( "background", &HTML_DEFAULT_BASE_COLOR);
00403   }
00404 
00405   if( reset || config->hasGroup( "Java/JavaScript Settings" ) )
00406   {
00407     config->setGroup( "Java/JavaScript Settings" );
00408 
00409     // The global setting for JavaScript debugging
00410     // This is currently always enabled by default
00411     if ( reset || config->hasKey( "EnableJavaScriptDebug" ) )
00412       d->m_bEnableJavaScriptDebug = config->readBoolEntry( "EnableJavaScriptDebug", false );
00413 
00414     // The global setting for JavaScript error reporting
00415     if ( reset || config->hasKey( "ReportJavaScriptErrors" ) )
00416       d->m_bEnableJavaScriptErrorReporting = config->readBoolEntry( "ReportJavaScriptErrors", false );
00417 
00418     // Read options from the global "domain"
00419     readDomainSettings(config,reset,true,d->global);
00420 #ifdef DEBUG_SETTINGS
00421     d->global.dump("init global");
00422 #endif
00423 
00424     // The domain-specific settings.
00425 
00426     static const char *const domain_keys[] = {  // always keep order of keys
00427         "ECMADomains", "JavaDomains", "PluginDomains"
00428     };
00429     bool check_old_ecma_settings = true;
00430     bool check_old_java_settings = true;
00431     // merge all domains into one list
00432     QMap<QString,int> domainList;   // why can't Qt have a QSet?
00433     for (unsigned i = 0; i < sizeof domain_keys/sizeof domain_keys[0]; ++i) {
00434       if ( reset || config->hasKey(domain_keys[i]) ) {
00435         if (i == 0) check_old_ecma_settings = false;
00436     else if (i == 1) check_old_java_settings = false;
00437         const QStringList dl = config->readListEntry( domain_keys[i] );
00438     const QMap<QString,int>::Iterator notfound = domainList.end();
00439     QStringList::ConstIterator it = dl.begin();
00440     const QStringList::ConstIterator itEnd = dl.end();
00441     for (; it != itEnd; ++it) {
00442       const QString domain = (*it).lower();
00443       QMap<QString,int>::Iterator pos = domainList.find(domain);
00444       if (pos == notfound) domainList.insert(domain,0);
00445     }/*next it*/
00446       }
00447     }/*next i*/
00448 
00449     if (reset)
00450       d->domainPolicy.clear();
00451 
00452     QString js_group_save = config->group();
00453     {
00454       QMap<QString,int>::ConstIterator it = domainList.begin();
00455       const QMap<QString,int>::ConstIterator itEnd = domainList.end();
00456       for ( ; it != itEnd; ++it)
00457       {
00458         const QString domain = it.key();
00459         config->setGroup(domain);
00460         readDomainSettings(config,reset,false,d->domainPolicy[domain]);
00461 #ifdef DEBUG_SETTINGS
00462         d->domainPolicy[domain].dump("init "+domain);
00463 #endif
00464       }
00465     }
00466     config->setGroup(js_group_save);
00467 
00468     bool check_old_java = true;
00469     if( ( reset || config->hasKey( "JavaDomainSettings" ) )
00470         && check_old_java_settings )
00471     {
00472       check_old_java = false;
00473       const QStringList domainList = config->readListEntry( "JavaDomainSettings" );
00474       QStringList::ConstIterator it = domainList.begin();
00475       const QStringList::ConstIterator itEnd = domainList.end();
00476       for ( ; it != itEnd; ++it)
00477       {
00478         QString domain;
00479         KJavaScriptAdvice javaAdvice;
00480         KJavaScriptAdvice javaScriptAdvice;
00481         splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
00482         setup_per_domain_policy(d,domain).m_bEnableJava =
00483         javaAdvice == KJavaScriptAccept;
00484 #ifdef DEBUG_SETTINGS
00485     setup_per_domain_policy(d,domain).dump("JavaDomainSettings 4 "+domain);
00486 #endif
00487       }
00488     }
00489 
00490     bool check_old_ecma = true;
00491     if( ( reset || config->hasKey( "ECMADomainSettings" ) )
00492     && check_old_ecma_settings )
00493     {
00494       check_old_ecma = false;
00495       const QStringList domainList = config->readListEntry( "ECMADomainSettings" );
00496       QStringList::ConstIterator it = domainList.begin();
00497       const QStringList::ConstIterator itEnd = domainList.end();
00498       for ( ; it != itEnd; ++it)
00499       {
00500         QString domain;
00501         KJavaScriptAdvice javaAdvice;
00502         KJavaScriptAdvice javaScriptAdvice;
00503         splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
00504         setup_per_domain_policy(d,domain).m_bEnableJavaScript =
00505             javaScriptAdvice == KJavaScriptAccept;
00506 #ifdef DEBUG_SETTINGS
00507     setup_per_domain_policy(d,domain).dump("ECMADomainSettings 4 "+domain);
00508 #endif
00509       }
00510     }
00511 
00512     if( ( reset || config->hasKey( "JavaScriptDomainAdvice" ) )
00513              && ( check_old_java || check_old_ecma )
00514          && ( check_old_ecma_settings || check_old_java_settings ) )
00515     {
00516       const QStringList domainList = config->readListEntry( "JavaScriptDomainAdvice" );
00517       QStringList::ConstIterator it = domainList.begin();
00518       const QStringList::ConstIterator itEnd = domainList.end();
00519       for ( ; it != itEnd; ++it)
00520       {
00521         QString domain;
00522         KJavaScriptAdvice javaAdvice;
00523         KJavaScriptAdvice javaScriptAdvice;
00524         splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
00525         if( check_old_java )
00526           setup_per_domain_policy(d,domain).m_bEnableJava =
00527             javaAdvice == KJavaScriptAccept;
00528         if( check_old_ecma )
00529           setup_per_domain_policy(d,domain).m_bEnableJavaScript =
00530             javaScriptAdvice == KJavaScriptAccept;
00531 #ifdef DEBUG_SETTINGS
00532     setup_per_domain_policy(d,domain).dump("JavaScriptDomainAdvice 4 "+domain);
00533 #endif
00534       }
00535 
00536       //save all the settings into the new keywords if they don't exist
00537 #if 0
00538       if( check_old_java )
00539       {
00540         QStringList domainConfig;
00541         PolicyMap::Iterator it;
00542         for( it = d->javaDomainPolicy.begin(); it != d->javaDomainPolicy.end(); ++it )
00543         {
00544           QCString javaPolicy = adviceToStr( it.data() );
00545           QCString javaScriptPolicy = adviceToStr( KJavaScriptDunno );
00546           domainConfig.append(QString::fromLatin1("%1:%2:%3").arg(it.key()).arg(javaPolicy).arg(javaScriptPolicy));
00547         }
00548         config->writeEntry( "JavaDomainSettings", domainConfig );
00549       }
00550 
00551       if( check_old_ecma )
00552       {
00553         QStringList domainConfig;
00554         PolicyMap::Iterator it;
00555         for( it = d->javaScriptDomainPolicy.begin(); it != d->javaScriptDomainPolicy.end(); ++it )
00556         {
00557           QCString javaPolicy = adviceToStr( KJavaScriptDunno );
00558           QCString javaScriptPolicy = adviceToStr( it.data() );
00559           domainConfig.append(QString::fromLatin1("%1:%2:%3").arg(it.key()).arg(javaPolicy).arg(javaScriptPolicy));
00560         }
00561         config->writeEntry( "ECMADomainSettings", domainConfig );
00562       }
00563 #endif
00564     }
00565   }
00566   config->setGroup(group_save);
00567 }
00568 
00569 
00574 static const KPerDomainSettings &lookup_hostname_policy(
00575             const KHTMLSettingsPrivate *d,
00576             const QString& hostname)
00577 {
00578 #ifdef DEBUG_SETTINGS
00579   kdDebug() << "lookup_hostname_policy(" << hostname << ")" << endl;
00580 #endif
00581   if (hostname.isEmpty()) {
00582 #ifdef DEBUG_SETTINGS
00583     d->global.dump("global");
00584 #endif
00585     return d->global;
00586   }
00587 
00588   const PolicyMap::const_iterator notfound = d->domainPolicy.end();
00589 
00590   // First check whether there is a perfect match.
00591   PolicyMap::const_iterator it = d->domainPolicy.find(hostname);
00592   if( it != notfound ) {
00593 #ifdef DEBUG_SETTINGS
00594     kdDebug() << "perfect match" << endl;
00595     (*it).dump(hostname);
00596 #endif
00597     // yes, use it (unless dunno)
00598     return *it;
00599   }
00600 
00601   // Now, check for partial match.  Chop host from the left until
00602   // there's no dots left.
00603   QString host_part = hostname;
00604   int dot_idx = -1;
00605   while( (dot_idx = host_part.find(QChar('.'))) >= 0 ) {
00606     host_part.remove(0,dot_idx);
00607     it = d->domainPolicy.find(host_part);
00608     Q_ASSERT(notfound == d->domainPolicy.end());
00609     if( it != notfound ) {
00610 #ifdef DEBUG_SETTINGS
00611       kdDebug() << "partial match" << endl;
00612       (*it).dump(host_part);
00613 #endif
00614       return *it;
00615     }
00616     // assert(host_part[0] == QChar('.'));
00617     host_part.remove(0,1); // Chop off the dot.
00618   }
00619 
00620   // No domain-specific entry: use global domain
00621 #ifdef DEBUG_SETTINGS
00622   kdDebug() << "no match" << endl;
00623   d->global.dump("global");
00624 #endif
00625   return d->global;
00626 }
00627 
00628 bool KHTMLSettings::isOpenMiddleClickEnabled()
00629 {
00630   return d->m_bOpenMiddleClick;
00631 }
00632 
00633 bool KHTMLSettings::isBackRightClickEnabled()
00634 {
00635   return d->m_bBackRightClick;
00636 }
00637 
00638 bool KHTMLSettings::isJavaEnabled( const QString& hostname )
00639 {
00640   return lookup_hostname_policy(d,hostname.lower()).m_bEnableJava;
00641 }
00642 
00643 bool KHTMLSettings::isJavaScriptEnabled( const QString& hostname )
00644 {
00645   return lookup_hostname_policy(d,hostname.lower()).m_bEnableJavaScript;
00646 }
00647 
00648 bool KHTMLSettings::isJavaScriptDebugEnabled( const QString& /*hostname*/ )
00649 {
00650   // debug setting is global for now, but could change in the future
00651   return d->m_bEnableJavaScriptDebug;
00652 }
00653 
00654 bool KHTMLSettings::isJavaScriptErrorReportingEnabled( const QString& /*hostname*/ ) const
00655 {
00656   // error reporting setting is global for now, but could change in the future
00657   return d->m_bEnableJavaScriptErrorReporting;
00658 }
00659 
00660 bool KHTMLSettings::isPluginsEnabled( const QString& hostname )
00661 {
00662   return lookup_hostname_policy(d,hostname.lower()).m_bEnablePlugins;
00663 }
00664 
00665 KHTMLSettings::KJSWindowOpenPolicy KHTMLSettings::windowOpenPolicy(
00666                 const QString& hostname) const {
00667   return lookup_hostname_policy(d,hostname.lower()).m_windowOpenPolicy;
00668 }
00669 
00670 KHTMLSettings::KJSWindowMovePolicy KHTMLSettings::windowMovePolicy(
00671                 const QString& hostname) const {
00672   return lookup_hostname_policy(d,hostname.lower()).m_windowMovePolicy;
00673 }
00674 
00675 KHTMLSettings::KJSWindowResizePolicy KHTMLSettings::windowResizePolicy(
00676                 const QString& hostname) const {
00677   return lookup_hostname_policy(d,hostname.lower()).m_windowResizePolicy;
00678 }
00679 
00680 KHTMLSettings::KJSWindowStatusPolicy KHTMLSettings::windowStatusPolicy(
00681                 const QString& hostname) const {
00682   return lookup_hostname_policy(d,hostname.lower()).m_windowStatusPolicy;
00683 }
00684 
00685 KHTMLSettings::KJSWindowFocusPolicy KHTMLSettings::windowFocusPolicy(
00686                 const QString& hostname) const {
00687   return lookup_hostname_policy(d,hostname.lower()).m_windowFocusPolicy;
00688 }
00689 
00690 int KHTMLSettings::mediumFontSize() const
00691 {
00692     return d->m_fontSize;
00693 }
00694 
00695 int KHTMLSettings::minFontSize() const
00696 {
00697   return d->m_minFontSize;
00698 }
00699 
00700 QString KHTMLSettings::settingsToCSS() const
00701 {
00702     // lets start with the link properties
00703     QString str = "a:link {\ncolor: ";
00704     str += d->m_linkColor.name();
00705     str += ";";
00706     if(d->m_underlineLink)
00707         str += "\ntext-decoration: underline;";
00708 
00709     if( d->m_bChangeCursor )
00710     {
00711         str += "\ncursor: pointer;";
00712         str += "\n}\ninput[type=image] { cursor: pointer;";
00713     }
00714     str += "\n}\n";
00715     str += "a:visited {\ncolor: ";
00716     str += d->m_vLinkColor.name();
00717     str += ";";
00718     if(d->m_underlineLink)
00719         str += "\ntext-decoration: underline;";
00720 
00721     if( d->m_bChangeCursor )
00722         str += "\ncursor: pointer;";
00723     str += "\n}\n";
00724 
00725     if(d->m_hoverLink)
00726         str += "a:link:hover, a:visited:hover { text-decoration: underline; }\n";
00727 
00728     return str;
00729 }
00730 
00731 const QString &KHTMLSettings::availableFamilies()
00732 {
00733     if ( !avFamilies ) {
00734         avFamilies = new QString;
00735         QFontDatabase db;
00736         QStringList families = db.families();
00737         QStringList s;
00738         QRegExp foundryExp(" \\[.+\\]");
00739 
00740         //remove foundry info
00741         QStringList::Iterator f = families.begin();
00742         const QStringList::Iterator fEnd = families.end();
00743 
00744         for ( ; f != fEnd; ++f ) {
00745                 (*f).replace( foundryExp, "");
00746                 if (!s.contains(*f))
00747                         s << *f;
00748         }
00749         s.sort();
00750 
00751         *avFamilies = ',' + s.join(",") + ',';
00752     }
00753 
00754   return *avFamilies;
00755 }
00756 
00757 QString KHTMLSettings::lookupFont(int i) const
00758 {
00759     QString font;
00760     if (d->fonts.count() > (uint) i)
00761        font = d->fonts[i];
00762     if (font.isEmpty())
00763         font = d->defaultFonts[i];
00764     return font;
00765 }
00766 
00767 QString KHTMLSettings::stdFontName() const
00768 {
00769     return lookupFont(0);
00770 }
00771 
00772 QString KHTMLSettings::fixedFontName() const
00773 {
00774     return lookupFont(1);
00775 }
00776 
00777 QString KHTMLSettings::serifFontName() const
00778 {
00779     return lookupFont(2);
00780 }
00781 
00782 QString KHTMLSettings::sansSerifFontName() const
00783 {
00784     return lookupFont(3);
00785 }
00786 
00787 QString KHTMLSettings::cursiveFontName() const
00788 {
00789     return lookupFont(4);
00790 }
00791 
00792 QString KHTMLSettings::fantasyFontName() const
00793 {
00794     return lookupFont(5);
00795 }
00796 
00797 void KHTMLSettings::setStdFontName(const QString &n)
00798 {
00799     while(d->fonts.count() <= 0)
00800         d->fonts.append(QString::null);
00801     d->fonts[0] = n;
00802 }
00803 
00804 void KHTMLSettings::setFixedFontName(const QString &n)
00805 {
00806     while(d->fonts.count() <= 1)
00807         d->fonts.append(QString::null);
00808     d->fonts[1] = n;
00809 }
00810 
00811 QString KHTMLSettings::userStyleSheet() const
00812 {
00813     return d->m_userSheet;
00814 }
00815 
00816 bool KHTMLSettings::isFormCompletionEnabled() const
00817 {
00818   return d->m_formCompletionEnabled;
00819 }
00820 
00821 int KHTMLSettings::maxFormCompletionItems() const
00822 {
00823   return d->m_maxFormCompletionItems;
00824 }
00825 
00826 const QString &KHTMLSettings::encoding() const
00827 {
00828   return d->m_encoding;
00829 }
00830 
00831 bool KHTMLSettings::followSystemColors() const
00832 {
00833     return d->m_follow_system_colors;
00834 }
00835 
00836 const QColor& KHTMLSettings::textColor() const
00837 {
00838   return d->m_textColor;
00839 }
00840 
00841 const QColor& KHTMLSettings::baseColor() const
00842 {
00843   return d->m_baseColor;
00844 }
00845 
00846 const QColor& KHTMLSettings::linkColor() const
00847 {
00848   return d->m_linkColor;
00849 }
00850 
00851 const QColor& KHTMLSettings::vLinkColor() const
00852 {
00853   return d->m_vLinkColor;
00854 }
00855 
00856 bool KHTMLSettings::autoLoadImages() const
00857 {
00858   return d->m_bAutoLoadImages;
00859 }
00860 
00861 bool KHTMLSettings::unfinishedImageFrame() const
00862 {
00863   return d->m_bUnfinishedImageFrame;
00864 }
00865 
00866 KHTMLSettings::KAnimationAdvice KHTMLSettings::showAnimations() const
00867 {
00868   return d->m_showAnimations;
00869 }
00870 
00871 bool KHTMLSettings::isAutoDelayedActionsEnabled() const
00872 {
00873   return d->m_autoDelayedActionsEnabled;
00874 }
00875 
00876 bool KHTMLSettings::jsErrorsEnabled() const
00877 {
00878   return d->m_jsErrorsEnabled;
00879 }
00880 
00881 void KHTMLSettings::setJSErrorsEnabled(bool enabled)
00882 {
00883   d->m_jsErrorsEnabled = enabled;
00884   // save it
00885   KConfig *config = KGlobal::config();
00886   config->setGroup("HTML Settings");
00887   config->writeEntry("ReportJSErrors", enabled);
00888   config->sync();
00889 }
00890 
00891 bool KHTMLSettings::allowTabulation() const
00892 {
00893     return d->m_allowTabulation;
00894 }
00895 
00896 bool KHTMLSettings::autoSpellCheck() const
00897 {
00898     return d->m_autoSpellCheck;
00899 }
KDE Logo
This file is part of the documentation for khtml Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jul 2 13:09:46 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003