--- /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 <QApplication>
+#include <QDesktopServices>
+#include <QDir>
+#include <QHash>
+#include <QSharedData>
+#include <QUrl>
+#include <QFileInfo>
+
+#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<int, QString> fontFamilies;
+ QHash<int, int> fontSizes;
+ QHash<int, bool> attributes;
+ QUrl userStyleSheetLocation;
+ QString defaultTextEncoding;
+ QString localStoragePath;
+ QString offlineWebApplicationCachePath;
+ qint64 offlineStorageDefaultQuota;
+
+ void apply();
+ WebCore::Settings* settings;
+};
+
+typedef QHash<int, QPixmap> 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<QWebSettingsPrivate*>, 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<QWebSettingsPrivate*> 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
+*/