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