diff -r 000000000000 -r 4f2f89ce4247 WebKit/qt/Api/qwebsettings.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/WebKit/qt/Api/qwebsettings.cpp Fri Sep 17 09:02:29 2010 +0300 @@ -0,0 +1,1081 @@ +/* + Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "config.h" +#include "qwebsettings.h" + +#include "qwebpage.h" +#include "qwebpage_p.h" +#include "qwebplugindatabase_p.h" + +#include "AbstractDatabase.h" +#include "Cache.h" +#include "CrossOriginPreflightResultCache.h" +#include "FontCache.h" +#include "Page.h" +#include "PageCache.h" +#include "Settings.h" +#include "KURL.h" +#include "PlatformString.h" +#include "IconDatabase.h" +#include "Image.h" +#include "IntSize.h" +#include "ApplicationCacheStorage.h" +#include "DatabaseTracker.h" +#include "FileSystem.h" + +#include +#include +#include +#include +#include +#include +#include + +#include "NetworkStateNotifier.h" + +void QWEBKIT_EXPORT qt_networkAccessAllowed(bool isAllowed) +{ +#if ENABLE(QT_BEARER) + WebCore::networkStateNotifier().setNetworkAccessAllowed(isAllowed); +#endif +} + +class QWebSettingsPrivate { +public: + QWebSettingsPrivate(WebCore::Settings* wcSettings = 0) + : settings(wcSettings) + { + } + + QHash fontFamilies; + QHash fontSizes; + QHash attributes; + QUrl userStyleSheetLocation; + QString defaultTextEncoding; + QString localStoragePath; + QString offlineWebApplicationCachePath; + qint64 offlineStorageDefaultQuota; + + void apply(); + WebCore::Settings* settings; +}; + +typedef QHash WebGraphicHash; +Q_GLOBAL_STATIC(WebGraphicHash, _graphics) + +static void earlyClearGraphics() +{ + _graphics()->clear(); +} + +static WebGraphicHash* graphics() +{ + WebGraphicHash* hash = _graphics(); + + if (hash->isEmpty()) { + + // prevent ~QPixmap running after ~QApplication (leaks native pixmaps) + qAddPostRoutine(earlyClearGraphics); + + hash->insert(QWebSettings::MissingImageGraphic, QPixmap(QLatin1String(":webkit/resources/missingImage.png"))); + hash->insert(QWebSettings::MissingPluginGraphic, QPixmap(QLatin1String(":webkit/resources/nullPlugin.png"))); + hash->insert(QWebSettings::DefaultFrameIconGraphic, QPixmap(QLatin1String(":webkit/resources/urlIcon.png"))); + hash->insert(QWebSettings::TextAreaSizeGripCornerGraphic, QPixmap(QLatin1String(":webkit/resources/textAreaResizeCorner.png"))); + hash->insert(QWebSettings::DeleteButtonGraphic, QPixmap(QLatin1String(":webkit/resources/deleteButton.png"))); + hash->insert(QWebSettings::InputSpeechButtonGraphic, QPixmap(QLatin1String(":webkit/resources/inputSpeech.png"))); + } + + return hash; +} + +Q_GLOBAL_STATIC(QList, allSettings); + +void QWebSettingsPrivate::apply() +{ + if (settings) { + settings->setTextAreasAreResizable(true); + + QWebSettingsPrivate* global = QWebSettings::globalSettings()->d; + + QString family = fontFamilies.value(QWebSettings::StandardFont, + global->fontFamilies.value(QWebSettings::StandardFont)); + settings->setStandardFontFamily(family); + + family = fontFamilies.value(QWebSettings::FixedFont, + global->fontFamilies.value(QWebSettings::FixedFont)); + settings->setFixedFontFamily(family); + + family = fontFamilies.value(QWebSettings::SerifFont, + global->fontFamilies.value(QWebSettings::SerifFont)); + settings->setSerifFontFamily(family); + + family = fontFamilies.value(QWebSettings::SansSerifFont, + global->fontFamilies.value(QWebSettings::SansSerifFont)); + settings->setSansSerifFontFamily(family); + + family = fontFamilies.value(QWebSettings::CursiveFont, + global->fontFamilies.value(QWebSettings::CursiveFont)); + settings->setCursiveFontFamily(family); + + family = fontFamilies.value(QWebSettings::FantasyFont, + global->fontFamilies.value(QWebSettings::FantasyFont)); + settings->setFantasyFontFamily(family); + + int size = fontSizes.value(QWebSettings::MinimumFontSize, + global->fontSizes.value(QWebSettings::MinimumFontSize)); + settings->setMinimumFontSize(size); + + size = fontSizes.value(QWebSettings::MinimumLogicalFontSize, + global->fontSizes.value(QWebSettings::MinimumLogicalFontSize)); + settings->setMinimumLogicalFontSize(size); + + size = fontSizes.value(QWebSettings::DefaultFontSize, + global->fontSizes.value(QWebSettings::DefaultFontSize)); + settings->setDefaultFontSize(size); + + size = fontSizes.value(QWebSettings::DefaultFixedFontSize, + global->fontSizes.value(QWebSettings::DefaultFixedFontSize)); + settings->setDefaultFixedFontSize(size); + + bool value = attributes.value(QWebSettings::AutoLoadImages, + global->attributes.value(QWebSettings::AutoLoadImages)); + settings->setLoadsImagesAutomatically(value); + + value = attributes.value(QWebSettings::JavascriptEnabled, + global->attributes.value(QWebSettings::JavascriptEnabled)); + settings->setJavaScriptEnabled(value); +#if USE(ACCELERATED_COMPOSITING) + value = attributes.value(QWebSettings::AcceleratedCompositingEnabled, + global->attributes.value(QWebSettings::AcceleratedCompositingEnabled)); + + settings->setAcceleratedCompositingEnabled(value); +#endif +#if ENABLE(3D_CANVAS) + value = attributes.value(QWebSettings::WebGLEnabled, + global->attributes.value(QWebSettings::WebGLEnabled)); + + settings->setWebGLEnabled(value); +#endif + + value = attributes.value(QWebSettings::JavascriptCanOpenWindows, + global->attributes.value(QWebSettings::JavascriptCanOpenWindows)); + settings->setJavaScriptCanOpenWindowsAutomatically(value); + + value = attributes.value(QWebSettings::JavaEnabled, + global->attributes.value(QWebSettings::JavaEnabled)); + settings->setJavaEnabled(value); + + value = attributes.value(QWebSettings::PluginsEnabled, + global->attributes.value(QWebSettings::PluginsEnabled)); + settings->setPluginsEnabled(value); + + value = attributes.value(QWebSettings::PrivateBrowsingEnabled, + global->attributes.value(QWebSettings::PrivateBrowsingEnabled)); + settings->setPrivateBrowsingEnabled(value); + + value = attributes.value(QWebSettings::SpatialNavigationEnabled, + global->attributes.value(QWebSettings::SpatialNavigationEnabled)); + settings->setSpatialNavigationEnabled(value); + + value = attributes.value(QWebSettings::JavascriptCanAccessClipboard, + global->attributes.value(QWebSettings::JavascriptCanAccessClipboard)); + settings->setDOMPasteAllowed(value); + settings->setJavaScriptCanAccessClipboard(value); + + value = attributes.value(QWebSettings::DeveloperExtrasEnabled, + global->attributes.value(QWebSettings::DeveloperExtrasEnabled)); + settings->setDeveloperExtrasEnabled(value); + + value = attributes.value(QWebSettings::FrameFlatteningEnabled, + global->attributes.value(QWebSettings::FrameFlatteningEnabled)); + settings->setFrameFlatteningEnabled(value); + + QUrl location = !userStyleSheetLocation.isEmpty() ? userStyleSheetLocation : global->userStyleSheetLocation; + settings->setUserStyleSheetLocation(WebCore::KURL(location)); + + QString encoding = !defaultTextEncoding.isEmpty() ? defaultTextEncoding: global->defaultTextEncoding; + settings->setDefaultTextEncodingName(encoding); + + QString storagePath = !localStoragePath.isEmpty() ? localStoragePath : global->localStoragePath; + settings->setLocalStorageDatabasePath(storagePath); + + value = attributes.value(QWebSettings::ZoomTextOnly, + global->attributes.value(QWebSettings::ZoomTextOnly)); + settings->setZoomMode(value ? WebCore::ZoomTextOnly : WebCore::ZoomPage); + + value = attributes.value(QWebSettings::PrintElementBackgrounds, + global->attributes.value(QWebSettings::PrintElementBackgrounds)); + settings->setShouldPrintBackgrounds(value); + +#if ENABLE(DATABASE) + value = attributes.value(QWebSettings::OfflineStorageDatabaseEnabled, + global->attributes.value(QWebSettings::OfflineStorageDatabaseEnabled)); + WebCore::AbstractDatabase::setIsAvailable(value); +#endif + + value = attributes.value(QWebSettings::OfflineWebApplicationCacheEnabled, + global->attributes.value(QWebSettings::OfflineWebApplicationCacheEnabled)); + settings->setOfflineWebApplicationCacheEnabled(value); + + value = attributes.value(QWebSettings::LocalStorageEnabled, + global->attributes.value(QWebSettings::LocalStorageEnabled)); + settings->setLocalStorageEnabled(value); + + value = attributes.value(QWebSettings::LocalContentCanAccessRemoteUrls, + global->attributes.value(QWebSettings::LocalContentCanAccessRemoteUrls)); + settings->setAllowUniversalAccessFromFileURLs(value); + + value = attributes.value(QWebSettings::LocalContentCanAccessFileUrls, + global->attributes.value(QWebSettings::LocalContentCanAccessFileUrls)); + settings->setAllowFileAccessFromFileURLs(value); + + value = attributes.value(QWebSettings::XSSAuditingEnabled, + global->attributes.value(QWebSettings::XSSAuditingEnabled)); + settings->setXSSAuditorEnabled(value); + +#if ENABLE(TILED_BACKING_STORE) + value = attributes.value(QWebSettings::TiledBackingStoreEnabled, + global->attributes.value(QWebSettings::TiledBackingStoreEnabled)); + settings->setTiledBackingStoreEnabled(value); +#endif + + value = attributes.value(QWebSettings::SiteSpecificQuirksEnabled, + global->attributes.value(QWebSettings::SiteSpecificQuirksEnabled)); + settings->setNeedsSiteSpecificQuirks(value); + + settings->setUsesPageCache(WebCore::pageCache()->capacity()); + } else { + QList settings = *::allSettings(); + for (int i = 0; i < settings.count(); ++i) + settings[i]->apply(); + } +} + +/*! + Returns the global settings object. + + Any setting changed on the default object is automatically applied to all + QWebPage instances where the particular setting is not overriden already. +*/ +QWebSettings* QWebSettings::globalSettings() +{ + static QWebSettings* global = 0; + if (!global) + global = new QWebSettings; + return global; +} + +/*! + \class QWebSettings + \since 4.4 + \brief The QWebSettings class provides an object to store the settings used + by QWebPage and QWebFrame. + + \inmodule QtWebKit + + Each QWebPage object has its own QWebSettings object, which configures the + settings for that page. If a setting is not configured, then it is looked + up in the global settings object, which can be accessed using + globalSettings(). + + QWebSettings allows configuration of browser properties, such as font sizes and + families, the location of a custom style sheet, and generic attributes like + JavaScript and plugins. Individual attributes are set using the setAttribute() + function. The \l{QWebSettings::WebAttribute}{WebAttribute} enum further describes + each attribute. + + QWebSettings also configures global properties such as the web page memory + cache, icon database, local database storage and offline + applications storage. + + \section1 Enabling Plugins + + Support for browser plugins can enabled by setting the + \l{QWebSettings::PluginsEnabled}{PluginsEnabled} attribute. For many applications, + this attribute is enabled for all pages by setting it on the + \l{globalSettings()}{global settings object}. QtWebKit will always ignore this setting + when processing Qt plugins. The decision to allow a Qt plugin is made by the client + in its reimplementation of QWebPage::createPlugin(). + + \section1 Web Application Support + + WebKit provides support for features specified in \l{HTML 5} that improve the + performance and capabilities of Web applications. These include client-side + (offline) storage and the use of a Web application cache. + + Client-side (offline) storage is an improvement over the use of cookies to + store persistent data in Web applications. Applications can configure and + enable the use of an offline storage database by calling the + setOfflineStoragePath() with an appropriate file path, and can limit the quota + for each application by calling setOfflineStorageDefaultQuota(). + + \sa QWebPage::settings(), QWebView::settings(), {Web Browser} +*/ + +/*! + \enum QWebSettings::FontFamily + + This enum describes the generic font families defined by CSS 2. + For more information see the + \l{http://www.w3.org/TR/REC-CSS2/fonts.html#generic-font-families}{CSS standard}. + + \value StandardFont + \value FixedFont + \value SerifFont + \value SansSerifFont + \value CursiveFont + \value FantasyFont +*/ + +/*! + \enum QWebSettings::FontSize + + This enum describes the font sizes configurable through QWebSettings. + + \value MinimumFontSize The hard minimum font size. + \value MinimumLogicalFontSize The minimum logical font size that is applied + when zooming out with QWebFrame::setTextSizeMultiplier(). + \value DefaultFontSize The default font size for regular text. + \value DefaultFixedFontSize The default font size for fixed-pitch text. +*/ + +/*! + \enum QWebSettings::WebGraphic + + This enums describes the standard graphical elements used in webpages. + + \value MissingImageGraphic The replacement graphic shown when an image could not be loaded. + \value MissingPluginGraphic The replacement graphic shown when a plugin could not be loaded. + \value DefaultFrameIconGraphic The default icon for QWebFrame::icon(). + \value TextAreaSizeGripCornerGraphic The graphic shown for the size grip of text areas. + \value DeleteButtonGraphic The graphic shown for the WebKit-Editing-Delete-Button in Deletion UI. +*/ + +/*! + \enum QWebSettings::WebAttribute + + This enum describes various attributes that are configurable through QWebSettings. + + \value AutoLoadImages Specifies whether images are automatically loaded in + web pages. This is enabled by default. + \value DnsPrefetchEnabled Specifies whether QtWebkit will try to pre-fetch DNS entries to + speed up browsing. This only works as a global attribute. Only for Qt 4.6 and later. This is disabled by default. + \value JavascriptEnabled Enables or disables the running of JavaScript + programs. This is enabled by default + \value JavaEnabled Enables or disables Java applets. + Currently Java applets are not supported. + \value PluginsEnabled Enables or disables plugins in Web pages (e.g. using NPAPI). Qt plugins + with a mimetype such as "application/x-qt-plugin" are not affected by this setting. This is disabled by default. + \value PrivateBrowsingEnabled Private browsing prevents WebKit from + recording visited pages in the history and storing web page icons. This is disabled by default. + \value JavascriptCanOpenWindows Specifies whether JavaScript programs + can open new windows. This is disabled by default. + \value JavascriptCanAccessClipboard Specifies whether JavaScript programs + can read or write to the clipboard. This is disabled by default. + \value DeveloperExtrasEnabled Enables extra tools for Web developers. + Currently this enables the "Inspect" element in the context menu as + well as the use of QWebInspector which controls the web inspector + for web site debugging. This is disabled by default. + \value SpatialNavigationEnabled Enables or disables the Spatial Navigation + feature, which consists in the ability to navigate between focusable + elements in a Web page, such as hyperlinks and form controls, by using + Left, Right, Up and Down arrow keys. For example, if a user presses the + Right key, heuristics determine whether there is an element he might be + trying to reach towards the right and which element he probably wants. + This is disabled by default. + \value LinksIncludedInFocusChain Specifies whether hyperlinks should be + included in the keyboard focus chain. This is enabled by default. + \value ZoomTextOnly Specifies whether the zoom factor on a frame applies + only to the text or to all content. This is disabled by default. + \value PrintElementBackgrounds Specifies whether the background color and images + are also drawn when the page is printed. This is enabled by default. + \value OfflineStorageDatabaseEnabled Specifies whether support for the HTML 5 + offline storage feature is enabled or not. This is disabled by default. + \value OfflineWebApplicationCacheEnabled Specifies whether support for the HTML 5 + web application cache feature is enabled or not. This is disabled by default. + \value LocalStorageEnabled Specifies whether support for the HTML 5 + local storage feature is enabled or not. This is disabled by default. + \value LocalStorageDatabaseEnabled \e{This enum value is deprecated.} Use + QWebSettings::LocalStorageEnabled instead. + \value LocalContentCanAccessRemoteUrls Specifies whether locally loaded documents are + allowed to access remote urls. This is disabled by default. For more information + about security origins and local vs. remote content see QWebSecurityOrigin. + \value LocalContentCanAccessFileUrls Specifies whether locally loaded documents are + allowed to access other local urls. This is enabled by default. For more information + about security origins and local vs. remote content see QWebSecurityOrigin. + \value XSSAuditingEnabled Specifies whether load requests should be monitored for cross-site + scripting attempts. Suspicious scripts will be blocked and reported in the inspector's + JavaScript console. Enabling this feature might have an impact on performance + and it is disabled by default. + \value AcceleratedCompositingEnabled This feature, when used in conjunction with + QGraphicsWebView, accelerates animations of web content. CSS animations of the transform and + opacity properties will be rendered by composing the cached content of the animated elements. + This is enabled by default. + \value TiledBackingStoreEnabled This setting enables the tiled backing store feature + for a QGraphicsWebView. With the tiled backing store enabled, the web page contents in and around + the current visible area is speculatively cached to bitmap tiles. The tiles are automatically kept + in sync with the web page as it changes. Enabling tiling can significantly speed up painting heavy + operations like scrolling. Enabling the feature increases memory consumption. It does not work well + with contents using CSS fixed positioning (see also \l{QGraphicsWebView::}{resizesToContents} property). + \l{QGraphicsWebView::}{tiledBackingStoreFrozen} property allows application to temporarily + freeze the contents of the backing store. This is disabled by default. + \value FrameFlatteningEnabled With this setting each subframe is expanded to its contents. + On touch devices, it is desired to not have any scrollable sub parts of the page + as it results in a confusing user experience, with scrolling sometimes scrolling sub parts + and at other times scrolling the page itself. For this reason iframes and framesets are + barely usable on touch devices. This will flatten all the frames to become one scrollable page. + This is disabled by default. + \value SiteSpecificQuirksEnabled This setting enables WebKit's workaround for broken sites. It is + enabled by default. +*/ + +/*! + \internal +*/ +QWebSettings::QWebSettings() + : d(new QWebSettingsPrivate) +{ + // Initialize our global defaults + d->fontSizes.insert(QWebSettings::MinimumFontSize, 0); + d->fontSizes.insert(QWebSettings::MinimumLogicalFontSize, 0); + d->fontSizes.insert(QWebSettings::DefaultFontSize, 16); + d->fontSizes.insert(QWebSettings::DefaultFixedFontSize, 13); + d->fontFamilies.insert(QWebSettings::StandardFont, QLatin1String("Arial")); + d->fontFamilies.insert(QWebSettings::FixedFont, QLatin1String("Courier New")); + d->fontFamilies.insert(QWebSettings::SerifFont, QLatin1String("Times New Roman")); + d->fontFamilies.insert(QWebSettings::SansSerifFont, QLatin1String("Arial")); + d->fontFamilies.insert(QWebSettings::CursiveFont, QLatin1String("Arial")); + d->fontFamilies.insert(QWebSettings::FantasyFont, QLatin1String("Arial")); + + d->attributes.insert(QWebSettings::AutoLoadImages, true); + d->attributes.insert(QWebSettings::DnsPrefetchEnabled, false); + d->attributes.insert(QWebSettings::JavascriptEnabled, true); + d->attributes.insert(QWebSettings::SpatialNavigationEnabled, false); + d->attributes.insert(QWebSettings::LinksIncludedInFocusChain, true); + d->attributes.insert(QWebSettings::ZoomTextOnly, false); + d->attributes.insert(QWebSettings::PrintElementBackgrounds, true); + d->attributes.insert(QWebSettings::OfflineStorageDatabaseEnabled, false); + d->attributes.insert(QWebSettings::OfflineWebApplicationCacheEnabled, false); + d->attributes.insert(QWebSettings::LocalStorageEnabled, false); + d->attributes.insert(QWebSettings::LocalContentCanAccessRemoteUrls, false); + d->attributes.insert(QWebSettings::LocalContentCanAccessFileUrls, true); + d->attributes.insert(QWebSettings::AcceleratedCompositingEnabled, true); + d->attributes.insert(QWebSettings::WebGLEnabled, false); + d->attributes.insert(QWebSettings::TiledBackingStoreEnabled, false); + d->attributes.insert(QWebSettings::FrameFlatteningEnabled, false); + d->attributes.insert(QWebSettings::SiteSpecificQuirksEnabled, true); + d->offlineStorageDefaultQuota = 5 * 1024 * 1024; + d->defaultTextEncoding = QLatin1String("iso-8859-1"); +} + +/*! + \internal +*/ +QWebSettings::QWebSettings(WebCore::Settings* settings) + : d(new QWebSettingsPrivate(settings)) +{ + d->settings = settings; + d->apply(); + allSettings()->append(d); +} + +/*! + \internal +*/ +QWebSettings::~QWebSettings() +{ + if (d->settings) + allSettings()->removeAll(d); + + delete d; +} + +/*! + Sets the font size for \a type to \a size. +*/ +void QWebSettings::setFontSize(FontSize type, int size) +{ + d->fontSizes.insert(type, size); + d->apply(); +} + +/*! + Returns the default font size for \a type. +*/ +int QWebSettings::fontSize(FontSize type) const +{ + int defaultValue = 0; + if (d->settings) { + QWebSettingsPrivate* global = QWebSettings::globalSettings()->d; + defaultValue = global->fontSizes.value(type); + } + return d->fontSizes.value(type, defaultValue); +} + +/*! + Resets the font size for \a type to the size specified in the global + settings object. + + This function has no effect on the global QWebSettings instance. +*/ +void QWebSettings::resetFontSize(FontSize type) +{ + if (d->settings) { + d->fontSizes.remove(type); + d->apply(); + } +} + +/*! + Specifies the location of a user stylesheet to load with every web page. + + The \a location must be either a path on the local filesystem, or a data URL + with UTF-8 and Base64 encoded data, such as: + + "data:text/css;charset=utf-8;base64,cCB7IGJhY2tncm91bmQtY29sb3I6IHJlZCB9Ow==" + + \note If the base64 data is not valid, the style will not be applied. + + \sa userStyleSheetUrl() +*/ +void QWebSettings::setUserStyleSheetUrl(const QUrl& location) +{ + d->userStyleSheetLocation = location; + d->apply(); +} + +/*! + Returns the location of the user stylesheet. + + \sa setUserStyleSheetUrl() +*/ +QUrl QWebSettings::userStyleSheetUrl() const +{ + return d->userStyleSheetLocation; +} + +/*! + \since 4.6 + Specifies the default text encoding system. + + The \a encoding, must be a string describing an encoding such as "utf-8", + "iso-8859-1", etc. If left empty a default value will be used. For a more + extensive list of encoding names see \l{QTextCodec} + + \sa defaultTextEncoding() +*/ +void QWebSettings::setDefaultTextEncoding(const QString& encoding) +{ + d->defaultTextEncoding = encoding; + d->apply(); +} + +/*! + \since 4.6 + Returns the default text encoding. + + \sa setDefaultTextEncoding() +*/ +QString QWebSettings::defaultTextEncoding() const +{ + return d->defaultTextEncoding; +} + +/*! + Sets the path of the icon database to \a path. The icon database is used + to store "favicons" associated with web sites. + + \a path must point to an existing directory. + + Setting an empty path disables the icon database. + + \sa iconDatabasePath(), clearIconDatabase() +*/ +void QWebSettings::setIconDatabasePath(const QString& path) +{ + WebCore::iconDatabase()->delayDatabaseCleanup(); + + if (!path.isEmpty()) { + WebCore::iconDatabase()->setEnabled(true); + QFileInfo info(path); + if (info.isDir() && info.isWritable()) + WebCore::iconDatabase()->open(path); + } else { + WebCore::iconDatabase()->setEnabled(false); + WebCore::iconDatabase()->close(); + } +} + +/*! + Returns the path of the icon database or an empty string if the icon + database is disabled. + + \sa setIconDatabasePath(), clearIconDatabase() +*/ +QString QWebSettings::iconDatabasePath() +{ + if (WebCore::iconDatabase()->isEnabled() && WebCore::iconDatabase()->isOpen()) + return WebCore::iconDatabase()->databasePath(); + else + return QString(); +} + +/*! + Clears the icon database. +*/ +void QWebSettings::clearIconDatabase() +{ + if (WebCore::iconDatabase()->isEnabled() && WebCore::iconDatabase()->isOpen()) + WebCore::iconDatabase()->removeAllIcons(); +} + +/*! + Returns the web site's icon for \a url. + + If the web site does not specify an icon \bold OR if the icon is not in the + database, a null QIcon is returned. + + \note The returned icon's size is arbitrary. + + \sa setIconDatabasePath() +*/ +QIcon QWebSettings::iconForUrl(const QUrl& url) +{ + WebCore::Image* image = WebCore::iconDatabase()->iconForPageURL(WebCore::KURL(url).string(), + WebCore::IntSize(16, 16)); + if (!image) + return QPixmap(); + + QPixmap* icon = image->nativeImageForCurrentFrame(); + if (!icon) + return QPixmap(); + + return* icon; +} + +/* + Returns the plugin database object. + +QWebPluginDatabase *QWebSettings::pluginDatabase() +{ + static QWebPluginDatabase* database = 0; + if (!database) + database = new QWebPluginDatabase(); + return database; +} +*/ + +/*! + Sets \a graphic to be drawn when QtWebKit needs to draw an image of the + given \a type. + + For example, when an image cannot be loaded, the pixmap specified by + \l{QWebSettings::WebGraphic}{MissingImageGraphic} is drawn instead. + + \sa webGraphic() +*/ +void QWebSettings::setWebGraphic(WebGraphic type, const QPixmap& graphic) +{ + WebGraphicHash* h = graphics(); + if (graphic.isNull()) + h->remove(type); + else + h->insert(type, graphic); +} + +/*! + Returns a previously set pixmap used to draw replacement graphics of the + specified \a type. + + \sa setWebGraphic() +*/ +QPixmap QWebSettings::webGraphic(WebGraphic type) +{ + return graphics()->value(type); +} + +/*! + Frees up as much memory as possible by cleaning all memory caches such + as page, object and font cache. + + \since 4.6 + */ +void QWebSettings::clearMemoryCaches() +{ + // Turn the cache on and off. Disabling the object cache will remove all + // resources from the cache. They may still live on if they are referenced + // by some Web page though. + if (!WebCore::cache()->disabled()) { + WebCore::cache()->setDisabled(true); + WebCore::cache()->setDisabled(false); + } + + int pageCapacity = WebCore::pageCache()->capacity(); + // Setting size to 0, makes all pages be released. + WebCore::pageCache()->setCapacity(0); + WebCore::pageCache()->releaseAutoreleasedPagesNow(); + WebCore::pageCache()->setCapacity(pageCapacity); + + // Invalidating the font cache and freeing all inactive font data. + WebCore::fontCache()->invalidate(); + + // Empty the Cross-Origin Preflight cache + WebCore::CrossOriginPreflightResultCache::shared().empty(); +} + +/*! + Sets the maximum number of pages to hold in the memory page cache to \a pages. + + The Page Cache allows for a nicer user experience when navigating forth or back + to pages in the forward/back history, by pausing and resuming up to \a pages. + + For more information about the feature, please refer to: + + http://webkit.org/blog/427/webkit-page-cache-i-the-basics/ +*/ +void QWebSettings::setMaximumPagesInCache(int pages) +{ + QWebSettingsPrivate* global = QWebSettings::globalSettings()->d; + WebCore::pageCache()->setCapacity(qMax(0, pages)); + global->apply(); +} + +/*! + Returns the maximum number of web pages that are kept in the memory cache. +*/ +int QWebSettings::maximumPagesInCache() +{ + return WebCore::pageCache()->capacity(); +} + +/*! + Specifies the capacities for the memory cache for dead objects such as + stylesheets or scripts. + + The \a cacheMinDeadCapacity specifies the \e minimum number of bytes that + dead objects should consume when the cache is under pressure. + + \a cacheMaxDead is the \e maximum number of bytes that dead objects should + consume when the cache is \bold not under pressure. + + \a totalCapacity specifies the \e maximum number of bytes that the cache + should consume \bold overall. + + The cache is enabled by default. Calling setObjectCacheCapacities(0, 0, 0) + will disable the cache. Calling it with one non-zero enables it again. +*/ +void QWebSettings::setObjectCacheCapacities(int cacheMinDeadCapacity, int cacheMaxDead, int totalCapacity) +{ + bool disableCache = !cacheMinDeadCapacity && !cacheMaxDead && !totalCapacity; + WebCore::cache()->setDisabled(disableCache); + + WebCore::cache()->setCapacities(qMax(0, cacheMinDeadCapacity), + qMax(0, cacheMaxDead), + qMax(0, totalCapacity)); +} + +/*! + Sets the actual font family to \a family for the specified generic family, + \a which. +*/ +void QWebSettings::setFontFamily(FontFamily which, const QString& family) +{ + d->fontFamilies.insert(which, family); + d->apply(); +} + +/*! + Returns the actual font family for the specified generic font family, + \a which. +*/ +QString QWebSettings::fontFamily(FontFamily which) const +{ + QString defaultValue; + if (d->settings) { + QWebSettingsPrivate* global = QWebSettings::globalSettings()->d; + defaultValue = global->fontFamilies.value(which); + } + return d->fontFamilies.value(which, defaultValue); +} + +/*! + Resets the actual font family specified by \a which to the one set + in the global QWebSettings instance. + + This function has no effect on the global QWebSettings instance. +*/ +void QWebSettings::resetFontFamily(FontFamily which) +{ + if (d->settings) { + d->fontFamilies.remove(which); + d->apply(); + } +} + +/*! + \fn void QWebSettings::setAttribute(WebAttribute attribute, bool on) + + Enables or disables the specified \a attribute feature depending on the + value of \a on. +*/ +void QWebSettings::setAttribute(WebAttribute attr, bool on) +{ + d->attributes.insert(attr, on); + d->apply(); +} + +/*! + \fn bool QWebSettings::testAttribute(WebAttribute attribute) const + + Returns true if \a attribute is enabled; otherwise returns false. +*/ +bool QWebSettings::testAttribute(WebAttribute attr) const +{ + bool defaultValue = false; + if (d->settings) { + QWebSettingsPrivate* global = QWebSettings::globalSettings()->d; + defaultValue = global->attributes.value(attr); + } + return d->attributes.value(attr, defaultValue); +} + +/*! + \fn void QWebSettings::resetAttribute(WebAttribute attribute) + + Resets the setting of \a attribute to the value specified in the + global QWebSettings instance. + + This function has no effect on the global QWebSettings instance. + + \sa globalSettings() +*/ +void QWebSettings::resetAttribute(WebAttribute attr) +{ + if (d->settings) { + d->attributes.remove(attr); + d->apply(); + } +} + +/*! + \since 4.5 + + Sets \a path as the save location for HTML5 client-side database storage data. + + \a path must point to an existing directory. + + Setting an empty path disables the feature. + + Support for client-side databases can enabled by setting the + \l{QWebSettings::OfflineStorageDatabaseEnabled}{OfflineStorageDatabaseEnabled} attribute. + + \sa offlineStoragePath() +*/ +void QWebSettings::setOfflineStoragePath(const QString& path) +{ +#if ENABLE(DATABASE) + WebCore::DatabaseTracker::tracker().setDatabaseDirectoryPath(path); +#endif +} + +/*! + \since 4.5 + + Returns the path of the HTML5 client-side database storage or an empty string if the + feature is disabled. + + \sa setOfflineStoragePath() +*/ +QString QWebSettings::offlineStoragePath() +{ +#if ENABLE(DATABASE) + return WebCore::DatabaseTracker::tracker().databaseDirectoryPath(); +#else + return QString(); +#endif +} + +/*! + \since 4.5 + + Sets the value of the default quota for new offline storage databases + to \a maximumSize. +*/ +void QWebSettings::setOfflineStorageDefaultQuota(qint64 maximumSize) +{ + QWebSettings::globalSettings()->d->offlineStorageDefaultQuota = maximumSize; +} + +/*! + \since 4.5 + + Returns the value of the default quota for new offline storage databases. +*/ +qint64 QWebSettings::offlineStorageDefaultQuota() +{ + return QWebSettings::globalSettings()->d->offlineStorageDefaultQuota; +} + +/*! + \since 4.6 + + Sets the path for HTML5 offline web application cache storage to \a path. + + An application cache acts like an HTTP cache in some sense. For documents + that use the application cache via JavaScript, the loader engine will + first ask the application cache for the contents, before hitting the + network. + + The feature is described in details at: + http://dev.w3.org/html5/spec/Overview.html#appcache + + \a path must point to an existing directory. + + Setting an empty path disables the feature. + + Support for offline web application cache storage can enabled by setting the + \l{QWebSettings::OfflineWebApplicationCacheEnabled}{OfflineWebApplicationCacheEnabled} attribute. + + \sa offlineWebApplicationCachePath() +*/ +void QWebSettings::setOfflineWebApplicationCachePath(const QString& path) +{ +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + WebCore::cacheStorage().setCacheDirectory(path); +#endif +} + +/*! + \since 4.6 + + Returns the path of the HTML5 offline web application cache storage + or an empty string if the feature is disabled. + + \sa setOfflineWebApplicationCachePath() +*/ +QString QWebSettings::offlineWebApplicationCachePath() +{ +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + return WebCore::cacheStorage().cacheDirectory(); +#else + return QString(); +#endif +} + +/*! + \since 4.6 + + Sets the value of the quota for the offline web application cache + to \a maximumSize. +*/ +void QWebSettings::setOfflineWebApplicationCacheQuota(qint64 maximumSize) +{ +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + WebCore::cacheStorage().empty(); + WebCore::cacheStorage().vacuumDatabaseFile(); + WebCore::cacheStorage().setMaximumSize(maximumSize); +#endif +} + +/*! + \since 4.6 + + Returns the value of the quota for the offline web application cache. +*/ +qint64 QWebSettings::offlineWebApplicationCacheQuota() +{ +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + return WebCore::cacheStorage().maximumSize(); +#else + return 0; +#endif +} + +/*! + \since 4.6 + + Sets the path for HTML5 local storage to \a path. + + For more information on HTML5 local storage see the + \l{http://www.w3.org/TR/webstorage/#the-localstorage-attribute}{Web Storage standard}. + + Support for local storage can enabled by setting the + \l{QWebSettings::LocalStorageEnabled}{LocalStorageEnabled} attribute. + + \sa localStoragePath() +*/ +void QWebSettings::setLocalStoragePath(const QString& path) +{ + d->localStoragePath = path; + d->apply(); +} + +/*! + \since 4.6 + + Returns the path for HTML5 local storage. + + \sa setLocalStoragePath() +*/ +QString QWebSettings::localStoragePath() const +{ + return d->localStoragePath; +} + +/*! + \since 4.6 + + Enables WebKit data persistence and sets the path to \a path. + If \a path is empty, the user-specific data location specified by + \l{QDesktopServices::DataLocation}{DataLocation} will be used instead. + + This method will simultaneously set and enable the iconDatabasePath(), + localStoragePath(), offlineStoragePath() and offlineWebApplicationCachePath(). + + \sa localStoragePath() +*/ +void QWebSettings::enablePersistentStorage(const QString& path) +{ + QString storagePath; + + if (path.isEmpty()) { +#ifndef QT_NO_DESKTOPSERVICES + storagePath = QDesktopServices::storageLocation(QDesktopServices::DataLocation); +#endif + if (storagePath.isEmpty()) + storagePath = WebCore::pathByAppendingComponent(QDir::homePath(), QCoreApplication::applicationName()); + } else + storagePath = path; + + WebCore::makeAllDirectories(storagePath); + + QWebSettings::setIconDatabasePath(storagePath); + QWebSettings::setOfflineWebApplicationCachePath(storagePath); + QWebSettings::setOfflineStoragePath(WebCore::pathByAppendingComponent(storagePath, "Databases")); + QWebSettings::globalSettings()->setLocalStoragePath(WebCore::pathByAppendingComponent(storagePath, "LocalStorage")); + QWebSettings::globalSettings()->setAttribute(QWebSettings::LocalStorageEnabled, true); + QWebSettings::globalSettings()->setAttribute(QWebSettings::OfflineStorageDatabaseEnabled, true); + QWebSettings::globalSettings()->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, true); +} + +/*! + \fn QWebSettingsPrivate* QWebSettings::handle() const + \internal +*/