| /* |
| * Copyright (C) 2008 Christian Dywan <christian@imendio.com> |
| * Copyright (C) 2008 Nuanti Ltd. |
| * Copyright (C) 2008 Collabora Ltd. |
| * Copyright (C) 2008 Holger Hans Peter Freyther |
| * Copyright (C) 2009 Jan Michael Alonzo |
| * Copyright (C) 2009 Movial Creative Technologies Inc. |
| * Copyright (C) 2009 Igalia S.L. |
| * |
| * 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 "webkitwebsettings.h" |
| |
| #include "EditingBehavior.h" |
| #include "FileSystem.h" |
| #include "KURL.h" |
| #include "PluginDatabase.h" |
| #include "UserAgentGtk.h" |
| #include "webkitenumtypes.h" |
| #include "webkitglobalsprivate.h" |
| #include "webkitversion.h" |
| #include "webkitwebsettingsprivate.h" |
| #include <wtf/gobject/GOwnPtr.h> |
| #include <wtf/text/CString.h> |
| #include <wtf/text/StringConcatenate.h> |
| #include <glib/gi18n-lib.h> |
| |
| /** |
| * SECTION:webkitwebsettings |
| * @short_description: Control the behaviour of a #WebKitWebView |
| * |
| * #WebKitWebSettings can be applied to a #WebKitWebView to control text encoding, |
| * color, font sizes, printing mode, script support, loading of images and various other things. |
| * After creation, a #WebKitWebSettings object contains default settings. |
| * |
| * <informalexample><programlisting> |
| * /<!-- -->* Create a new websettings and disable java script *<!-- -->/ |
| * WebKitWebSettings *settings = webkit_web_settings_new (); |
| * g_object_set (G_OBJECT(settings), "enable-scripts", FALSE, NULL); |
| * |
| * /<!-- -->* Apply the result *<!-- -->/ |
| * webkit_web_view_set_settings (WEBKIT_WEB_VIEW(my_webview), settings); |
| * </programlisting></informalexample> |
| */ |
| |
| using namespace WebCore; |
| |
| G_DEFINE_TYPE(WebKitWebSettings, webkit_web_settings, G_TYPE_OBJECT) |
| |
| enum { |
| PROP_0, |
| |
| PROP_DEFAULT_ENCODING, |
| PROP_CURSIVE_FONT_FAMILY, |
| PROP_DEFAULT_FONT_FAMILY, |
| PROP_FANTASY_FONT_FAMILY, |
| PROP_MONOSPACE_FONT_FAMILY, |
| PROP_SANS_SERIF_FONT_FAMILY, |
| PROP_SERIF_FONT_FAMILY, |
| PROP_DEFAULT_FONT_SIZE, |
| PROP_DEFAULT_MONOSPACE_FONT_SIZE, |
| PROP_MINIMUM_FONT_SIZE, |
| PROP_MINIMUM_LOGICAL_FONT_SIZE, |
| PROP_ENFORCE_96_DPI, |
| PROP_AUTO_LOAD_IMAGES, |
| PROP_AUTO_SHRINK_IMAGES, |
| PROP_RESPECT_IMAGE_ORIENTATION, |
| PROP_PRINT_BACKGROUNDS, |
| PROP_ENABLE_SCRIPTS, |
| PROP_ENABLE_PLUGINS, |
| PROP_RESIZABLE_TEXT_AREAS, |
| PROP_USER_STYLESHEET_URI, |
| PROP_ZOOM_STEP, |
| PROP_ENABLE_DEVELOPER_EXTRAS, |
| PROP_ENABLE_PRIVATE_BROWSING, |
| PROP_ENABLE_SPELL_CHECKING, |
| PROP_SPELL_CHECKING_LANGUAGES, |
| PROP_ENABLE_CARET_BROWSING, |
| PROP_ENABLE_HTML5_DATABASE, |
| PROP_ENABLE_HTML5_LOCAL_STORAGE, |
| PROP_HTML5_LOCAL_STORAGE_DATABASE_PATH, |
| PROP_ENABLE_XSS_AUDITOR, |
| PROP_ENABLE_SPATIAL_NAVIGATION, |
| PROP_ENABLE_FRAME_FLATTENING, |
| PROP_USER_AGENT, |
| PROP_JAVASCRIPT_CAN_OPEN_WINDOWS_AUTOMATICALLY, |
| PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD, |
| PROP_ENABLE_OFFLINE_WEB_APPLICATION_CACHE, |
| PROP_EDITING_BEHAVIOR, |
| PROP_ENABLE_UNIVERSAL_ACCESS_FROM_FILE_URIS, |
| PROP_ENABLE_FILE_ACCESS_FROM_FILE_URIS, |
| PROP_ENABLE_DOM_PASTE, |
| PROP_TAB_KEY_CYCLES_THROUGH_ELEMENTS, |
| PROP_ENABLE_DEFAULT_CONTEXT_MENU, |
| PROP_ENABLE_SITE_SPECIFIC_QUIRKS, |
| PROP_ENABLE_PAGE_CACHE, |
| PROP_AUTO_RESIZE_WINDOW, |
| PROP_ENABLE_JAVA_APPLET, |
| PROP_ENABLE_HYPERLINK_AUDITING, |
| PROP_ENABLE_FULLSCREEN, |
| PROP_ENABLE_DNS_PREFETCHING, |
| PROP_ENABLE_WEBGL, |
| PROP_ENABLE_MEDIA_STREAM, |
| PROP_ENABLE_WEB_AUDIO, |
| PROP_ENABLE_ACCELERATED_COMPOSITING, |
| PROP_ENABLE_SMOOTH_SCROLLING, |
| PROP_MEDIA_PLAYBACK_REQUIRES_USER_GESTURE, |
| PROP_MEDIA_PLAYBACK_ALLOWS_INLINE, |
| PROP_ENABLE_CSS_SHADERS, |
| PROP_ENABLE_RUNNING_OF_INSECURE_CONTENT, |
| PROP_ENABLE_DISPLAY_OF_INSECURE_CONTENT |
| }; |
| |
| static void webkit_web_settings_finalize(GObject* object); |
| |
| static void webkit_web_settings_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec); |
| |
| static void webkit_web_settings_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec); |
| |
| static void webkit_web_settings_class_init(WebKitWebSettingsClass* klass) |
| { |
| GObjectClass* gobject_class = G_OBJECT_CLASS(klass); |
| gobject_class->finalize = webkit_web_settings_finalize; |
| gobject_class->set_property = webkit_web_settings_set_property; |
| gobject_class->get_property = webkit_web_settings_get_property; |
| |
| webkitInit(); |
| |
| GParamFlags flags = (GParamFlags)(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_DEFAULT_ENCODING, |
| g_param_spec_string( |
| "default-encoding", |
| _("Default Encoding"), |
| _("The default encoding used to display text."), |
| "iso-8859-1", |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_CURSIVE_FONT_FAMILY, |
| g_param_spec_string( |
| "cursive-font-family", |
| _("Cursive Font Family"), |
| _("The default Cursive font family used to display text."), |
| "serif", |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_DEFAULT_FONT_FAMILY, |
| g_param_spec_string( |
| "default-font-family", |
| _("Default Font Family"), |
| _("The default font family used to display text."), |
| "sans-serif", |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_FANTASY_FONT_FAMILY, |
| g_param_spec_string( |
| "fantasy-font-family", |
| _("Fantasy Font Family"), |
| _("The default Fantasy font family used to display text."), |
| "serif", |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_MONOSPACE_FONT_FAMILY, |
| g_param_spec_string( |
| "monospace-font-family", |
| _("Monospace Font Family"), |
| _("The default font family used to display monospace text."), |
| "monospace", |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_SANS_SERIF_FONT_FAMILY, |
| g_param_spec_string( |
| "sans-serif-font-family", |
| _("Sans Serif Font Family"), |
| _("The default Sans Serif font family used to display text."), |
| "sans-serif", |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_SERIF_FONT_FAMILY, |
| g_param_spec_string( |
| "serif-font-family", |
| _("Serif Font Family"), |
| _("The default Serif font family used to display text."), |
| "serif", |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_DEFAULT_FONT_SIZE, |
| g_param_spec_int( |
| "default-font-size", |
| _("Default Font Size"), |
| _("The default font size used to display text."), |
| 5, G_MAXINT, 12, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_DEFAULT_MONOSPACE_FONT_SIZE, |
| g_param_spec_int( |
| "default-monospace-font-size", |
| _("Default Monospace Font Size"), |
| _("The default font size used to display monospace text."), |
| 5, G_MAXINT, 10, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_MINIMUM_FONT_SIZE, |
| g_param_spec_int( |
| "minimum-font-size", |
| _("Minimum Font Size"), |
| _("The minimum font size used to display text."), |
| 0, G_MAXINT, 5, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_MINIMUM_LOGICAL_FONT_SIZE, |
| g_param_spec_int( |
| "minimum-logical-font-size", |
| _("Minimum Logical Font Size"), |
| _("The minimum logical font size used to display text."), |
| 1, G_MAXINT, 5, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enforce-96-dpi: |
| * |
| * Enforce a resolution of 96 DPI. This is meant for compatibility |
| * with web pages which cope badly with different screen resolutions |
| * and for automated testing. |
| * Web browsers and applications that typically display arbitrary |
| * content from the web should provide a preference for this. |
| * |
| * Since: 1.0.3 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENFORCE_96_DPI, |
| g_param_spec_boolean( |
| "enforce-96-dpi", |
| _("Enforce 96 DPI"), |
| _("Enforce a resolution of 96 DPI"), |
| FALSE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_AUTO_LOAD_IMAGES, |
| g_param_spec_boolean( |
| "auto-load-images", |
| _("Auto Load Images"), |
| _("Load images automatically."), |
| TRUE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_AUTO_SHRINK_IMAGES, |
| g_param_spec_boolean( |
| "auto-shrink-images", |
| _("Auto Shrink Images"), |
| _("Automatically shrink standalone images to fit."), |
| TRUE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_RESPECT_IMAGE_ORIENTATION, |
| g_param_spec_boolean( |
| "respect-image-orientation", |
| _("Respect Image Orientation"), |
| _("Whether WebKit should respect image orientation."), |
| FALSE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_PRINT_BACKGROUNDS, |
| g_param_spec_boolean( |
| "print-backgrounds", |
| _("Print Backgrounds"), |
| _("Whether background images should be printed."), |
| TRUE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_SCRIPTS, |
| g_param_spec_boolean( |
| "enable-scripts", |
| _("Enable Scripts"), |
| _("Enable embedded scripting languages."), |
| TRUE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_PLUGINS, |
| g_param_spec_boolean( |
| "enable-plugins", |
| _("Enable Plugins"), |
| _("Enable embedded plugin objects."), |
| TRUE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_RESIZABLE_TEXT_AREAS, |
| g_param_spec_boolean( |
| "resizable-text-areas", |
| _("Resizable Text Areas"), |
| _("Whether text areas are resizable."), |
| TRUE, |
| flags)); |
| |
| g_object_class_install_property(gobject_class, |
| PROP_USER_STYLESHEET_URI, |
| g_param_spec_string("user-stylesheet-uri", |
| _("User Stylesheet URI"), |
| _("The URI of a stylesheet that is applied to every page."), |
| 0, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:zoom-step: |
| * |
| * The value by which the zoom level is changed when zooming in or out. |
| * |
| * Since: 1.0.1 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ZOOM_STEP, |
| g_param_spec_float( |
| "zoom-step", |
| _("Zoom Stepping Value"), |
| _("The value by which the zoom level is changed when zooming in or out."), |
| 0.0f, G_MAXFLOAT, 0.1f, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-developer-extras: |
| * |
| * Whether developer extensions should be enabled. This enables, |
| * for now, the Web Inspector, which can be controlled using the |
| * #WebKitWebInspector instance held by the #WebKitWebView this |
| * setting is enabled for. |
| * |
| * Since: 1.0.3 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_DEVELOPER_EXTRAS, |
| g_param_spec_boolean( |
| "enable-developer-extras", |
| _("Enable Developer Extras"), |
| _("Enables special extensions that help developers"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-private-browsing: |
| * |
| * Whether to enable private browsing mode. Private browsing mode prevents |
| * WebKit from updating the global history and storing any session |
| * information e.g., on-disk cache, as well as suppressing any messages |
| * from being printed into the (javascript) console. |
| * |
| * This is currently experimental for WebKitGtk. |
| * |
| * Since: 1.1.2 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_PRIVATE_BROWSING, |
| g_param_spec_boolean( |
| "enable-private-browsing", |
| _("Enable Private Browsing"), |
| _("Enables private browsing mode"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-spell-checking: |
| * |
| * Whether to enable spell checking while typing. |
| * |
| * Since: 1.1.6 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_SPELL_CHECKING, |
| g_param_spec_boolean( |
| "enable-spell-checking", |
| _("Enable Spell Checking"), |
| _("Enables spell checking while typing"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:spell-checking-languages: |
| * |
| * The languages to be used for spell checking, separated by commas. |
| * |
| * The locale string typically is in the form lang_COUNTRY, where lang |
| * is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. |
| * For instance, sv_FI for Swedish as written in Finland or pt_BR |
| * for Portuguese as written in Brazil. |
| * |
| * If no value is specified then the value returned by |
| * gtk_get_default_language will be used. |
| * |
| * Since: 1.1.6 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_SPELL_CHECKING_LANGUAGES, |
| g_param_spec_string( |
| "spell-checking-languages", |
| _("Languages to use for spell checking"), |
| _("Comma separated list of languages to use for spell checking"), |
| 0, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-caret-browsing: |
| * |
| * Whether to enable caret browsing mode. |
| * |
| * Since: 1.1.6 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_CARET_BROWSING, |
| g_param_spec_boolean("enable-caret-browsing", |
| _("Enable Caret Browsing"), |
| _("Whether to enable accessibility enhanced keyboard navigation"), |
| FALSE, |
| flags)); |
| /** |
| * WebKitWebSettings:enable-html5-database: |
| * |
| * Whether to enable HTML5 client-side SQL database support. Client-side |
| * SQL database allows web pages to store structured data and be able to |
| * use SQL to manipulate that data asynchronously. |
| * |
| * Since: 1.1.8 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_HTML5_DATABASE, |
| g_param_spec_boolean("enable-html5-database", |
| _("Enable HTML5 Database"), |
| _("Whether to enable HTML5 database support"), |
| TRUE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-html5-local-storage: |
| * |
| * Whether to enable HTML5 localStorage support. localStorage provides |
| * simple synchronous storage access. |
| * |
| * Since: 1.1.8 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_HTML5_LOCAL_STORAGE, |
| g_param_spec_boolean("enable-html5-local-storage", |
| _("Enable HTML5 Local Storage"), |
| _("Whether to enable HTML5 Local Storage support"), |
| TRUE, |
| flags)); |
| /** |
| * WebKitWebSettings:html5-local-storage-database-path: |
| * |
| * Path to store persistent HTML5 localStorage databases, which are enabled by |
| * "enable-html5-local-storage". The default path is $XDG_DATA_HOME/webkit/databases/. |
| * |
| * Since: 1.5.2 |
| */ |
| GOwnPtr<gchar> localStoragePath(g_build_filename(g_get_user_data_dir(), "webkit", "databases", NULL)); |
| g_object_class_install_property(gobject_class, |
| PROP_HTML5_LOCAL_STORAGE_DATABASE_PATH, |
| g_param_spec_string("html5-local-storage-database-path", |
| _("Local Storage Database Path"), |
| _("The path to where HTML5 Local Storage databases are stored."), |
| localStoragePath.get(), |
| flags)); |
| /** |
| * WebKitWebSettings:enable-xss-auditor: |
| * |
| * Whether to enable the XSS Auditor. This feature filters some kinds of |
| * reflective XSS attacks on vulnerable web sites. |
| * |
| * Since: 1.1.11 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_XSS_AUDITOR, |
| g_param_spec_boolean("enable-xss-auditor", |
| _("Enable XSS Auditor"), |
| _("Whether to enable the XSS auditor"), |
| TRUE, |
| flags)); |
| /** |
| * WebKitWebSettings:enable-spatial-navigation: |
| * |
| * Whether to enable the Spatial Navigation. This feature 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 |
| * an user presses the Right key, heuristics determine whether there is an element |
| * he might be trying to reach towards the right, and if there are multiple elements, |
| * which element he probably wants. |
| * |
| * Since: 1.1.23 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_SPATIAL_NAVIGATION, |
| g_param_spec_boolean("enable-spatial-navigation", |
| _("Enable Spatial Navigation"), |
| _("Whether to enable Spatial Navigation"), |
| FALSE, |
| flags)); |
| /** |
| * WebKitWebSettings:enable-frame-flattening: |
| * |
| * Whether to enable the Frame Flattening. With this setting each subframe is expanded |
| * to its contents, which will flatten all the frames to become one scrollable page. |
| * 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. |
| * |
| * Since: 1.3.5 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_FRAME_FLATTENING, |
| g_param_spec_boolean("enable-frame-flattening", |
| _("Enable Frame Flattening"), |
| _("Whether to enable Frame Flattening"), |
| FALSE, |
| flags)); |
| /** |
| * WebKitWebSettings:user-agent: |
| * |
| * The User-Agent string used by WebKitGtk. |
| * |
| * This will return a default User-Agent string if a custom string wasn't |
| * provided by the application. Setting this property to a NULL value or |
| * an empty string will result in the User-Agent string being reset to the |
| * default value. |
| * |
| * Since: 1.1.11 |
| */ |
| g_object_class_install_property(gobject_class, PROP_USER_AGENT, |
| g_param_spec_string("user-agent", |
| _("User Agent"), |
| _("The User-Agent string used by WebKitGtk"), |
| "", // An empty string means the default user-agent. |
| flags)); |
| |
| /** |
| * WebKitWebSettings:javascript-can-open-windows-automatically: |
| * |
| * Whether JavaScript can open popup windows automatically without user |
| * intervention. |
| * |
| * Since: 1.1.11 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_JAVASCRIPT_CAN_OPEN_WINDOWS_AUTOMATICALLY, |
| g_param_spec_boolean("javascript-can-open-windows-automatically", |
| _("JavaScript can open windows automatically"), |
| _("Whether JavaScript can open windows automatically"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:javascript-can-access-clipboard: |
| * |
| * Whether JavaScript can access Clipboard. |
| * |
| * Since: 1.3.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD, |
| g_param_spec_boolean("javascript-can-access-clipboard", |
| _("JavaScript can access Clipboard"), |
| _("Whether JavaScript can access Clipboard"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-offline-web-application-cache: |
| * |
| * Whether to enable HTML5 offline web application cache support. Offline |
| * Web Application Cache ensures web applications are available even when |
| * the user is not connected to the network. |
| * |
| * Since: 1.1.13 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_OFFLINE_WEB_APPLICATION_CACHE, |
| g_param_spec_boolean("enable-offline-web-application-cache", |
| _("Enable offline web application cache"), |
| _("Whether to enable offline web application cache"), |
| TRUE, |
| flags)); |
| |
| |
| /** |
| * WebKitWebSettings:editing-behavior: |
| * |
| * This setting controls various editing behaviors that differ |
| * between platforms and that have been combined in two groups, |
| * 'Mac' and 'Windows'. Some examples: |
| * |
| * 1) Clicking below the last line of an editable area puts the |
| * caret at the end of the last line on Mac, but in the middle of |
| * the last line on Windows. |
| * |
| * 2) Pushing down the arrow key on the last line puts the caret |
| * at the end of the last line on Mac, but does nothing on |
| * Windows. A similar case exists on the top line. |
| * |
| * Since: 1.1.13 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_EDITING_BEHAVIOR, |
| g_param_spec_enum("editing-behavior", |
| _("Editing behavior"), |
| _("The behavior mode to use in editing mode"), |
| WEBKIT_TYPE_EDITING_BEHAVIOR, |
| WEBKIT_EDITING_BEHAVIOR_UNIX, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-universal-access-from-file-uris: |
| * |
| * Whether to allow files loaded through file:// URIs universal access to |
| * all pages. |
| * |
| * Since: 1.1.13 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_UNIVERSAL_ACCESS_FROM_FILE_URIS, |
| g_param_spec_boolean("enable-universal-access-from-file-uris", |
| _("Enable universal access from file URIs"), |
| _("Whether to allow universal access from file URIs"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-dom-paste: |
| * |
| * Whether to enable DOM paste. If set to %TRUE, document.execCommand("Paste") |
| * will correctly execute and paste content of the clipboard. |
| * |
| * Since: 1.1.16 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_DOM_PASTE, |
| g_param_spec_boolean("enable-dom-paste", |
| _("Enable DOM paste"), |
| _("Whether to enable DOM paste"), |
| FALSE, |
| flags)); |
| /** |
| * WebKitWebSettings:tab-key-cycles-through-elements: |
| * |
| * Whether the tab key cycles through elements on the page. |
| * |
| * If @flag is %TRUE, pressing the tab key will focus the next element in |
| * the @web_view. If @flag is %FALSE, the @web_view will interpret tab |
| * key presses as normal key presses. If the selected element is editable, the |
| * tab key will cause the insertion of a tab character. |
| * |
| * Since: 1.1.17 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_TAB_KEY_CYCLES_THROUGH_ELEMENTS, |
| g_param_spec_boolean("tab-key-cycles-through-elements", |
| _("Tab key cycles through elements"), |
| _("Whether the tab key cycles through elements on the page."), |
| TRUE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-default-context-menu: |
| * |
| * Whether right-clicks should be handled automatically to create, |
| * and display the context menu. Turning this off will make |
| * WebKitGTK+ not emit the populate-popup signal. Notice that the |
| * default button press event handler may still handle right |
| * clicks for other reasons, such as in-page context menus, or |
| * right-clicks that are handled by the page itself. |
| * |
| * Since: 1.1.18 |
| * |
| * Deprecated: 1.10: Use #WebKitWebView::context-menu signal instead. |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_DEFAULT_CONTEXT_MENU, |
| g_param_spec_boolean( |
| "enable-default-context-menu", |
| _("Enable Default Context Menu"), |
| _("Enables the handling of right-clicks for the creation of the default context menu"), |
| TRUE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings::enable-site-specific-quirks: |
| * |
| * Whether to turn on site-specific hacks. Turning this on will |
| * tell WebKitGTK+ to use some site-specific workarounds for |
| * better web compatibility. For example, older versions of |
| * MediaWiki will incorrectly send WebKit a css file with KHTML |
| * workarounds. By turning on site-specific quirks, WebKit will |
| * special-case this and other cases to make the sites work. |
| * |
| * Since: 1.1.18 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_SITE_SPECIFIC_QUIRKS, |
| g_param_spec_boolean( |
| "enable-site-specific-quirks", |
| _("Enable Site Specific Quirks"), |
| _("Enables the site-specific compatibility workarounds"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-page-cache: |
| * |
| * Enable or disable the page cache. Disabling the page cache is |
| * generally only useful for special circumstances like low-memory |
| * scenarios or special purpose applications like static HTML |
| * viewers. This setting only controls the Page Cache, this cache |
| * is different than the disk-based or memory-based traditional |
| * resource caches, its point is to make going back and forth |
| * between pages much faster. For details about the different types |
| * of caches and their purposes see: |
| * http://webkit.org/blog/427/webkit-page-cache-i-the-basics/ |
| * |
| * Since: 1.1.18 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_PAGE_CACHE, |
| g_param_spec_boolean("enable-page-cache", |
| _("Enable page cache"), |
| _("Whether the page cache should be used"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:auto-resize-window: |
| * |
| * Web pages can request to modify the size and position of the |
| * window containing the #WebKitWebView through various DOM methods |
| * (resizeTo, moveTo, resizeBy, moveBy). By default WebKit will not |
| * honor this requests, but you can set this property to %TRUE if |
| * you'd like it to do so. If you wish to handle this manually, you |
| * can connect to the notify signal for the |
| * #WebKitWebWindowFeatures of your #WebKitWebView. |
| * |
| * Since: 1.1.22 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_AUTO_RESIZE_WINDOW, |
| g_param_spec_boolean("auto-resize-window", |
| _("Auto Resize Window"), |
| _("Automatically resize the toplevel window when a page requests it"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-file-access-from-file-uris: |
| * |
| * Boolean property to control file access for file:// URIs. If this |
| * option is enabled every file:// will have its own security unique domain. |
| * |
| * Since: 1.1.22 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_FILE_ACCESS_FROM_FILE_URIS, |
| g_param_spec_boolean("enable-file-access-from-file-uris", |
| "Enable file access from file URIs", |
| "Controls file access for file:// URIs.", |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-java-applet: |
| * |
| * Enable or disable support for the Java <applet> tag. Keep in |
| * mind that Java content can be still shown in the page through |
| * <object> or <embed>, which are the preferred tags for this task. |
| * |
| * Since: 1.1.22 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_JAVA_APPLET, |
| g_param_spec_boolean("enable-java-applet", |
| _("Enable Java Applet"), |
| _("Whether Java Applet support through <applet> should be enabled"), |
| TRUE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-hyperlink-auditing: |
| * |
| * Enable or disable support for <a ping>. |
| * |
| * Since: 1.2.5 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_HYPERLINK_AUDITING, |
| g_param_spec_boolean("enable-hyperlink-auditing", |
| _("Enable Hyperlink Auditing"), |
| _("Whether <a ping> should be able to send pings"), |
| FALSE, |
| flags)); |
| |
| /* Undocumented for now */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_FULLSCREEN, |
| g_param_spec_boolean("enable-fullscreen", |
| _("Enable Fullscreen"), |
| _("Whether the Mozilla style API should be enabled."), |
| FALSE, |
| flags)); |
| /** |
| * WebKitWebSettings:enable-webgl: |
| * |
| * Enable or disable support for WebGL on pages. WebGL is an experimental |
| * proposal for allowing web pages to use OpenGL ES-like calls directly. The |
| * standard is currently a work-in-progress by the Khronos Group. |
| * |
| * Since: 1.3.14 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_WEBGL, |
| g_param_spec_boolean("enable-webgl", |
| _("Enable WebGL"), |
| _("Whether WebGL content should be rendered"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-accelerated-compositing: |
| * |
| * Enable or disable support for accelerated compositing on pages. Accelerated |
| * compositing uses the GPU to render animations on pages smoothly and also allows |
| * proper rendering of 3D CSS transforms. |
| * |
| * Since: 1.7.5 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_ACCELERATED_COMPOSITING, |
| g_param_spec_boolean("enable-accelerated-compositing", |
| _("Enable accelerated compositing"), |
| _("Whether accelerated compositing should be enabled"), |
| FALSE, |
| flags)); |
| /** |
| * WebKitWebSettings:enable-webaudio: |
| * |
| * Enable or disable support for WebAudio on pages. WebAudio is an |
| * experimental proposal for allowing web pages to generate Audio |
| * WAVE data from JavaScript. The standard is currently a |
| * work-in-progress by the W3C Audio Working Group. |
| * |
| * See also https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html |
| * |
| * Since: TODO |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_WEB_AUDIO, |
| g_param_spec_boolean("enable-webaudio", |
| _("Enable WebAudio"), |
| _("Whether WebAudio content should be handled"), |
| FALSE, |
| flags)); |
| |
| |
| /** |
| * WebKitWebSettings:enable-dns-prefetching: |
| * |
| * Whether webkit prefetches domain names. This is a separate knob from private browsing. |
| * Whether private browsing should set this or not is up for debate, for now it doesn't. |
| * |
| * Since: 1.3.13. |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_DNS_PREFETCHING, |
| g_param_spec_boolean("enable-dns-prefetching", |
| _("WebKit prefetches domain names"), |
| _("Whether WebKit prefetches domain names"), |
| TRUE, |
| flags)); |
| /** |
| * WebKitWebSettings:enable-media-stream: |
| * |
| * Enable or disable support for Media Stream on pages. Media Stream is |
| * an experimental proposal for allowing web pages to access local video and |
| * audio input devices. The standard is currently a work-in-progress as part |
| * of the Web Applications 1.0 specification from WHATWG. |
| * |
| * See also http://www.w3.org/TR/mediacapture-streams/ |
| * |
| * Since: 1.10.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_MEDIA_STREAM, |
| g_param_spec_boolean("enable-media-stream", |
| _("Enable Media Stream"), |
| _("Whether Media Stream should be enabled"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-smooth-scrolling: |
| * |
| * Enable or disable support for smooth scrolling. The current implementation relies upon |
| * CPU work to produce a smooth scrolling experience. |
| * |
| * Since: 1.9.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_SMOOTH_SCROLLING, |
| g_param_spec_boolean("enable-smooth-scrolling", |
| _("Enable smooth scrolling"), |
| _("Whether to enable smooth scrolling"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:media-playback-requires-user-gesture: |
| * |
| * Whether a user gesture (such as clicking the play button) would |
| * be required to start media playback or load media. This is off |
| * by default, so media playback could start automatically. Setting |
| * it on requires a gesture by the user to start playback, or to load |
| * the media. |
| * |
| * Since: 1.10.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_MEDIA_PLAYBACK_REQUIRES_USER_GESTURE, |
| g_param_spec_boolean("media-playback-requires-user-gesture", |
| _("Media playback requires user gesture"), |
| _("Whether media playback requires user gesture"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:media-playback-allows-inline: |
| * |
| * Whether media playback is full-screen only or inline playback is allowed. |
| * This is true by default, so media playback can be inline. Setting it to |
| * false allows specifying that media playback should be always fullscreen. |
| * |
| * Since: 1.10.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_MEDIA_PLAYBACK_ALLOWS_INLINE, |
| g_param_spec_boolean("media-playback-allows-inline", |
| _("Media playback allows inline"), |
| _("Whether media playback allows inline"), |
| TRUE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-css-shaders: |
| * |
| * Enable or disable support for css shaders (css custom filters). |
| * Accelerated compositing needs to be enabled at compile time, but needs |
| * not be enabled at runtime. |
| * |
| * See also https://dvcs.w3.org/hg/FXTF/raw-file/tip/custom/index.html |
| * |
| * Since: 2.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_CSS_SHADERS, |
| g_param_spec_boolean("enable-css-shaders", |
| _("Enable CSS shaders"), |
| _("Whether to enable css shaders"), |
| FALSE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-display-of-insecure-content: |
| * |
| * Whether pages loaded via HTTPS should load subresources such as |
| * images and frames from non-HTTPS URLs. |
| * |
| * Since: 2.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_DISPLAY_OF_INSECURE_CONTENT, |
| g_param_spec_boolean("enable-display-of-insecure-content", |
| _("Enable display of insecure content"), |
| _("Whether non-HTTPS resources can display on HTTPS pages."), |
| TRUE, |
| flags)); |
| |
| /** |
| * WebKitWebSettings:enable-running-of-insecure-content: |
| * |
| * Whether pages loaded via HTTPS should run subresources such as |
| * CSS, scripts, and plugins from non-HTTPS URLs. |
| * |
| * Since: 2.0 |
| */ |
| g_object_class_install_property(gobject_class, |
| PROP_ENABLE_RUNNING_OF_INSECURE_CONTENT, |
| g_param_spec_boolean("enable-running-of-insecure-content", |
| _("Enable running of insecure content"), |
| _("Whether non-HTTPS resources can run on HTTPS pages."), |
| TRUE, |
| flags)); |
| } |
| |
| static void webkit_web_settings_init(WebKitWebSettings* web_settings) |
| { |
| web_settings->priv = new WebKitWebSettingsPrivate; |
| } |
| |
| static void webkit_web_settings_finalize(GObject* object) |
| { |
| delete WEBKIT_WEB_SETTINGS(object)->priv; |
| G_OBJECT_CLASS(webkit_web_settings_parent_class)->finalize(object); |
| } |
| |
| static void webkit_web_settings_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec) |
| { |
| WebKitWebSettings* web_settings = WEBKIT_WEB_SETTINGS(object); |
| WebKitWebSettingsPrivate* priv = web_settings->priv; |
| |
| switch(prop_id) { |
| case PROP_DEFAULT_ENCODING: |
| priv->defaultEncoding = g_value_get_string(value); |
| break; |
| case PROP_CURSIVE_FONT_FAMILY: |
| priv->cursiveFontFamily = g_value_get_string(value); |
| break; |
| case PROP_DEFAULT_FONT_FAMILY: |
| priv->defaultFontFamily = g_value_get_string(value); |
| break; |
| case PROP_FANTASY_FONT_FAMILY: |
| priv->fantasyFontFamily = g_value_get_string(value); |
| break; |
| case PROP_MONOSPACE_FONT_FAMILY: |
| priv->monospaceFontFamily = g_value_get_string(value); |
| break; |
| case PROP_SANS_SERIF_FONT_FAMILY: |
| priv->sansSerifFontFamily = g_value_get_string(value); |
| break; |
| case PROP_SERIF_FONT_FAMILY: |
| priv->serifFontFamily = g_value_get_string(value); |
| break; |
| case PROP_DEFAULT_FONT_SIZE: |
| priv->defaultFontSize = g_value_get_int(value); |
| break; |
| case PROP_DEFAULT_MONOSPACE_FONT_SIZE: |
| priv->defaultMonospaceFontSize = g_value_get_int(value); |
| break; |
| case PROP_MINIMUM_FONT_SIZE: |
| priv->minimumFontSize = g_value_get_int(value); |
| break; |
| case PROP_MINIMUM_LOGICAL_FONT_SIZE: |
| priv->minimumLogicalFontSize = g_value_get_int(value); |
| break; |
| case PROP_ENFORCE_96_DPI: |
| priv->enforce96DPI = g_value_get_boolean(value); |
| break; |
| case PROP_AUTO_LOAD_IMAGES: |
| priv->autoLoadImages = g_value_get_boolean(value); |
| break; |
| case PROP_AUTO_SHRINK_IMAGES: |
| priv->autoShrinkImages = g_value_get_boolean(value); |
| break; |
| case PROP_RESPECT_IMAGE_ORIENTATION: |
| priv->respectImageOrientation = g_value_get_boolean(value); |
| break; |
| case PROP_PRINT_BACKGROUNDS: |
| priv->printBackgrounds = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_SCRIPTS: |
| priv->enableScripts = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_PLUGINS: |
| priv->enablePlugins = g_value_get_boolean(value); |
| break; |
| case PROP_RESIZABLE_TEXT_AREAS: |
| priv->resizableTextAreas = g_value_get_boolean(value); |
| break; |
| case PROP_USER_STYLESHEET_URI: |
| priv->userStylesheetURI = g_value_get_string(value); |
| break; |
| case PROP_ZOOM_STEP: |
| priv->zoomStep = g_value_get_float(value); |
| break; |
| case PROP_ENABLE_DEVELOPER_EXTRAS: |
| priv->enableDeveloperExtras = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_PRIVATE_BROWSING: |
| priv->enablePrivateBrowsing = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_CARET_BROWSING: |
| priv->enableCaretBrowsing = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_HTML5_DATABASE: |
| priv->enableHTML5Database = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_HTML5_LOCAL_STORAGE: |
| priv->enableHTML5LocalStorage = g_value_get_boolean(value); |
| break; |
| case PROP_HTML5_LOCAL_STORAGE_DATABASE_PATH: |
| priv->html5LocalStorageDatabasePath = g_value_get_string(value); |
| break; |
| case PROP_ENABLE_SPELL_CHECKING: |
| priv->enableSpellChecking = g_value_get_boolean(value); |
| break; |
| case PROP_SPELL_CHECKING_LANGUAGES: |
| priv->spellCheckingLanguages = g_value_get_string(value); |
| break; |
| case PROP_ENABLE_XSS_AUDITOR: |
| priv->enableXSSAuditor = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_SPATIAL_NAVIGATION: |
| priv->enableSpatialNavigation = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_FRAME_FLATTENING: |
| priv->enableFrameFlattening = g_value_get_boolean(value); |
| break; |
| case PROP_USER_AGENT: |
| if (!g_value_get_string(value) || !strlen(g_value_get_string(value))) |
| priv->userAgent = standardUserAgent().utf8(); |
| else |
| priv->userAgent = g_value_get_string(value); |
| break; |
| case PROP_JAVASCRIPT_CAN_OPEN_WINDOWS_AUTOMATICALLY: |
| priv->javascriptCanOpenWindowsAutomatically = g_value_get_boolean(value); |
| break; |
| case PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD: |
| priv->javascriptCanAccessClipboard = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_OFFLINE_WEB_APPLICATION_CACHE: |
| priv->enableOfflineWebApplicationCache = g_value_get_boolean(value); |
| break; |
| case PROP_EDITING_BEHAVIOR: |
| priv->editingBehavior = static_cast<WebKitEditingBehavior>(g_value_get_enum(value)); |
| break; |
| case PROP_ENABLE_UNIVERSAL_ACCESS_FROM_FILE_URIS: |
| priv->enableUniversalAccessFromFileURIs = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_FILE_ACCESS_FROM_FILE_URIS: |
| priv->enableFileAccessFromFileURIs = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_DOM_PASTE: |
| priv->enableDOMPaste = g_value_get_boolean(value); |
| break; |
| case PROP_TAB_KEY_CYCLES_THROUGH_ELEMENTS: |
| priv->tabKeyCyclesThroughElements = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_DEFAULT_CONTEXT_MENU: |
| priv->enableDefaultContextMenu = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_SITE_SPECIFIC_QUIRKS: |
| priv->enableSiteSpecificQuirks = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_PAGE_CACHE: |
| priv->enablePageCache = g_value_get_boolean(value); |
| break; |
| case PROP_AUTO_RESIZE_WINDOW: |
| priv->autoResizeWindow = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_JAVA_APPLET: |
| priv->enableJavaApplet = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_HYPERLINK_AUDITING: |
| priv->enableHyperlinkAuditing = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_FULLSCREEN: |
| priv->enableFullscreen = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_DNS_PREFETCHING: |
| priv->enableDNSPrefetching = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_WEBGL: |
| priv->enableWebgl = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_MEDIA_STREAM: |
| priv->enableMediaStream = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_WEB_AUDIO: |
| priv->enableWebAudio = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_ACCELERATED_COMPOSITING: |
| priv->enableAcceleratedCompositing = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_SMOOTH_SCROLLING: |
| priv->enableSmoothScrolling = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_CSS_SHADERS: |
| priv->enableCSSShaders = g_value_get_boolean(value); |
| break; |
| case PROP_MEDIA_PLAYBACK_REQUIRES_USER_GESTURE: |
| priv->mediaPlaybackRequiresUserGesture = g_value_get_boolean(value); |
| break; |
| case PROP_MEDIA_PLAYBACK_ALLOWS_INLINE: |
| priv->mediaPlaybackAllowsInline = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_DISPLAY_OF_INSECURE_CONTENT: |
| priv->enableDisplayOfInsecureContent = g_value_get_boolean(value); |
| break; |
| case PROP_ENABLE_RUNNING_OF_INSECURE_CONTENT: |
| priv->enableRunningOfInsecureContent = g_value_get_boolean(value); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void webkit_web_settings_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec) |
| { |
| WebKitWebSettings* web_settings = WEBKIT_WEB_SETTINGS(object); |
| WebKitWebSettingsPrivate* priv = web_settings->priv; |
| |
| switch (prop_id) { |
| case PROP_DEFAULT_ENCODING: |
| g_value_set_string(value, priv->defaultEncoding.data()); |
| break; |
| case PROP_CURSIVE_FONT_FAMILY: |
| g_value_set_string(value, priv->cursiveFontFamily.data()); |
| break; |
| case PROP_DEFAULT_FONT_FAMILY: |
| g_value_set_string(value, priv->defaultFontFamily.data()); |
| break; |
| case PROP_FANTASY_FONT_FAMILY: |
| g_value_set_string(value, priv->fantasyFontFamily.data()); |
| break; |
| case PROP_MONOSPACE_FONT_FAMILY: |
| g_value_set_string(value, priv->monospaceFontFamily.data()); |
| break; |
| case PROP_SANS_SERIF_FONT_FAMILY: |
| g_value_set_string(value, priv->sansSerifFontFamily.data()); |
| break; |
| case PROP_SERIF_FONT_FAMILY: |
| g_value_set_string(value, priv->serifFontFamily.data()); |
| break; |
| case PROP_DEFAULT_FONT_SIZE: |
| g_value_set_int(value, priv->defaultFontSize); |
| break; |
| case PROP_DEFAULT_MONOSPACE_FONT_SIZE: |
| g_value_set_int(value, priv->defaultMonospaceFontSize); |
| break; |
| case PROP_MINIMUM_FONT_SIZE: |
| g_value_set_int(value, priv->minimumFontSize); |
| break; |
| case PROP_MINIMUM_LOGICAL_FONT_SIZE: |
| g_value_set_int(value, priv->minimumLogicalFontSize); |
| break; |
| case PROP_ENFORCE_96_DPI: |
| g_value_set_boolean(value, priv->enforce96DPI); |
| break; |
| case PROP_AUTO_LOAD_IMAGES: |
| g_value_set_boolean(value, priv->autoLoadImages); |
| break; |
| case PROP_AUTO_SHRINK_IMAGES: |
| g_value_set_boolean(value, priv->autoShrinkImages); |
| break; |
| case PROP_RESPECT_IMAGE_ORIENTATION: |
| g_value_set_boolean(value, priv->respectImageOrientation); |
| break; |
| case PROP_PRINT_BACKGROUNDS: |
| g_value_set_boolean(value, priv->printBackgrounds); |
| break; |
| case PROP_ENABLE_SCRIPTS: |
| g_value_set_boolean(value, priv->enableScripts); |
| break; |
| case PROP_ENABLE_PLUGINS: |
| g_value_set_boolean(value, priv->enablePlugins); |
| break; |
| case PROP_RESIZABLE_TEXT_AREAS: |
| g_value_set_boolean(value, priv->resizableTextAreas); |
| break; |
| case PROP_USER_STYLESHEET_URI: |
| g_value_set_string(value, priv->userStylesheetURI.data()); |
| break; |
| case PROP_ZOOM_STEP: |
| g_value_set_float(value, priv->zoomStep); |
| break; |
| case PROP_ENABLE_DEVELOPER_EXTRAS: |
| g_value_set_boolean(value, priv->enableDeveloperExtras); |
| break; |
| case PROP_ENABLE_PRIVATE_BROWSING: |
| g_value_set_boolean(value, priv->enablePrivateBrowsing); |
| break; |
| case PROP_ENABLE_CARET_BROWSING: |
| g_value_set_boolean(value, priv->enableCaretBrowsing); |
| break; |
| case PROP_ENABLE_HTML5_DATABASE: |
| g_value_set_boolean(value, priv->enableHTML5Database); |
| break; |
| case PROP_ENABLE_HTML5_LOCAL_STORAGE: |
| g_value_set_boolean(value, priv->enableHTML5LocalStorage); |
| break; |
| case PROP_HTML5_LOCAL_STORAGE_DATABASE_PATH: |
| g_value_set_string(value, priv->html5LocalStorageDatabasePath.data()); |
| break; |
| case PROP_ENABLE_SPELL_CHECKING: |
| g_value_set_boolean(value, priv->enableSpellChecking); |
| break; |
| case PROP_SPELL_CHECKING_LANGUAGES: |
| g_value_set_string(value, priv->spellCheckingLanguages.data()); |
| break; |
| case PROP_ENABLE_XSS_AUDITOR: |
| g_value_set_boolean(value, priv->enableXSSAuditor); |
| break; |
| case PROP_ENABLE_SPATIAL_NAVIGATION: |
| g_value_set_boolean(value, priv->enableSpatialNavigation); |
| break; |
| case PROP_ENABLE_FRAME_FLATTENING: |
| g_value_set_boolean(value, priv->enableFrameFlattening); |
| break; |
| case PROP_USER_AGENT: |
| g_value_set_string(value, priv->userAgent.data()); |
| break; |
| case PROP_JAVASCRIPT_CAN_OPEN_WINDOWS_AUTOMATICALLY: |
| g_value_set_boolean(value, priv->javascriptCanOpenWindowsAutomatically); |
| break; |
| case PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD: |
| g_value_set_boolean(value, priv->javascriptCanAccessClipboard); |
| break; |
| case PROP_ENABLE_OFFLINE_WEB_APPLICATION_CACHE: |
| g_value_set_boolean(value, priv->enableOfflineWebApplicationCache); |
| break; |
| case PROP_EDITING_BEHAVIOR: |
| g_value_set_enum(value, priv->editingBehavior); |
| break; |
| case PROP_ENABLE_UNIVERSAL_ACCESS_FROM_FILE_URIS: |
| g_value_set_boolean(value, priv->enableUniversalAccessFromFileURIs); |
| break; |
| case PROP_ENABLE_FILE_ACCESS_FROM_FILE_URIS: |
| g_value_set_boolean(value, priv->enableFileAccessFromFileURIs); |
| break; |
| case PROP_ENABLE_DOM_PASTE: |
| g_value_set_boolean(value, priv->enableDOMPaste); |
| break; |
| case PROP_TAB_KEY_CYCLES_THROUGH_ELEMENTS: |
| g_value_set_boolean(value, priv->tabKeyCyclesThroughElements); |
| break; |
| case PROP_ENABLE_DEFAULT_CONTEXT_MENU: |
| g_value_set_boolean(value, priv->enableDefaultContextMenu); |
| break; |
| case PROP_ENABLE_SITE_SPECIFIC_QUIRKS: |
| g_value_set_boolean(value, priv->enableSiteSpecificQuirks); |
| break; |
| case PROP_ENABLE_PAGE_CACHE: |
| g_value_set_boolean(value, priv->enablePageCache); |
| break; |
| case PROP_AUTO_RESIZE_WINDOW: |
| g_value_set_boolean(value, priv->autoResizeWindow); |
| break; |
| case PROP_ENABLE_JAVA_APPLET: |
| g_value_set_boolean(value, priv->enableJavaApplet); |
| break; |
| case PROP_ENABLE_HYPERLINK_AUDITING: |
| g_value_set_boolean(value, priv->enableHyperlinkAuditing); |
| break; |
| case PROP_ENABLE_FULLSCREEN: |
| g_value_set_boolean(value, priv->enableFullscreen); |
| break; |
| case PROP_ENABLE_DNS_PREFETCHING: |
| g_value_set_boolean(value, priv->enableDNSPrefetching); |
| break; |
| case PROP_ENABLE_WEBGL: |
| g_value_set_boolean(value, priv->enableWebgl); |
| break; |
| case PROP_ENABLE_MEDIA_STREAM: |
| g_value_set_boolean(value, priv->enableMediaStream); |
| break; |
| case PROP_ENABLE_WEB_AUDIO: |
| g_value_set_boolean(value, priv->enableWebAudio); |
| break; |
| case PROP_ENABLE_ACCELERATED_COMPOSITING: |
| g_value_set_boolean(value, priv->enableAcceleratedCompositing); |
| break; |
| case PROP_ENABLE_SMOOTH_SCROLLING: |
| g_value_set_boolean(value, priv->enableSmoothScrolling); |
| break; |
| case PROP_ENABLE_CSS_SHADERS: |
| g_value_set_boolean(value, priv->enableCSSShaders); |
| break; |
| case PROP_MEDIA_PLAYBACK_REQUIRES_USER_GESTURE: |
| g_value_set_boolean(value, priv->mediaPlaybackRequiresUserGesture); |
| break; |
| case PROP_MEDIA_PLAYBACK_ALLOWS_INLINE: |
| g_value_set_boolean(value, priv->mediaPlaybackAllowsInline); |
| break; |
| case PROP_ENABLE_DISPLAY_OF_INSECURE_CONTENT: |
| g_value_set_boolean(value, priv->enableDisplayOfInsecureContent); |
| break; |
| case PROP_ENABLE_RUNNING_OF_INSECURE_CONTENT: |
| g_value_set_boolean(value, priv->enableRunningOfInsecureContent); |
| break; |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| /** |
| * webkit_web_settings_new: |
| * |
| * Creates a new #WebKitWebSettings instance with default values. It must |
| * be manually attached to a WebView. |
| * |
| * Returns: a new #WebKitWebSettings instance |
| **/ |
| WebKitWebSettings* webkit_web_settings_new() |
| { |
| return WEBKIT_WEB_SETTINGS(g_object_new(WEBKIT_TYPE_WEB_SETTINGS, NULL)); |
| } |
| |
| /** |
| * webkit_web_settings_copy: |
| * @web_settings: a #WebKitWebSettings to copy. |
| * |
| * Copies an existing #WebKitWebSettings instance. |
| * |
| * Returns: (transfer full): a new #WebKitWebSettings instance |
| **/ |
| WebKitWebSettings* webkit_web_settings_copy(WebKitWebSettings* original) |
| { |
| unsigned numberOfProperties = 0; |
| GOwnPtr<GParamSpec*> properties(g_object_class_list_properties( |
| G_OBJECT_CLASS(WEBKIT_WEB_SETTINGS_GET_CLASS(original)), &numberOfProperties)); |
| GOwnPtr<GParameter> parameters(g_new0(GParameter, numberOfProperties)); |
| |
| for (size_t i = 0; i < numberOfProperties; i++) { |
| GParamSpec* property = properties.get()[i]; |
| GParameter* parameter = parameters.get() + i; |
| |
| if (!(property->flags & (G_PARAM_CONSTRUCT | G_PARAM_READWRITE))) |
| continue; |
| |
| parameter->name = property->name; |
| g_value_init(¶meter->value, property->value_type); |
| g_object_get_property(G_OBJECT(original), property->name, ¶meter->value); |
| } |
| |
| return WEBKIT_WEB_SETTINGS(g_object_newv(WEBKIT_TYPE_WEB_SETTINGS, numberOfProperties, parameters.get())); |
| |
| } |
| |
| /** |
| * webkit_web_settings_add_extra_plugin_directory: |
| * @web_view: a #WebKitWebView |
| * @directory: the directory to add |
| * |
| * Adds the @directory to paths where @web_view will search for plugins. |
| * |
| * Since: 1.0.3 |
| */ |
| void webkit_web_settings_add_extra_plugin_directory(WebKitWebView* webView, const gchar* directory) |
| { |
| g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView)); |
| PluginDatabase::installedPlugins()->addExtraPluginDirectory(filenameToString(directory)); |
| } |
| |
| /** |
| * webkit_web_settings_get_user_agent: |
| * @web_settings: a #WebKitWebSettings |
| * |
| * Returns: the User-Agent string currently used by the web view(s) associated |
| * with the @web_settings. |
| * |
| * Since: 1.1.11 |
| */ |
| const gchar* webkit_web_settings_get_user_agent(WebKitWebSettings* webSettings) |
| { |
| g_return_val_if_fail(WEBKIT_IS_WEB_SETTINGS(webSettings), 0); |
| return webSettings->priv->userAgent.data(); |
| } |
| |
| static void initializeDomainsList(HashSet<String>& googleDomains) |
| { |
| // Google search domains. |
| googleDomains.add("biz"); |
| googleDomains.add("com"); |
| googleDomains.add("net"); |
| googleDomains.add("org"); |
| googleDomains.add("ae"); |
| googleDomains.add("ag"); |
| googleDomains.add("am"); |
| googleDomains.add("at"); |
| googleDomains.add("az"); |
| googleDomains.add("be"); |
| googleDomains.add("bi"); |
| googleDomains.add("ca"); |
| googleDomains.add("cc"); |
| googleDomains.add("cd"); |
| googleDomains.add("cg"); |
| googleDomains.add("ch"); |
| googleDomains.add("cl"); |
| googleDomains.add("com.br"); |
| googleDomains.add("com.do"); |
| googleDomains.add("co.uk"); |
| googleDomains.add("co.kr"); |
| googleDomains.add("co.jp"); |
| googleDomains.add("de"); |
| googleDomains.add("dj"); |
| googleDomains.add("dk"); |
| googleDomains.add("ee"); |
| googleDomains.add("es"); |
| googleDomains.add("fi"); |
| googleDomains.add("fm"); |
| googleDomains.add("fr"); |
| googleDomains.add("gg"); |
| googleDomains.add("gl"); |
| googleDomains.add("gm"); |
| googleDomains.add("gs"); |
| googleDomains.add("hn"); |
| googleDomains.add("hu"); |
| googleDomains.add("ie"); |
| googleDomains.add("it"); |
| googleDomains.add("je"); |
| googleDomains.add("kz"); |
| googleDomains.add("li"); |
| googleDomains.add("lt"); |
| googleDomains.add("lu"); |
| googleDomains.add("lv"); |
| googleDomains.add("ma"); |
| googleDomains.add("ms"); |
| googleDomains.add("mu"); |
| googleDomains.add("mw"); |
| googleDomains.add("nl"); |
| googleDomains.add("no"); |
| googleDomains.add("nu"); |
| googleDomains.add("pl"); |
| googleDomains.add("pn"); |
| googleDomains.add("pt"); |
| googleDomains.add("ru"); |
| googleDomains.add("rw"); |
| googleDomains.add("sh"); |
| googleDomains.add("sk"); |
| googleDomains.add("sm"); |
| googleDomains.add("st"); |
| googleDomains.add("td"); |
| googleDomains.add("tk"); |
| googleDomains.add("tp"); |
| googleDomains.add("tv"); |
| googleDomains.add("us"); |
| googleDomains.add("uz"); |
| googleDomains.add("ws"); |
| } |
| |
| static void initializeOtherGoogleDomains(Vector<String>& otherGoogleDomains) |
| { |
| otherGoogleDomains.append("gmail.com"); |
| otherGoogleDomains.append("youtube.com"); |
| otherGoogleDomains.append("gstatic.com"); |
| otherGoogleDomains.append("ytimg.com"); |
| } |
| |
| static bool isGoogleDomain(String host) |
| { |
| DEFINE_STATIC_LOCAL(HashSet<String>, googleDomains, ()); |
| DEFINE_STATIC_LOCAL(Vector<String>, otherGoogleDomains, ()); |
| |
| if (googleDomains.isEmpty()) |
| initializeDomainsList(googleDomains); |
| |
| if (otherGoogleDomains.isEmpty()) |
| initializeOtherGoogleDomains(otherGoogleDomains); |
| |
| // First check if this is one of the various google.com international domains. |
| int position = host.find(".google."); |
| if (position > 0 && googleDomains.contains(host.substring(position + sizeof(".google.") - 1))) |
| return true; |
| |
| // Then we check the possibility of it being one of the other, .com-only google domains. |
| for (unsigned int i = 0; i < otherGoogleDomains.size(); i++) { |
| if (host.endsWith(otherGoogleDomains.at(i))) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static String userAgentForURL(const KURL& url) |
| { |
| // For Google domains, drop the browser's custom User Agent string, and use the |
| // standard Chrome one, so they don't give us a broken experience. |
| if (isGoogleDomain(url.host())) |
| return standardUserAgent(); |
| |
| return String(); |
| } |
| |
| /* |
| * Private usage only. |
| * webkitWebSettingsUserAgentForURI: |
| * @web_settings: the #WebKitWebSettings object to query |
| * @uri: the URI we want to know the User-Agent for |
| * |
| * Some web sites have been using User-Agent parsing heavily to decide |
| * the kind of content that is sent to the browser. When |
| * WebKitWebSettings:enable-site-specific-quirks is enabled WebKitGTK+ |
| * will use its knowledge of sites doing bad things and lie to them by |
| * sending either the default User-Agent, i.e. not using the one |
| * specified by the browser in WebKitWebSettings:user-agent, or the |
| * Safari one (including lying about the underlying operating system). |
| * |
| * This function allows the browser to figure out what User-Agent is |
| * going to be sent to a particular URI. |
| * |
| * Please note that if WebKitWebSettings:use-site-specific-quirks is |
| * turned off calling this function is the same as calling |
| * webkit_web_settings_get_user_agent(), except you have to free the |
| * result. |
| * |
| * Returns: (transfer full): a newly allocated string containing the |
| * User-Agent that will be sent for the given URI. |
| */ |
| char* webkitWebSettingsUserAgentForURI(WebKitWebSettings* webSettings, const char* uri) |
| { |
| if (webSettings->priv->enableSiteSpecificQuirks) { |
| String userAgentString = userAgentForURL(WebCore::KURL(WebCore::KURL(), String::fromUTF8(uri))); |
| if (!userAgentString.isEmpty()) |
| return g_strdup(userAgentString.utf8().data()); |
| } |
| |
| return g_strdup(webkit_web_settings_get_user_agent(webSettings)); |
| } |
| |
| namespace WebKit { |
| |
| WebCore::EditingBehaviorType core(WebKitEditingBehavior type) |
| { |
| return static_cast<WebCore::EditingBehaviorType>(type); |
| } |
| |
| } |
