WebKitSettings.cpp [plain text]
#include "config.h"
#include "WebKitSettings.h"
#include "WebKitPrivate.h"
#include "WebKitSettingsPrivate.h"
#include <glib/gi18n-lib.h>
#include <wtf/text/CString.h>
struct _WebKitSettingsPrivate {
WKRetainPtr<WKPreferencesRef> preferences;
CString defaultFontFamily;
CString monospaceFontFamily;
CString serifFontFamily;
CString sansSerifFontFamily;
CString cursiveFontFamily;
CString fantasyFontFamily;
CString pictographFontFamily;
CString defaultCharset;
bool zoomTextOnly;
};
G_DEFINE_TYPE(WebKitSettings, webkit_settings, G_TYPE_OBJECT)
enum {
PROP_0,
PROP_ENABLE_JAVASCRIPT,
PROP_AUTO_LOAD_IMAGES,
PROP_LOAD_ICONS_IGNORING_IMAGE_LOAD_SETTING,
PROP_ENABLE_OFFLINE_WEB_APPLICATION_CACHE,
PROP_ENABLE_HTML5_LOCAL_STORAGE,
PROP_ENABLE_HTML5_DATABASE,
PROP_ENABLE_XSS_AUDITOR,
PROP_ENABLE_FRAME_FLATTENING,
PROP_ENABLE_PLUGINS,
PROP_ENABLE_JAVA,
PROP_JAVASCRIPT_CAN_OPEN_WINDOWS_AUTOMATICALLY,
PROP_ENABLE_HYPERLINK_AUDITING,
PROP_DEFAULT_FONT_FAMILY,
PROP_MONOSPACE_FONT_FAMILY,
PROP_SERIF_FONT_FAMILY,
PROP_SANS_SERIF_FONT_FAMILY,
PROP_CURSIVE_FONT_FAMILY,
PROP_FANTASY_FONT_FAMILY,
PROP_PICTOGRAPH_FONT_FAMILY,
PROP_DEFAULT_FONT_SIZE,
PROP_DEFAULT_MONOSPACE_FONT_SIZE,
PROP_MINIMUM_FONT_SIZE,
PROP_DEFAULT_CHARSET,
PROP_ENABLE_PRIVATE_BROWSING,
PROP_ENABLE_DEVELOPER_EXTRAS,
PROP_ENABLE_RESIZABLE_TEXT_AREAS,
PROP_ENABLE_TABS_TO_LINKS,
PROP_ENABLE_DNS_PREFETCHING,
PROP_ENABLE_CARET_BROWSING,
PROP_ENABLE_FULLSCREEN,
PROP_PRINT_BACKGROUNDS,
PROP_ENABLE_WEBAUDIO,
PROP_ENABLE_WEBGL,
PROP_ZOOM_TEXT_ONLY,
PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD
};
static void webKitSettingsSetProperty(GObject* object, guint propId, const GValue* value, GParamSpec* paramSpec)
{
WebKitSettings* settings = WEBKIT_SETTINGS(object);
switch (propId) {
case PROP_ENABLE_JAVASCRIPT:
webkit_settings_set_enable_javascript(settings, g_value_get_boolean(value));
break;
case PROP_AUTO_LOAD_IMAGES:
webkit_settings_set_auto_load_images(settings, g_value_get_boolean(value));
break;
case PROP_LOAD_ICONS_IGNORING_IMAGE_LOAD_SETTING:
webkit_settings_set_load_icons_ignoring_image_load_setting(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_OFFLINE_WEB_APPLICATION_CACHE:
webkit_settings_set_enable_offline_web_application_cache(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_HTML5_LOCAL_STORAGE:
webkit_settings_set_enable_html5_local_storage(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_HTML5_DATABASE:
webkit_settings_set_enable_html5_database(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_XSS_AUDITOR:
webkit_settings_set_enable_xss_auditor(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_FRAME_FLATTENING:
webkit_settings_set_enable_frame_flattening(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_PLUGINS:
webkit_settings_set_enable_plugins(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_JAVA:
webkit_settings_set_enable_java(settings, g_value_get_boolean(value));
break;
case PROP_JAVASCRIPT_CAN_OPEN_WINDOWS_AUTOMATICALLY:
webkit_settings_set_javascript_can_open_windows_automatically(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_HYPERLINK_AUDITING:
webkit_settings_set_enable_hyperlink_auditing(settings, g_value_get_boolean(value));
break;
case PROP_DEFAULT_FONT_FAMILY:
webkit_settings_set_default_font_family(settings, g_value_get_string(value));
break;
case PROP_MONOSPACE_FONT_FAMILY:
webkit_settings_set_monospace_font_family(settings, g_value_get_string(value));
break;
case PROP_SERIF_FONT_FAMILY:
webkit_settings_set_serif_font_family(settings, g_value_get_string(value));
break;
case PROP_SANS_SERIF_FONT_FAMILY:
webkit_settings_set_sans_serif_font_family(settings, g_value_get_string(value));
break;
case PROP_CURSIVE_FONT_FAMILY:
webkit_settings_set_cursive_font_family(settings, g_value_get_string(value));
break;
case PROP_FANTASY_FONT_FAMILY:
webkit_settings_set_fantasy_font_family(settings, g_value_get_string(value));
break;
case PROP_PICTOGRAPH_FONT_FAMILY:
webkit_settings_set_pictograph_font_family(settings, g_value_get_string(value));
break;
case PROP_DEFAULT_FONT_SIZE:
webkit_settings_set_default_font_size(settings, g_value_get_uint(value));
break;
case PROP_DEFAULT_MONOSPACE_FONT_SIZE:
webkit_settings_set_default_monospace_font_size(settings, g_value_get_uint(value));
break;
case PROP_MINIMUM_FONT_SIZE:
webkit_settings_set_minimum_font_size(settings, g_value_get_uint(value));
break;
case PROP_DEFAULT_CHARSET:
webkit_settings_set_default_charset(settings, g_value_get_string(value));
break;
case PROP_ENABLE_PRIVATE_BROWSING:
webkit_settings_set_enable_private_browsing(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_DEVELOPER_EXTRAS:
webkit_settings_set_enable_developer_extras(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_RESIZABLE_TEXT_AREAS:
webkit_settings_set_enable_resizable_text_areas(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_TABS_TO_LINKS:
webkit_settings_set_enable_tabs_to_links(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_DNS_PREFETCHING:
webkit_settings_set_enable_dns_prefetching(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_CARET_BROWSING:
webkit_settings_set_enable_caret_browsing(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_FULLSCREEN:
webkit_settings_set_enable_fullscreen(settings, g_value_get_boolean(value));
break;
case PROP_PRINT_BACKGROUNDS:
webkit_settings_set_print_backgrounds(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_WEBAUDIO:
webkit_settings_set_enable_webaudio(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_WEBGL:
webkit_settings_set_enable_webgl(settings, g_value_get_boolean(value));
break;
case PROP_ZOOM_TEXT_ONLY:
webkit_settings_set_zoom_text_only(settings, g_value_get_boolean(value));
break;
case PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD:
webkit_settings_set_javascript_can_access_clipboard(settings, g_value_get_boolean(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
break;
}
}
static void webKitSettingsGetProperty(GObject* object, guint propId, GValue* value, GParamSpec* paramSpec)
{
WebKitSettings* settings = WEBKIT_SETTINGS(object);
switch (propId) {
case PROP_ENABLE_JAVASCRIPT:
g_value_set_boolean(value, webkit_settings_get_enable_javascript(settings));
break;
case PROP_AUTO_LOAD_IMAGES:
g_value_set_boolean(value, webkit_settings_get_auto_load_images(settings));
break;
case PROP_LOAD_ICONS_IGNORING_IMAGE_LOAD_SETTING:
g_value_set_boolean(value, webkit_settings_get_load_icons_ignoring_image_load_setting(settings));
break;
case PROP_ENABLE_OFFLINE_WEB_APPLICATION_CACHE:
g_value_set_boolean(value, webkit_settings_get_enable_offline_web_application_cache(settings));
break;
case PROP_ENABLE_HTML5_LOCAL_STORAGE:
g_value_set_boolean(value, webkit_settings_get_enable_html5_local_storage(settings));
break;
case PROP_ENABLE_HTML5_DATABASE:
g_value_set_boolean(value, webkit_settings_get_enable_html5_database(settings));
break;
case PROP_ENABLE_XSS_AUDITOR:
g_value_set_boolean(value, webkit_settings_get_enable_xss_auditor(settings));
break;
case PROP_ENABLE_FRAME_FLATTENING:
g_value_set_boolean(value, webkit_settings_get_enable_frame_flattening(settings));
break;
case PROP_ENABLE_PLUGINS:
g_value_set_boolean(value, webkit_settings_get_enable_plugins(settings));
break;
case PROP_ENABLE_JAVA:
g_value_set_boolean(value, webkit_settings_get_enable_java(settings));
break;
case PROP_JAVASCRIPT_CAN_OPEN_WINDOWS_AUTOMATICALLY:
g_value_set_boolean(value, webkit_settings_get_javascript_can_open_windows_automatically(settings));
break;
case PROP_ENABLE_HYPERLINK_AUDITING:
g_value_set_boolean(value, webkit_settings_get_enable_hyperlink_auditing(settings));
break;
case PROP_DEFAULT_FONT_FAMILY:
g_value_set_string(value, webkit_settings_get_default_font_family(settings));
break;
case PROP_MONOSPACE_FONT_FAMILY:
g_value_set_string(value, webkit_settings_get_monospace_font_family(settings));
break;
case PROP_SERIF_FONT_FAMILY:
g_value_set_string(value, webkit_settings_get_serif_font_family(settings));
break;
case PROP_SANS_SERIF_FONT_FAMILY:
g_value_set_string(value, webkit_settings_get_sans_serif_font_family(settings));
break;
case PROP_CURSIVE_FONT_FAMILY:
g_value_set_string(value, webkit_settings_get_cursive_font_family(settings));
break;
case PROP_FANTASY_FONT_FAMILY:
g_value_set_string(value, webkit_settings_get_fantasy_font_family(settings));
break;
case PROP_PICTOGRAPH_FONT_FAMILY:
g_value_set_string(value, webkit_settings_get_pictograph_font_family(settings));
break;
case PROP_DEFAULT_FONT_SIZE:
g_value_set_uint(value, webkit_settings_get_default_font_size(settings));
break;
case PROP_DEFAULT_MONOSPACE_FONT_SIZE:
g_value_set_uint(value, webkit_settings_get_default_monospace_font_size(settings));
break;
case PROP_MINIMUM_FONT_SIZE:
g_value_set_uint(value, webkit_settings_get_minimum_font_size(settings));
break;
case PROP_DEFAULT_CHARSET:
g_value_set_string(value, webkit_settings_get_default_charset(settings));
break;
case PROP_ENABLE_PRIVATE_BROWSING:
g_value_set_boolean(value, webkit_settings_get_enable_private_browsing(settings));
break;
case PROP_ENABLE_DEVELOPER_EXTRAS:
g_value_set_boolean(value, webkit_settings_get_enable_developer_extras(settings));
break;
case PROP_ENABLE_RESIZABLE_TEXT_AREAS:
g_value_set_boolean(value, webkit_settings_get_enable_resizable_text_areas(settings));
break;
case PROP_ENABLE_TABS_TO_LINKS:
g_value_set_boolean(value, webkit_settings_get_enable_tabs_to_links(settings));
break;
case PROP_ENABLE_DNS_PREFETCHING:
g_value_set_boolean(value, webkit_settings_get_enable_dns_prefetching(settings));
break;
case PROP_ENABLE_CARET_BROWSING:
g_value_set_boolean(value, webkit_settings_get_enable_caret_browsing(settings));
break;
case PROP_ENABLE_FULLSCREEN:
g_value_set_boolean(value, webkit_settings_get_enable_fullscreen(settings));
break;
case PROP_PRINT_BACKGROUNDS:
g_value_set_boolean(value, webkit_settings_get_print_backgrounds(settings));
break;
case PROP_ENABLE_WEBAUDIO:
g_value_set_boolean(value, webkit_settings_get_enable_webaudio(settings));
break;
case PROP_ENABLE_WEBGL:
g_value_set_boolean(value, webkit_settings_get_enable_webgl(settings));
break;
case PROP_ZOOM_TEXT_ONLY:
g_value_set_boolean(value, webkit_settings_get_zoom_text_only(settings));
break;
case PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD:
g_value_set_boolean(value, webkit_settings_get_javascript_can_access_clipboard(settings));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
break;
}
}
static void webKitSettingsFinalize(GObject* object)
{
WEBKIT_SETTINGS(object)->priv->~WebKitSettingsPrivate();
G_OBJECT_CLASS(webkit_settings_parent_class)->finalize(object);
}
static void webkit_settings_class_init(WebKitSettingsClass* klass)
{
GObjectClass* gObjectClass = G_OBJECT_CLASS(klass);
gObjectClass->set_property = webKitSettingsSetProperty;
gObjectClass->get_property = webKitSettingsGetProperty;
gObjectClass->finalize = webKitSettingsFinalize;
GParamFlags readWriteConstructParamFlags = static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT);
g_object_class_install_property(gObjectClass,
PROP_ENABLE_JAVASCRIPT,
g_param_spec_boolean("enable-javascript",
_("Enable JavaScript"),
_("Enable JavaScript."),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_AUTO_LOAD_IMAGES,
g_param_spec_boolean("auto-load-images",
_("Auto load images"),
_("Load images automatically."),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_LOAD_ICONS_IGNORING_IMAGE_LOAD_SETTING,
g_param_spec_boolean("load-icons-ignoring-image-load-setting",
_("Load icons ignoring image load setting"),
_("Whether to load site icons ignoring image load setting."),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
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,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
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,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_HTML5_DATABASE,
g_param_spec_boolean("enable-html5-database",
_("Enable HTML5 database"),
_("Whether to enable HTML5 database support."),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_XSS_AUDITOR,
g_param_spec_boolean("enable-xss-auditor",
_("Enable XSS auditor"),
_("Whether to enable the XSS auditor."),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_FRAME_FLATTENING,
g_param_spec_boolean("enable-frame-flattening",
_("Enable frame flattening"),
_("Whether to enable frame flattening."),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_PLUGINS,
g_param_spec_boolean("enable-plugins",
_("Enable plugins"),
_("Enable embedded plugin objects."),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_JAVA,
g_param_spec_boolean("enable-java",
_("Enable Java"),
_("Whether Java support should be enabled."),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
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,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_HYPERLINK_AUDITING,
g_param_spec_boolean("enable-hyperlink-auditing",
_("Enable hyperlink auditing"),
_("Whether <a ping> should be able to send pings."),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_DEFAULT_FONT_FAMILY,
g_param_spec_string("default-font-family",
_("Default font family"),
_("The font family to use as the default for content that does not specify a font."),
"sans-serif",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_MONOSPACE_FONT_FAMILY,
g_param_spec_string("monospace-font-family",
_("Monospace font family"),
_("The font family used as the default for content using monospace font."),
"monospace",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_SERIF_FONT_FAMILY,
g_param_spec_string("serif-font-family",
_("Serif font family"),
_("The font family used as the default for content using serif font."),
"serif",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_SANS_SERIF_FONT_FAMILY,
g_param_spec_string("sans-serif-font-family",
_("Sans-serif font family"),
_("The font family used as the default for content using sans-serif font."),
"sans-serif",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_CURSIVE_FONT_FAMILY,
g_param_spec_string("cursive-font-family",
_("Cursive font family"),
_("The font family used as the default for content using cursive font."),
"serif",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_FANTASY_FONT_FAMILY,
g_param_spec_string("fantasy-font-family",
_("Fantasy font family"),
_("The font family used as the default for content using fantasy font."),
"serif",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_PICTOGRAPH_FONT_FAMILY,
g_param_spec_string("pictograph-font-family",
_("Pictograph font family"),
_("The font family used as the default for content using pictograph font."),
"serif",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_DEFAULT_FONT_SIZE,
g_param_spec_uint("default-font-size",
_("Default font size"),
_("The default font size used to display text."),
0, G_MAXUINT, 16,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_DEFAULT_MONOSPACE_FONT_SIZE,
g_param_spec_uint("default-monospace-font-size",
_("Default monospace font size"),
_("The default font size used to display monospace text."),
0, G_MAXUINT, 13,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_MINIMUM_FONT_SIZE,
g_param_spec_uint("minimum-font-size",
_("Minimum font size"),
_("The minimum font size used to display text."),
0, G_MAXUINT, 0,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_DEFAULT_CHARSET,
g_param_spec_string("default-charset",
_("Default charset"),
_("The default text charset used when interpreting content with unspecified charset."),
"iso-8859-1",
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_PRIVATE_BROWSING,
g_param_spec_boolean("enable-private-browsing",
_("Enable private browsing"),
_("Whether to enable private browsing"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_DEVELOPER_EXTRAS,
g_param_spec_boolean("enable-developer-extras",
_("Enable developer extras"),
_("Whether to enable developer extras"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_RESIZABLE_TEXT_AREAS,
g_param_spec_boolean("enable-resizable-text-areas",
_("Enable resizable text areas"),
_("Whether to enable resizable text areas"),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_TABS_TO_LINKS,
g_param_spec_boolean("enable-tabs-to-links",
_("Enable tabs to links"),
_("Whether to enable tabs to links"),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_DNS_PREFETCHING,
g_param_spec_boolean("enable-dns-prefetching",
_("Enable DNS prefetching"),
_("Whether to enable DNS prefetching"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_CARET_BROWSING,
g_param_spec_boolean("enable-caret-browsing",
_("Enable Caret Browsing"),
_("Whether to enable accessibility enhanced keyboard navigation"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_FULLSCREEN,
g_param_spec_boolean("enable-fullscreen",
_("Enable Fullscreen"),
_("Whether to enable the Javascriipt Fullscreen API"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_PRINT_BACKGROUNDS,
g_param_spec_boolean("print-backgrounds",
_("Print Backgrounds"),
_("Whether background images should be drawn during printing"),
TRUE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_WEBAUDIO,
g_param_spec_boolean("enable-webaudio",
_("Enable WebAudio"),
_("Whether WebAudio content should be handled"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ENABLE_WEBGL,
g_param_spec_boolean("enable-webgl",
_("Enable WebGL"),
_("Whether WebGL content should be rendered"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_ZOOM_TEXT_ONLY,
g_param_spec_boolean("zoom-text-only",
_("Zoom Text Only"),
_("Whether zoom level of web view changes only the text size"),
FALSE,
readWriteConstructParamFlags));
g_object_class_install_property(gObjectClass,
PROP_JAVASCRIPT_CAN_ACCESS_CLIPBOARD,
g_param_spec_boolean("javascript-can-access-clipboard",
_("JavaScript can access clipboard"),
_("Whether JavaScript can access Clipboard"),
FALSE,
readWriteConstructParamFlags));
g_type_class_add_private(klass, sizeof(WebKitSettingsPrivate));
}
static void webkit_settings_init(WebKitSettings* settings)
{
WebKitSettingsPrivate* priv = G_TYPE_INSTANCE_GET_PRIVATE(settings, WEBKIT_TYPE_SETTINGS, WebKitSettingsPrivate);
settings->priv = priv;
new (priv) WebKitSettingsPrivate();
priv->preferences = adoptWK(WKPreferencesCreate());
WKRetainPtr<WKStringRef> defaultFontFamilyRef = WKPreferencesCopyStandardFontFamily(priv->preferences.get());
priv->defaultFontFamily = WebKit::toImpl(defaultFontFamilyRef.get())->string().utf8();
WKRetainPtr<WKStringRef> monospaceFontFamilyRef = WKPreferencesCopyFixedFontFamily(priv->preferences.get());
priv->monospaceFontFamily = WebKit::toImpl(monospaceFontFamilyRef.get())->string().utf8();
WKRetainPtr<WKStringRef> serifFontFamilyRef = WKPreferencesCopySerifFontFamily(priv->preferences.get());
priv->serifFontFamily = WebKit::toImpl(serifFontFamilyRef.get())->string().utf8();
WKRetainPtr<WKStringRef> sansSerifFontFamilyRef = WKPreferencesCopySansSerifFontFamily(priv->preferences.get());
priv->sansSerifFontFamily = WebKit::toImpl(sansSerifFontFamilyRef.get())->string().utf8();
WKRetainPtr<WKStringRef> cursiveFontFamilyRef = WKPreferencesCopyCursiveFontFamily(priv->preferences.get());
priv->cursiveFontFamily = WebKit::toImpl(cursiveFontFamilyRef.get())->string().utf8();
WKRetainPtr<WKStringRef> fantasyFontFamilyRef = WKPreferencesCopyFantasyFontFamily(priv->preferences.get());
priv->fantasyFontFamily = WebKit::toImpl(fantasyFontFamilyRef.get())->string().utf8();
WKRetainPtr<WKStringRef> pictographFontFamilyRef = WKPreferencesCopyPictographFontFamily(priv->preferences.get());
priv->pictographFontFamily = WebKit::toImpl(pictographFontFamilyRef.get())->string().utf8();
WKRetainPtr<WKStringRef> defaultCharsetRef = WKPreferencesCopyDefaultTextEncodingName(priv->preferences.get());
priv->defaultCharset = WebKit::toImpl(defaultCharsetRef.get())->string().utf8();
}
void webkitSettingsAttachSettingsToPage(WebKitSettings* settings, WKPageRef wkPage)
{
WKPageGroupSetPreferences(WKPageGetPageGroup(wkPage), settings->priv->preferences.get());
}
WebKitSettings* webkit_settings_new()
{
return WEBKIT_SETTINGS(g_object_new(WEBKIT_TYPE_SETTINGS, NULL));
}
WebKitSettings* webkit_settings_new_with_settings(const gchar* firstSettingName, ...)
{
va_list args;
va_start(args, firstSettingName);
WebKitSettings* settings = WEBKIT_SETTINGS(g_object_new_valist(WEBKIT_TYPE_SETTINGS, firstSettingName, args));
va_end(args);
return settings;
}
gboolean webkit_settings_get_enable_javascript(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetJavaScriptEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_javascript(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetJavaScriptEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetJavaScriptEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-javascript");
}
gboolean webkit_settings_get_auto_load_images(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetLoadsImagesAutomatically(settings->priv->preferences.get());
}
void webkit_settings_set_auto_load_images(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetLoadsImagesAutomatically(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetLoadsImagesAutomatically(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "auto-load-images");
}
gboolean webkit_settings_get_load_icons_ignoring_image_load_setting(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetLoadsSiteIconsIgnoringImageLoadingPreference(settings->priv->preferences.get());
}
void webkit_settings_set_load_icons_ignoring_image_load_setting(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetLoadsSiteIconsIgnoringImageLoadingPreference(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetLoadsSiteIconsIgnoringImageLoadingPreference(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "load-icons-ignoring-image-load-setting");
}
gboolean webkit_settings_get_enable_offline_web_application_cache(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetOfflineWebApplicationCacheEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_offline_web_application_cache(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetOfflineWebApplicationCacheEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetOfflineWebApplicationCacheEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-offline-web-application-cache");
}
gboolean webkit_settings_get_enable_html5_local_storage(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetLocalStorageEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_html5_local_storage(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetLocalStorageEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetLocalStorageEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-html5-local-storage");
}
gboolean webkit_settings_get_enable_html5_database(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetDatabasesEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_html5_database(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetDatabasesEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetDatabasesEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-html5-database");
}
gboolean webkit_settings_get_enable_xss_auditor(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetXSSAuditorEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_xss_auditor(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetXSSAuditorEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetXSSAuditorEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-xss-auditor");
}
gboolean webkit_settings_get_enable_frame_flattening(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetFrameFlatteningEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_frame_flattening(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetFrameFlatteningEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetFrameFlatteningEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-frame-flattening");
}
gboolean webkit_settings_get_enable_plugins(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetPluginsEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_plugins(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetPluginsEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetPluginsEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-plugins");
}
gboolean webkit_settings_get_enable_java(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetJavaEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_java(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetJavaEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetJavaEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-java");
}
gboolean webkit_settings_get_javascript_can_open_windows_automatically(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetJavaScriptCanOpenWindowsAutomatically(settings->priv->preferences.get());
}
void webkit_settings_set_javascript_can_open_windows_automatically(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetJavaScriptCanOpenWindowsAutomatically(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetJavaScriptCanOpenWindowsAutomatically(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "javascript-can-open-windows-automatically");
}
gboolean webkit_settings_get_enable_hyperlink_auditing(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetHyperlinkAuditingEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_hyperlink_auditing(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetHyperlinkAuditingEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetHyperlinkAuditingEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-hyperlink-auditing");
}
const gchar* webkit_settings_get_default_font_family(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->defaultFontFamily.data();
}
void webkit_settings_set_default_font_family(WebKitSettings* settings, const gchar* defaultFontFamily)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(defaultFontFamily);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->defaultFontFamily.data(), defaultFontFamily))
return;
WKRetainPtr<WKStringRef> standardFontFamilyRef = adoptWK(WKStringCreateWithUTF8CString(defaultFontFamily));
WKPreferencesSetStandardFontFamily(priv->preferences.get(), standardFontFamilyRef.get());
priv->defaultFontFamily = WebKit::toImpl(standardFontFamilyRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "default-font-family");
}
const gchar* webkit_settings_get_monospace_font_family(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->monospaceFontFamily.data();
}
void webkit_settings_set_monospace_font_family(WebKitSettings* settings, const gchar* monospaceFontFamily)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(monospaceFontFamily);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->monospaceFontFamily.data(), monospaceFontFamily))
return;
WKRetainPtr<WKStringRef> fixedFontFamilyRef = adoptWK(WKStringCreateWithUTF8CString(monospaceFontFamily));
WKPreferencesSetFixedFontFamily(priv->preferences.get(), fixedFontFamilyRef.get());
priv->monospaceFontFamily = WebKit::toImpl(fixedFontFamilyRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "monospace-font-family");
}
const gchar* webkit_settings_get_serif_font_family(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->serifFontFamily.data();
}
void webkit_settings_set_serif_font_family(WebKitSettings* settings, const gchar* serifFontFamily)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(serifFontFamily);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->serifFontFamily.data(), serifFontFamily))
return;
WKRetainPtr<WKStringRef> serifFontFamilyRef = WKStringCreateWithUTF8CString(serifFontFamily);
WKPreferencesSetSerifFontFamily(priv->preferences.get(), serifFontFamilyRef.get());
priv->serifFontFamily = WebKit::toImpl(serifFontFamilyRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "serif-font-family");
}
const gchar* webkit_settings_get_sans_serif_font_family(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->sansSerifFontFamily.data();
}
void webkit_settings_set_sans_serif_font_family(WebKitSettings* settings, const gchar* sansSerifFontFamily)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(sansSerifFontFamily);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->sansSerifFontFamily.data(), sansSerifFontFamily))
return;
WKRetainPtr<WKStringRef> sansSerifFontFamilyRef = adoptWK(WKStringCreateWithUTF8CString(sansSerifFontFamily));
WKPreferencesSetSansSerifFontFamily(priv->preferences.get(), sansSerifFontFamilyRef.get());
priv->sansSerifFontFamily = WebKit::toImpl(sansSerifFontFamilyRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "sans-serif-font-family");
}
const gchar* webkit_settings_get_cursive_font_family(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->cursiveFontFamily.data();
}
void webkit_settings_set_cursive_font_family(WebKitSettings* settings, const gchar* cursiveFontFamily)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(cursiveFontFamily);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->cursiveFontFamily.data(), cursiveFontFamily))
return;
WKRetainPtr<WKStringRef> cursiveFontFamilyRef = adoptWK(WKStringCreateWithUTF8CString(cursiveFontFamily));
WKPreferencesSetCursiveFontFamily(priv->preferences.get(), cursiveFontFamilyRef.get());
priv->cursiveFontFamily = WebKit::toImpl(cursiveFontFamilyRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "cursive-font-family");
}
const gchar* webkit_settings_get_fantasy_font_family(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->fantasyFontFamily.data();
}
void webkit_settings_set_fantasy_font_family(WebKitSettings* settings, const gchar* fantasyFontFamily)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(fantasyFontFamily);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->fantasyFontFamily.data(), fantasyFontFamily))
return;
WKRetainPtr<WKStringRef> fantasyFontFamilyRef = adoptWK(WKStringCreateWithUTF8CString(fantasyFontFamily));
WKPreferencesSetFantasyFontFamily(priv->preferences.get(), fantasyFontFamilyRef.get());
priv->fantasyFontFamily = WebKit::toImpl(fantasyFontFamilyRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "fantasy-font-family");
}
const gchar* webkit_settings_get_pictograph_font_family(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->pictographFontFamily.data();
}
void webkit_settings_set_pictograph_font_family(WebKitSettings* settings, const gchar* pictographFontFamily)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(pictographFontFamily);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->pictographFontFamily.data(), pictographFontFamily))
return;
WKRetainPtr<WKStringRef> pictographFontFamilyRef = adoptWK(WKStringCreateWithUTF8CString(pictographFontFamily));
WKPreferencesSetPictographFontFamily(priv->preferences.get(), pictographFontFamilyRef.get());
priv->pictographFontFamily = WebKit::toImpl(pictographFontFamilyRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "pictograph-font-family");
}
guint32 webkit_settings_get_default_font_size(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return WKPreferencesGetDefaultFontSize(settings->priv->preferences.get());
}
void webkit_settings_set_default_font_size(WebKitSettings* settings, guint32 fontSize)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
uint32_t currentSize = WKPreferencesGetDefaultFontSize(priv->preferences.get());
if (currentSize == fontSize)
return;
WKPreferencesSetDefaultFontSize(priv->preferences.get(), fontSize);
g_object_notify(G_OBJECT(settings), "default-font-size");
}
guint32 webkit_settings_get_default_monospace_font_size(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return WKPreferencesGetDefaultFixedFontSize(settings->priv->preferences.get());
}
void webkit_settings_set_default_monospace_font_size(WebKitSettings* settings, guint32 fontSize)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
uint32_t currentSize = WKPreferencesGetDefaultFixedFontSize(priv->preferences.get());
if (currentSize == fontSize)
return;
WKPreferencesSetDefaultFixedFontSize(priv->preferences.get(), fontSize);
g_object_notify(G_OBJECT(settings), "default-monospace-font-size");
}
guint32 webkit_settings_get_minimum_font_size(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return WKPreferencesGetMinimumFontSize(settings->priv->preferences.get());
}
void webkit_settings_set_minimum_font_size(WebKitSettings* settings, guint32 fontSize)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
uint32_t currentSize = WKPreferencesGetMinimumFontSize(priv->preferences.get());
if (currentSize == fontSize)
return;
WKPreferencesSetMinimumFontSize(priv->preferences.get(), fontSize);
g_object_notify(G_OBJECT(settings), "minimum-font-size");
}
const gchar* webkit_settings_get_default_charset(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), 0);
return settings->priv->defaultCharset.data();
}
void webkit_settings_set_default_charset(WebKitSettings* settings, const gchar* defaultCharset)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
g_return_if_fail(defaultCharset);
WebKitSettingsPrivate* priv = settings->priv;
if (!g_strcmp0(priv->defaultCharset.data(), defaultCharset))
return;
WKRetainPtr<WKStringRef> defaultCharsetRef = adoptWK(WKStringCreateWithUTF8CString(defaultCharset));
WKPreferencesSetDefaultTextEncodingName(priv->preferences.get(), defaultCharsetRef.get());
priv->defaultCharset = WebKit::toImpl(defaultCharsetRef.get())->string().utf8();
g_object_notify(G_OBJECT(settings), "default-charset");
}
gboolean webkit_settings_get_enable_private_browsing(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetPrivateBrowsingEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_private_browsing(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetPrivateBrowsingEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetPrivateBrowsingEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-private-browsing");
}
gboolean webkit_settings_get_enable_developer_extras(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetDeveloperExtrasEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_developer_extras(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetDeveloperExtrasEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetDeveloperExtrasEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-developer-extras");
}
gboolean webkit_settings_get_enable_resizable_text_areas(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetTextAreasAreResizable(settings->priv->preferences.get());
}
void webkit_settings_set_enable_resizable_text_areas(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetTextAreasAreResizable(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetTextAreasAreResizable(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-resizable-text-areas");
}
gboolean webkit_settings_get_enable_tabs_to_links(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetTabsToLinks(settings->priv->preferences.get());
}
void webkit_settings_set_enable_tabs_to_links(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetTabsToLinks(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetTabsToLinks(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-tabs-to-links");
}
gboolean webkit_settings_get_enable_dns_prefetching(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetDNSPrefetchingEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_dns_prefetching(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetDNSPrefetchingEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetDNSPrefetchingEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-dns-prefetching");
}
gboolean webkit_settings_get_enable_caret_browsing(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetCaretBrowsingEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_caret_browsing(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetCaretBrowsingEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetCaretBrowsingEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-caret-browsing");
}
gboolean webkit_settings_get_enable_fullscreen(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetFullScreenEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_fullscreen(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetFullScreenEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetFullScreenEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-fullscreen");
}
gboolean webkit_settings_get_print_backgrounds(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetShouldPrintBackgrounds(settings->priv->preferences.get());
}
void webkit_settings_set_print_backgrounds(WebKitSettings* settings, gboolean printBackgrounds)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetShouldPrintBackgrounds(priv->preferences.get());
if (currentValue == printBackgrounds)
return;
WKPreferencesSetShouldPrintBackgrounds(priv->preferences.get(), printBackgrounds);
g_object_notify(G_OBJECT(settings), "print-backgrounds");
}
gboolean webkit_settings_get_enable_webaudio(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetWebAudioEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_webaudio(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetWebAudioEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetWebAudioEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-webaudio");
}
gboolean webkit_settings_get_enable_webgl(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetWebGLEnabled(settings->priv->preferences.get());
}
void webkit_settings_set_enable_webgl(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetWebGLEnabled(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetWebGLEnabled(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "enable-webgl");
}
void webkit_settings_set_zoom_text_only(WebKitSettings* settings, gboolean zoomTextOnly)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
if (priv->zoomTextOnly == zoomTextOnly)
return;
priv->zoomTextOnly = zoomTextOnly;
g_object_notify(G_OBJECT(settings), "zoom-text-only");
}
gboolean webkit_settings_get_zoom_text_only(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return settings->priv->zoomTextOnly;
}
gboolean webkit_settings_get_javascript_can_access_clipboard(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
return WKPreferencesGetJavaScriptCanAccessClipboard(settings->priv->preferences.get())
&& WKPreferencesGetDOMPasteAllowed(settings->priv->preferences.get());
}
void webkit_settings_set_javascript_can_access_clipboard(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
WebKitSettingsPrivate* priv = settings->priv;
bool currentValue = WKPreferencesGetJavaScriptCanAccessClipboard(priv->preferences.get())
&& WKPreferencesGetDOMPasteAllowed(priv->preferences.get());
if (currentValue == enabled)
return;
WKPreferencesSetJavaScriptCanAccessClipboard(priv->preferences.get(), enabled);
WKPreferencesSetDOMPasteAllowed(priv->preferences.get(), enabled);
g_object_notify(G_OBJECT(settings), "javascript-can-access-clipboard");
}