WebKit/qt/Api/qwebsettings.cpp

   1 /*
   2     Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
   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 "config.h"
  21 #include "qwebsettings.h"
  22
  23 #include "qwebpage.h"
  24 #include "qwebpage_p.h"
  25
  26 #include "Cache.h"
  27 #include "Page.h"
  28 #include "PageCache.h"
  29 #include "Settings.h"
  30 #include "KURL.h"
  31 #include "PlatformString.h"
  32 #include "IconDatabase.h"
  33 #include "Image.h"
  34 #include "IntSize.h"
  35 #include "ApplicationCacheStorage.h"
  36 #include "DatabaseTracker.h"
  37
  38 #include <QHash>
  39 #include <QSharedData>
  40 #include <QUrl>
  41 #include <QFileInfo>
  42
  43 class QWebSettingsPrivate
  44 {
  45 public:
  46     QWebSettingsPrivate(WebCore::Settings *wcSettings = 0)
  47         : settings(wcSettings)
  48     {
  49     }
  50
  51     QHash<int, QString> fontFamilies;
  52     QHash<int, int> fontSizes;
  53     QHash<int, bool> attributes;
  54     QUrl userStyleSheetLocation;
  55     QString localStorageDatabasePath;
  56     QString offlineWebApplicationCachePath;
  57     qint64 offlineStorageDefaultQuota;
  58
  59     void apply();
  60     WebCore::Settings *settings;
  61 };
  62
  63 typedef QHash<int, QPixmap> WebGraphicHash;
  64 Q_GLOBAL_STATIC(WebGraphicHash, _graphics)
  65
  66 static WebGraphicHash* graphics()
  67 {
  68     WebGraphicHash* hash = _graphics();
  69
  70     if (hash->isEmpty()) {
  71         hash->insert(QWebSettings::MissingImageGraphic, QPixmap(QLatin1String(":webkit/resources/missingImage.png")));
  72         hash->insert(QWebSettings::MissingPluginGraphic, QPixmap(QLatin1String(":webkit/resources/nullPlugin.png")));
  73         hash->insert(QWebSettings::DefaultFrameIconGraphic, QPixmap(QLatin1String(":webkit/resources/urlIcon.png")));
  74         hash->insert(QWebSettings::TextAreaSizeGripCornerGraphic, QPixmap(QLatin1String(":webkit/resources/textAreaResizeCorner.png")));
  75     }
  76
  77     return hash;
  78 }
  79
  80 Q_GLOBAL_STATIC(QList<QWebSettingsPrivate *>, allSettings);
  81
  82 void QWebSettingsPrivate::apply()
  83 {
  84     if (settings) {
  85         settings->setTextAreasAreResizable(true);
  86
  87         QWebSettingsPrivate *global = QWebSettings::globalSettings()->d;
  88
  89         QString family = fontFamilies.value(QWebSettings::StandardFont,
  90                                             global->fontFamilies.value(QWebSettings::StandardFont));
  91         settings->setStandardFontFamily(family);
  92
  93         family = fontFamilies.value(QWebSettings::FixedFont,
  94                                     global->fontFamilies.value(QWebSettings::FixedFont));
  95         settings->setFixedFontFamily(family);
  96
  97         family = fontFamilies.value(QWebSettings::SerifFont,
  98                                     global->fontFamilies.value(QWebSettings::SerifFont));
  99         settings->setSerifFontFamily(family);
 100
 101         family = fontFamilies.value(QWebSettings::SansSerifFont,
 102                                     global->fontFamilies.value(QWebSettings::SansSerifFont));
 103         settings->setSansSerifFontFamily(family);
 104
 105         family = fontFamilies.value(QWebSettings::CursiveFont,
 106                                     global->fontFamilies.value(QWebSettings::CursiveFont));
 107         settings->setCursiveFontFamily(family);
 108
 109         family = fontFamilies.value(QWebSettings::FantasyFont,
 110                                     global->fontFamilies.value(QWebSettings::FantasyFont));
 111         settings->setFantasyFontFamily(family);
 112
 113         int size = fontSizes.value(QWebSettings::MinimumFontSize,
 114                                    global->fontSizes.value(QWebSettings::MinimumFontSize));
 115         settings->setMinimumFontSize(size);
 116
 117         size = fontSizes.value(QWebSettings::MinimumLogicalFontSize,
 118                                    global->fontSizes.value(QWebSettings::MinimumLogicalFontSize));
 119         settings->setMinimumLogicalFontSize(size);
 120
 121         size = fontSizes.value(QWebSettings::DefaultFontSize,
 122                                    global->fontSizes.value(QWebSettings::DefaultFontSize));
 123         settings->setDefaultFontSize(size);
 124
 125         size = fontSizes.value(QWebSettings::DefaultFixedFontSize,
 126                                    global->fontSizes.value(QWebSettings::DefaultFixedFontSize));
 127         settings->setDefaultFixedFontSize(size);
 128
 129         bool value = attributes.value(QWebSettings::AutoLoadImages,
 130                                       global->attributes.value(QWebSettings::AutoLoadImages));
 131         settings->setLoadsImagesAutomatically(value);
 132
 133         value = attributes.value(QWebSettings::JavascriptEnabled,
 134                                       global->attributes.value(QWebSettings::JavascriptEnabled));
 135         settings->setJavaScriptEnabled(value);
 136
 137         value = attributes.value(QWebSettings::JavascriptCanOpenWindows,
 138                                       global->attributes.value(QWebSettings::JavascriptCanOpenWindows));
 139         settings->setJavaScriptCanOpenWindowsAutomatically(value);
 140
 141         value = attributes.value(QWebSettings::JavaEnabled,
 142                                       global->attributes.value(QWebSettings::JavaEnabled));
 143         settings->setJavaEnabled(value);
 144
 145         value = attributes.value(QWebSettings::PluginsEnabled,
 146                                       global->attributes.value(QWebSettings::PluginsEnabled));
 147         settings->setPluginsEnabled(value);
 148
 149         value = attributes.value(QWebSettings::PrivateBrowsingEnabled,
 150                                       global->attributes.value(QWebSettings::PrivateBrowsingEnabled));
 151         settings->setPrivateBrowsingEnabled(value);
 152
 153         value = attributes.value(QWebSettings::JavascriptCanAccessClipboard,
 154                                       global->attributes.value(QWebSettings::JavascriptCanAccessClipboard));
 155         settings->setDOMPasteAllowed(value);
 156
 157         value = attributes.value(QWebSettings::DeveloperExtrasEnabled,
 158                                       global->attributes.value(QWebSettings::DeveloperExtrasEnabled));
 159         settings->setDeveloperExtrasEnabled(value);
 160
 161         QUrl location = !userStyleSheetLocation.isEmpty() ? userStyleSheetLocation : global->userStyleSheetLocation;
 162         settings->setUserStyleSheetLocation(WebCore::KURL(location));
 163
 164         QString localStoragePath = !localStorageDatabasePath.isEmpty() ? localStorageDatabasePath : global->localStorageDatabasePath;
 165         settings->setLocalStorageDatabasePath(localStoragePath);
 166
 167         value = attributes.value(QWebSettings::ZoomTextOnly,
 168                                  global->attributes.value(QWebSettings::ZoomTextOnly));
 169         settings->setZoomsTextOnly(value);
 170
 171         value = attributes.value(QWebSettings::PrintElementBackgrounds,
 172                                       global->attributes.value(QWebSettings::PrintElementBackgrounds));
 173         settings->setShouldPrintBackgrounds(value);
 174
 175         value = attributes.value(QWebSettings::OfflineStorageDatabaseEnabled,
 176                                       global->attributes.value(QWebSettings::OfflineStorageDatabaseEnabled));
 177         settings->setDatabasesEnabled(value);
 178
 179         value = attributes.value(QWebSettings::OfflineWebApplicationCacheEnabled,
 180                                       global->attributes.value(QWebSettings::OfflineWebApplicationCacheEnabled));
 181         settings->setOfflineWebApplicationCacheEnabled(value);
 182
 183         value = attributes.value(QWebSettings::LocalStorageDatabaseEnabled,
 184                                       global->attributes.value(QWebSettings::LocalStorageDatabaseEnabled));
 185         settings->setLocalStorageEnabled(value);
 186     } else {
 187         QList<QWebSettingsPrivate *> settings = *::allSettings();
 188         for (int i = 0; i < settings.count(); ++i)
 189             settings[i]->apply();
 190     }
 191 }
 192
 193 /*!
 194     Returns the global settings object.
 195
 196     Any setting changed on the default object is automatically applied to all
 197     QWebPage instances where the particular setting is not overriden already.
 198 */
 199 QWebSettings *QWebSettings::globalSettings()
 200 {
 201     static QWebSettings *global = 0;
 202     if (!global)
 203         global = new QWebSettings;
 204     return global;
 205 }
 206
 207 /*!
 208     \class QWebSettings
 209     \since 4.4
 210     \brief The QWebSettings class provides an object to store the settings used
 211     by QWebPage and QWebFrame.
 212
 213     Each QWebPage object has its own QWebSettings object, which configures the
 214     settings for that page. If a setting is not configured, then it is looked
 215     up in the global settings object, which can be accessed using
 216     QWebSettings::globalSettings().
 217
 218     QWebSettings allows configuring font properties such as font size and font
 219     family, the location of a custom stylesheet, and generic attributes like java
 220     script, plugins, etc. The \l{QWebSettings::WebAttribute}{WebAttribute}
 221     enum further describes this.
 222
 223     QWebSettings also configures global properties such as the web page memory
 224     cache and the web page icon database, local database storage and offline
 225     applications storage.
 226
 227     \section1 Web Application Support
 228
 229     WebKit provides support for features specified in \l{HTML 5} that improve the
 230     performance and capabilities of Web applications. These include client-side
 231     (offline) storage and the use of a Web application cache.
 232
 233     Client-side (offline) storage is an improvement over the use of cookies to
 234     store persistent data in Web applications. Applications can configure and
 235     enable the use of an offline storage database by calling the
 236     setOfflineStoragePath() with an appropriate file path, and can limit the quota
 237     for each application by calling setOfflineStorageDefaultQuota().
 238
 239     \sa QWebPage::settings(), QWebView::settings(), {Browser}
 240 */
 241
 242 /*!
 243     \enum QWebSettings::FontFamily
 244
 245     This enum describes the generic font families defined by CSS 2.
 246     For more information see the
 247     \l{http://www.w3.org/TR/REC-CSS2/fonts.html#generic-font-families}{CSS standard}.
 248
 249     \value StandardFont
 250     \value FixedFont
 251     \value SerifFont
 252     \value SansSerifFont
 253     \value CursiveFont
 254     \value FantasyFont
 255 */
 256
 257 /*!
 258     \enum QWebSettings::FontSize
 259
 260     This enum describes the font sizes configurable through QWebSettings.
 261
 262     \value MinimumFontSize The hard minimum font size.
 263     \value MinimumLogicalFontSize The minimum logical font size that is applied
 264         after zooming with QWebFrame's textSizeMultiplier().
 265     \value DefaultFontSize The default font size for regular text.
 266     \value DefaultFixedFontSize The default font size for fixed-pitch text.
 267 */
 268
 269 /*!
 270     \enum QWebSettings::WebGraphic
 271
 272     This enums describes the standard graphical elements used in webpages.
 273
 274     \value MissingImageGraphic The replacement graphic shown when an image could not be loaded.
 275     \value MissingPluginGraphic The replacement graphic shown when a plugin could not be loaded.
 276     \value DefaultFrameIconGraphic The default icon for QWebFrame::icon().
 277     \value TextAreaSizeGripCornerGraphic The graphic shown for the size grip of text areas.
 278 */
 279
 280 /*!
 281     \enum QWebSettings::WebAttribute
 282
 283     This enum describes various attributes that are configurable through QWebSettings.
 284
 285     \value AutoLoadImages Specifies whether images are automatically loaded in
 286         web pages.
 287     \value JavascriptEnabled Enables or disables the running of JavaScript
 288         programs.
 289     \value JavaEnabled Enables or disables Java applets.
 290         Currently Java applets are not supported.
 291     \value PluginsEnabled Enables or disables plugins in web pages.
 292         Currently Flash and other plugins are not supported.
 293     \value PrivateBrowsingEnabled Private browsing prevents WebKit from
 294         recording visited pages in the history and storing web page icons.
 295     \value JavascriptCanOpenWindows Specifies whether JavaScript programs
 296         can open new windows.
 297     \value JavascriptCanAccessClipboard Specifies whether JavaScript programs
 298         can read or write to the clipboard.
 299     \value DeveloperExtrasEnabled Enables extra tools for Web developers.
 300         Currently this enables the "Inspect" element in the context menu,
 301     which shows the WebKit WebInspector for web site debugging.
 302     \value LinksIncludedInFocusChain Specifies whether hyperlinks should be
 303         included in the keyboard focus chain.
 304     \value ZoomTextOnly Specifies whether the zoom factor on a frame applies to
 305         only the text or all content.
 306     \value PrintElementBackgrounds Specifies whether the background color and images
 307         are also drawn when the page is printed.
 308     \value OfflineStorageDatabaseEnabled Specifies whether support for the HTML 5
 309         offline storage feature is enabled or not.
 310     \value OfflineWebApplicationCacheEnabled Specifies whether support for the HTML 5
 311         web application cache feature is enabled or not.
 312     \value LocalStorageDatabaseEnabled Specifies whether support for the HTML 5
 313         local storage feature is enabled or not.
 314 */
 315
 316 /*!
 317     \internal
 318 */
 319 QWebSettings::QWebSettings()
 320     : d(new QWebSettingsPrivate)
 321 {
 322     // Initialize our global defaults
 323     d->fontSizes.insert(QWebSettings::MinimumFontSize, 0);
 324     d->fontSizes.insert(QWebSettings::MinimumLogicalFontSize, 0);
 325     d->fontSizes.insert(QWebSettings::DefaultFontSize, 14);
 326     d->fontSizes.insert(QWebSettings::DefaultFixedFontSize, 14);
 327     d->fontFamilies.insert(QWebSettings::StandardFont, QLatin1String("Arial"));
 328     d->fontFamilies.insert(QWebSettings::FixedFont, QLatin1String("Courier New"));
 329     d->fontFamilies.insert(QWebSettings::SerifFont, QLatin1String("Times New Roman"));
 330     d->fontFamilies.insert(QWebSettings::SansSerifFont, QLatin1String("Arial"));
 331     d->fontFamilies.insert(QWebSettings::CursiveFont, QLatin1String("Arial"));
 332     d->fontFamilies.insert(QWebSettings::FantasyFont, QLatin1String("Arial"));
 333
 334     d->attributes.insert(QWebSettings::AutoLoadImages, true);
 335     d->attributes.insert(QWebSettings::JavascriptEnabled, true);
 336     d->attributes.insert(QWebSettings::LinksIncludedInFocusChain, true);
 337     d->attributes.insert(QWebSettings::ZoomTextOnly, false);
 338     d->attributes.insert(QWebSettings::PrintElementBackgrounds, true);
 339     d->attributes.insert(QWebSettings::OfflineStorageDatabaseEnabled, true);
 340     d->attributes.insert(QWebSettings::OfflineWebApplicationCacheEnabled, true);
 341     d->attributes.insert(QWebSettings::LocalStorageDatabaseEnabled, true);
 342     d->offlineStorageDefaultQuota = 5 * 1024 * 1024;
 343
 344 }
 345
 346 /*!
 347     \internal
 348 */
 349 QWebSettings::QWebSettings(WebCore::Settings *settings)
 350     : d(new QWebSettingsPrivate(settings))
 351 {
 352     d->settings = settings;
 353     d->apply();
 354     allSettings()->append(d);
 355 }
 356
 357 /*!
 358     \internal
 359 */
 360 QWebSettings::~QWebSettings()
 361 {
 362     if (d->settings)
 363         allSettings()->removeAll(d);
 364
 365     delete d;
 366 }
 367
 368 /*!
 369     Sets the font size for \a type to \a size.
 370 */
 371 void QWebSettings::setFontSize(FontSize type, int size)
 372 {
 373     d->fontSizes.insert(type, size);
 374     d->apply();
 375 }
 376
 377 /*!
 378     Returns the default font size for \a type.
 379 */
 380 int QWebSettings::fontSize(FontSize type) const
 381 {
 382     int defaultValue = 0;
 383     if (d->settings) {
 384         QWebSettingsPrivate *global = QWebSettings::globalSettings()->d;
 385         defaultValue = global->fontSizes.value(type);
 386     }
 387     return d->fontSizes.value(type, defaultValue);
 388 }
 389
 390 /*!
 391     Resets the font size for \a type to the size specified in the global
 392     settings object.
 393
 394     This function has no effect on the global QWebSettings instance.
 395 */
 396 void QWebSettings::resetFontSize(FontSize type)
 397 {
 398     if (d->settings) {
 399         d->fontSizes.remove(type);
 400         d->apply();
 401     }
 402 }
 403
 404 /*!
 405     Specifies the location of a user stylesheet to load with every web page.
 406
 407     The \a location can be a URL or a path on the local filesystem.
 408
 409     \sa userStyleSheetUrl()
 410 */
 411 void QWebSettings::setUserStyleSheetUrl(const QUrl &location)
 412 {
 413     d->userStyleSheetLocation = location;
 414     d->apply();
 415 }
 416
 417 /*!
 418     Returns the location of the user stylesheet.
 419
 420     \sa setUserStyleSheetUrl()
 421 */
 422 QUrl QWebSettings::userStyleSheetUrl() const
 423 {
 424     return d->userStyleSheetLocation;
 425 }
 426
 427 /*!
 428     Sets the path of the icon database to \a path. The icon database is used
 429     to store "favicons" associated with web sites.
 430
 431     \a path must point to an existing directory where the icons are stored.
 432
 433     Setting an empty path disables the icon database.
 434 */
 435 void QWebSettings::setIconDatabasePath(const QString &path)
 436 {
 437     WebCore::iconDatabase()->delayDatabaseCleanup();
 438
 439     if (!path.isEmpty()) {
 440         WebCore::iconDatabase()->setEnabled(true);
 441         QFileInfo info(path);
 442         if (info.isDir() && info.isWritable())
 443             WebCore::iconDatabase()->open(path);
 444     } else {
 445         WebCore::iconDatabase()->setEnabled(false);
 446         WebCore::iconDatabase()->close();
 447     }
 448 }
 449
 450 /*!
 451     Returns the path of the icon database or an empty string if the icon
 452     database is disabled.
 453
 454     \sa setIconDatabasePath(), clearIconDatabase()
 455 */
 456 QString QWebSettings::iconDatabasePath()
 457 {
 458     if (WebCore::iconDatabase()->isEnabled() && WebCore::iconDatabase()->isOpen()) {
 459         return WebCore::iconDatabase()->databasePath();
 460     } else {
 461         return QString();
 462     }
 463 }
 464
 465 /*!
 466     Clears the icon database.
 467 */
 468 void QWebSettings::clearIconDatabase()
 469 {
 470     if (WebCore::iconDatabase()->isEnabled() && WebCore::iconDatabase()->isOpen())
 471         WebCore::iconDatabase()->removeAllIcons();
 472 }
 473
 474 /*!
 475     Returns the web site's icon for \a url.
 476
 477     If the web site does not specify an icon, or the icon is not in the
 478     database, a null QIcon is returned.
 479
 480     \note The returned icon's size is arbitrary.
 481
 482     \sa setIconDatabasePath()
 483 */
 484 QIcon QWebSettings::iconForUrl(const QUrl &url)
 485 {
 486     WebCore::Image* image = WebCore::iconDatabase()->iconForPageURL(WebCore::KURL(url).string(),
 487                                 WebCore::IntSize(16, 16));
 488     if (!image) {
 489         return QPixmap();
 490     }
 491     QPixmap *icon = image->nativeImageForCurrentFrame();
 492     if (!icon) {
 493         return QPixmap();
 494     }
 495     return *icon;
 496 }
 497
 498 /*!
 499     Sets \a graphic to be drawn when QtWebKit needs to draw an image of the
 500     given \a type.
 501
 502     For example, when an image cannot be loaded the pixmap specified by
 503     \l{QWebSettings::WebGraphic}{MissingImageGraphic} is drawn instead.
 504
 505     \sa webGraphic()
 506 */
 507 void QWebSettings::setWebGraphic(WebGraphic type, const QPixmap &graphic)
 508 {
 509     WebGraphicHash *h = graphics();
 510     if (graphic.isNull())
 511         h->remove(type);
 512     else
 513         h->insert(type, graphic);
 514 }
 515
 516 /*!
 517     Returns a previously set pixmap used to draw replacement graphics of the
 518     specified \a type.
 519
 520     For example, when an image cannot be loaded the pixmap specified by
 521     \l{QWebSettings::WebGraphic}{MissingImageGraphic} is drawn instead.
 522
 523     \sa setWebGraphic()
 524 */
 525 QPixmap QWebSettings::webGraphic(WebGraphic type)
 526 {
 527     return graphics()->value(type);
 528 }
 529
 530 /*!
 531     Sets the maximum number of pages to hold in the memory cache to \a pages.
 532 */
 533 void QWebSettings::setMaximumPagesInCache(int pages)
 534 {
 535     WebCore::pageCache()->setCapacity(qMax(0, pages));
 536 }
 537
 538 /*!
 539     Returns the maximum number of web pages that are kept in the memory cache.
 540 */
 541 int QWebSettings::maximumPagesInCache()
 542 {
 543     return WebCore::pageCache()->capacity();
 544 }
 545
 546 /*!
 547    Specifies the capacities for the memory cache for dead objects such as
 548    stylesheets or scripts.
 549
 550    The \a cacheMinDeadCapacity specifies the \e minimum number of bytes that
 551    dead objects should consume when the cache is under pressure.
 552
 553    \a cacheMaxDead is the \e maximum number of bytes that dead objects should
 554    consume when the cache is \bold not under pressure.
 555
 556    \a totalCapacity specifies the \e maximum number of bytes that the cache
 557    should consume \bold overall.
 558
 559    The cache is enabled by default. Calling setObjectCacheCapacities(0, 0, 0)
 560    will disable the cache. Calling it with one non-zero enables it again.
 561 */
 562 void QWebSettings::setObjectCacheCapacities(int cacheMinDeadCapacity, int cacheMaxDead, int totalCapacity)
 563 {
 564     bool disableCache = cacheMinDeadCapacity == 0 && cacheMaxDead == 0 && totalCapacity == 0;
 565     WebCore::cache()->setDisabled(disableCache);
 566
 567     WebCore::cache()->setCapacities(qMax(0, cacheMinDeadCapacity),
 568                                     qMax(0, cacheMaxDead),
 569                                     qMax(0, totalCapacity));
 570 }
 571
 572 /*!
 573     Sets the actual font family to \a family for the specified generic family,
 574     \a which.
 575 */
 576 void QWebSettings::setFontFamily(FontFamily which, const QString &family)
 577 {
 578     d->fontFamilies.insert(which, family);
 579     d->apply();
 580 }
 581
 582 /*!
 583     Returns the actual font family for the specified generic font family,
 584     \a which.
 585 */
 586 QString QWebSettings::fontFamily(FontFamily which) const
 587 {
 588     QString defaultValue;
 589     if (d->settings) {
 590         QWebSettingsPrivate *global = QWebSettings::globalSettings()->d;
 591         defaultValue = global->fontFamilies.value(which);
 592     }
 593     return d->fontFamilies.value(which, defaultValue);
 594 }
 595
 596 /*!
 597     Resets the actual font family to the default font family, specified by
 598     \a which.
 599
 600     This function has no effect on the global QWebSettings instance.
 601 */
 602 void QWebSettings::resetFontFamily(FontFamily which)
 603 {
 604     if (d->settings) {
 605         d->fontFamilies.remove(which);
 606         d->apply();
 607     }
 608 }
 609
 610 /*!
 611     \fn void QWebSettings::setAttribute(WebAttribute attribute, bool on)
 612
 613     Enables or disables the specified \a attribute feature depending on the
 614     value of \a on.
 615 */
 616 void QWebSettings::setAttribute(WebAttribute attr, bool on)
 617 {
 618     d->attributes.insert(attr, on);
 619     d->apply();
 620 }
 621
 622 /*!
 623     \fn bool QWebSettings::testAttribute(WebAttribute attribute) const
 624
 625     Returns true if \a attribute is enabled; otherwise returns false.
 626 */
 627 bool QWebSettings::testAttribute(WebAttribute attr) const
 628 {
 629     bool defaultValue = false;
 630     if (d->settings) {
 631         QWebSettingsPrivate *global = QWebSettings::globalSettings()->d;
 632         defaultValue = global->attributes.value(attr);
 633     }
 634     return d->attributes.value(attr, defaultValue);
 635 }
 636
 637 /*!
 638     \fn void QWebSettings::resetAttribute(WebAttribute attribute)
 639
 640     Resets the setting of \a attribute.
 641     This function has no effect on the global QWebSettings instance.
 642
 643     \sa globalSettings()
 644 */
 645 void QWebSettings::resetAttribute(WebAttribute attr)
 646 {
 647     if (d->settings) {
 648         d->attributes.remove(attr);
 649         d->apply();
 650     }
 651 }
 652
 653 /*!
 654     \since 4.5
 655
 656     Sets the path for HTML5 offline storage to \a path.
 657
 658     \a path must point to an existing directory where the databases are stored.
 659
 660     Setting an empty path disables the feature.
 661
 662     \sa offlineStoragePath()
 663 */
 664 void QWebSettings::setOfflineStoragePath(const QString& path)
 665 {
 666 #if ENABLE(DATABASE)
 667     WebCore::DatabaseTracker::tracker().setDatabaseDirectoryPath(path);
 668 #endif
 669 }
 670
 671 /*!
 672     \since 4.5
 673
 674     Returns the path of the HTML5 offline storage or an empty string if the
 675     feature is disabled.
 676
 677     \sa setOfflineStoragePath()
 678 */
 679 QString QWebSettings::offlineStoragePath()
 680 {
 681 #if ENABLE(DATABASE)
 682     return WebCore::DatabaseTracker::tracker().databaseDirectoryPath();
 683 #else
 684     return QString();
 685 #endif
 686 }
 687
 688 /*!
 689     \since 4.5
 690
 691     Sets the value of the default quota for new offline storage databases
 692     to \a maximumSize.
 693 */
 694 void QWebSettings::setOfflineStorageDefaultQuota(qint64 maximumSize)
 695 {
 696     QWebSettings::globalSettings()->d->offlineStorageDefaultQuota = maximumSize;
 697 }
 698
 699 /*!
 700     \since 4.5
 701
 702     Returns the value of the default quota for new offline storage databases.
 703 */
 704 qint64 QWebSettings::offlineStorageDefaultQuota()
 705 {
 706     return QWebSettings::globalSettings()->d->offlineStorageDefaultQuota;
 707 }
 708
 709 /*
 710     \internal
 711     \relates QWebSettings
 712
 713     Sets the path for HTML5 offline web application cache storage to \a path.
 714
 715     \a path must point to an existing directory where the cache is stored.
 716
 717     Setting an empty path disables the feature.
 718
 719     \sa offlineWebApplicationCachePath()
 720 */
 721 void QWEBKIT_EXPORT qt_websettings_setOfflineWebApplicationCachePath(const QString& path)
 722 {
 723 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
 724     WebCore::cacheStorage().setCacheDirectory(path);
 725 #endif
 726 }
 727
 728 /*
 729     \internal
 730     \relates QWebSettings
 731
 732     Returns the path of the HTML5 offline web application cache storage
 733     or an empty string if the feature is disabled.
 734
 735     \sa setOfflineWebApplicationCachePath()
 736 */
 737 QString QWEBKIT_EXPORT qt_websettings_offlineWebApplicationCachePath()
 738 {
 739 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
 740     return WebCore::cacheStorage().cacheDirectory();
 741 #else
 742     return QString();
 743 #endif
 744 }
 745
 746 /*
 747     \since 4.5
 748     \relates QWebSettings
 749
 750     Sets the path for HTML5 local storage databases to \a path.
 751
 752     \a path must point to an existing directory where the cache is stored.
 753
 754     Setting an empty path disables the feature.
 755
 756     \sa localStorageDatabasePath()
 757 */
 758 void QWEBKIT_EXPORT qt_websettings_setLocalStorageDatabasePath(QWebSettings* settings, const QString& path)
 759 {
 760     QWebSettingsPrivate *d = settings->handle();
 761     d->localStorageDatabasePath = path;
 762     d->apply();
 763 }
 764
 765 /*
 766     \since 4.5
 767     \relates QWebSettings
 768
 769     Returns the path for HTML5 local storage databases
 770     or an empty string if the feature is disabled.
 771
 772     \sa setLocalStorageDatabasePath()
 773 */
 774 QString QWEBKIT_EXPORT qt_websettings_localStorageDatabasePath(QWebSettings* settings)
 775 {
 776     return settings->handle()->localStorageDatabasePath;
 777 }
 778
 779 /*!
 780     \fn QWebSettingsPrivate* QWebSettings::handle() const
 781     \internal
 782 */