// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

namespace WebKit {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;
	using static GLib.AbiStructExtension;

#region Autogenerated code
	public partial class Settings : GLib.Object {

		public Settings (IntPtr raw) : base(raw) {}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_new();
		static d_webkit_settings_new webkit_settings_new = FuncLoader.LoadFunction<d_webkit_settings_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_new"));

		public Settings () : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Settings)) {
				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
				return;
			}
			Raw = webkit_settings_new();
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_allow_file_access_from_file_urls(IntPtr raw);
		static d_webkit_settings_get_allow_file_access_from_file_urls webkit_settings_get_allow_file_access_from_file_urls = FuncLoader.LoadFunction<d_webkit_settings_get_allow_file_access_from_file_urls>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_allow_file_access_from_file_urls"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_allow_file_access_from_file_urls(IntPtr raw, bool allowed);
		static d_webkit_settings_set_allow_file_access_from_file_urls webkit_settings_set_allow_file_access_from_file_urls = FuncLoader.LoadFunction<d_webkit_settings_set_allow_file_access_from_file_urls>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_allow_file_access_from_file_urls"));

		[GLib.Property ("allow-file-access-from-file-urls")]
		public bool AllowFileAccessFromFileUrls {
			get  {
				bool raw_ret = webkit_settings_get_allow_file_access_from_file_urls(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_allow_file_access_from_file_urls(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_allow_modal_dialogs(IntPtr raw);
		static d_webkit_settings_get_allow_modal_dialogs webkit_settings_get_allow_modal_dialogs = FuncLoader.LoadFunction<d_webkit_settings_get_allow_modal_dialogs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_allow_modal_dialogs"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_allow_modal_dialogs(IntPtr raw, bool allowed);
		static d_webkit_settings_set_allow_modal_dialogs webkit_settings_set_allow_modal_dialogs = FuncLoader.LoadFunction<d_webkit_settings_set_allow_modal_dialogs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_allow_modal_dialogs"));

		[GLib.Property ("allow-modal-dialogs")]
		public bool AllowModalDialogs {
			get  {
				bool raw_ret = webkit_settings_get_allow_modal_dialogs(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_allow_modal_dialogs(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_allow_top_navigation_to_data_urls(IntPtr raw);
		static d_webkit_settings_get_allow_top_navigation_to_data_urls webkit_settings_get_allow_top_navigation_to_data_urls = FuncLoader.LoadFunction<d_webkit_settings_get_allow_top_navigation_to_data_urls>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_allow_top_navigation_to_data_urls"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_allow_top_navigation_to_data_urls(IntPtr raw, bool allowed);
		static d_webkit_settings_set_allow_top_navigation_to_data_urls webkit_settings_set_allow_top_navigation_to_data_urls = FuncLoader.LoadFunction<d_webkit_settings_set_allow_top_navigation_to_data_urls>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_allow_top_navigation_to_data_urls"));

		[GLib.Property ("allow-top-navigation-to-data-urls")]
		public bool AllowTopNavigationToDataUrls {
			get  {
				bool raw_ret = webkit_settings_get_allow_top_navigation_to_data_urls(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_allow_top_navigation_to_data_urls(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_allow_universal_access_from_file_urls(IntPtr raw);
		static d_webkit_settings_get_allow_universal_access_from_file_urls webkit_settings_get_allow_universal_access_from_file_urls = FuncLoader.LoadFunction<d_webkit_settings_get_allow_universal_access_from_file_urls>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_allow_universal_access_from_file_urls"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_allow_universal_access_from_file_urls(IntPtr raw, bool allowed);
		static d_webkit_settings_set_allow_universal_access_from_file_urls webkit_settings_set_allow_universal_access_from_file_urls = FuncLoader.LoadFunction<d_webkit_settings_set_allow_universal_access_from_file_urls>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_allow_universal_access_from_file_urls"));

		[GLib.Property ("allow-universal-access-from-file-urls")]
		public bool AllowUniversalAccessFromFileUrls {
			get  {
				bool raw_ret = webkit_settings_get_allow_universal_access_from_file_urls(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_allow_universal_access_from_file_urls(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_auto_load_images(IntPtr raw);
		static d_webkit_settings_get_auto_load_images webkit_settings_get_auto_load_images = FuncLoader.LoadFunction<d_webkit_settings_get_auto_load_images>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_auto_load_images"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_auto_load_images(IntPtr raw, bool enabled);
		static d_webkit_settings_set_auto_load_images webkit_settings_set_auto_load_images = FuncLoader.LoadFunction<d_webkit_settings_set_auto_load_images>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_auto_load_images"));

		[GLib.Property ("auto-load-images")]
		public bool AutoLoadImages {
			get  {
				bool raw_ret = webkit_settings_get_auto_load_images(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_auto_load_images(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_cursive_font_family(IntPtr raw);
		static d_webkit_settings_get_cursive_font_family webkit_settings_get_cursive_font_family = FuncLoader.LoadFunction<d_webkit_settings_get_cursive_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_cursive_font_family"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_cursive_font_family(IntPtr raw, IntPtr cursive_font_family);
		static d_webkit_settings_set_cursive_font_family webkit_settings_set_cursive_font_family = FuncLoader.LoadFunction<d_webkit_settings_set_cursive_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_cursive_font_family"));

		[GLib.Property ("cursive-font-family")]
		public string CursiveFontFamily {
			get  {
				IntPtr raw_ret = webkit_settings_get_cursive_font_family(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_cursive_font_family(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_default_charset(IntPtr raw);
		static d_webkit_settings_get_default_charset webkit_settings_get_default_charset = FuncLoader.LoadFunction<d_webkit_settings_get_default_charset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_default_charset"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_default_charset(IntPtr raw, IntPtr default_charset);
		static d_webkit_settings_set_default_charset webkit_settings_set_default_charset = FuncLoader.LoadFunction<d_webkit_settings_set_default_charset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_default_charset"));

		[GLib.Property ("default-charset")]
		public string DefaultCharset {
			get  {
				IntPtr raw_ret = webkit_settings_get_default_charset(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_default_charset(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_default_font_family(IntPtr raw);
		static d_webkit_settings_get_default_font_family webkit_settings_get_default_font_family = FuncLoader.LoadFunction<d_webkit_settings_get_default_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_default_font_family"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_default_font_family(IntPtr raw, IntPtr default_font_family);
		static d_webkit_settings_set_default_font_family webkit_settings_set_default_font_family = FuncLoader.LoadFunction<d_webkit_settings_set_default_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_default_font_family"));

		[GLib.Property ("default-font-family")]
		public string DefaultFontFamily {
			get  {
				IntPtr raw_ret = webkit_settings_get_default_font_family(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_default_font_family(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_webkit_settings_get_default_font_size(IntPtr raw);
		static d_webkit_settings_get_default_font_size webkit_settings_get_default_font_size = FuncLoader.LoadFunction<d_webkit_settings_get_default_font_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_default_font_size"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_default_font_size(IntPtr raw, uint font_size);
		static d_webkit_settings_set_default_font_size webkit_settings_set_default_font_size = FuncLoader.LoadFunction<d_webkit_settings_set_default_font_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_default_font_size"));

		[GLib.Property ("default-font-size")]
		public uint DefaultFontSize {
			get  {
				uint raw_ret = webkit_settings_get_default_font_size(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_default_font_size(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_webkit_settings_get_default_monospace_font_size(IntPtr raw);
		static d_webkit_settings_get_default_monospace_font_size webkit_settings_get_default_monospace_font_size = FuncLoader.LoadFunction<d_webkit_settings_get_default_monospace_font_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_default_monospace_font_size"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_default_monospace_font_size(IntPtr raw, uint font_size);
		static d_webkit_settings_set_default_monospace_font_size webkit_settings_set_default_monospace_font_size = FuncLoader.LoadFunction<d_webkit_settings_set_default_monospace_font_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_default_monospace_font_size"));

		[GLib.Property ("default-monospace-font-size")]
		public uint DefaultMonospaceFontSize {
			get  {
				uint raw_ret = webkit_settings_get_default_monospace_font_size(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_default_monospace_font_size(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_draw_compositing_indicators(IntPtr raw);
		static d_webkit_settings_get_draw_compositing_indicators webkit_settings_get_draw_compositing_indicators = FuncLoader.LoadFunction<d_webkit_settings_get_draw_compositing_indicators>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_draw_compositing_indicators"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_draw_compositing_indicators(IntPtr raw, bool enabled);
		static d_webkit_settings_set_draw_compositing_indicators webkit_settings_set_draw_compositing_indicators = FuncLoader.LoadFunction<d_webkit_settings_set_draw_compositing_indicators>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_draw_compositing_indicators"));

		[GLib.Property ("draw-compositing-indicators")]
		public bool DrawCompositingIndicators {
			get  {
				bool raw_ret = webkit_settings_get_draw_compositing_indicators(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_draw_compositing_indicators(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_accelerated_2d_canvas(IntPtr raw);
		static d_webkit_settings_get_enable_accelerated_2d_canvas webkit_settings_get_enable_accelerated_2d_canvas = FuncLoader.LoadFunction<d_webkit_settings_get_enable_accelerated_2d_canvas>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_accelerated_2d_canvas"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_accelerated_2d_canvas(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_accelerated_2d_canvas webkit_settings_set_enable_accelerated_2d_canvas = FuncLoader.LoadFunction<d_webkit_settings_set_enable_accelerated_2d_canvas>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_accelerated_2d_canvas"));

		[Obsolete]
		[GLib.Property ("enable-accelerated-2d-canvas")]
		public bool EnableAccelerated2dCanvas {
			get  {
				bool raw_ret = webkit_settings_get_enable_accelerated_2d_canvas(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_accelerated_2d_canvas(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_back_forward_navigation_gestures(IntPtr raw);
		static d_webkit_settings_get_enable_back_forward_navigation_gestures webkit_settings_get_enable_back_forward_navigation_gestures = FuncLoader.LoadFunction<d_webkit_settings_get_enable_back_forward_navigation_gestures>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_back_forward_navigation_gestures"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_back_forward_navigation_gestures(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_back_forward_navigation_gestures webkit_settings_set_enable_back_forward_navigation_gestures = FuncLoader.LoadFunction<d_webkit_settings_set_enable_back_forward_navigation_gestures>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_back_forward_navigation_gestures"));

		[GLib.Property ("enable-back-forward-navigation-gestures")]
		public bool EnableBackForwardNavigationGestures {
			get  {
				bool raw_ret = webkit_settings_get_enable_back_forward_navigation_gestures(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_back_forward_navigation_gestures(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_caret_browsing(IntPtr raw);
		static d_webkit_settings_get_enable_caret_browsing webkit_settings_get_enable_caret_browsing = FuncLoader.LoadFunction<d_webkit_settings_get_enable_caret_browsing>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_caret_browsing"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_caret_browsing(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_caret_browsing webkit_settings_set_enable_caret_browsing = FuncLoader.LoadFunction<d_webkit_settings_set_enable_caret_browsing>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_caret_browsing"));

		[GLib.Property ("enable-caret-browsing")]
		public bool EnableCaretBrowsing {
			get  {
				bool raw_ret = webkit_settings_get_enable_caret_browsing(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_caret_browsing(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_developer_extras(IntPtr raw);
		static d_webkit_settings_get_enable_developer_extras webkit_settings_get_enable_developer_extras = FuncLoader.LoadFunction<d_webkit_settings_get_enable_developer_extras>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_developer_extras"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_developer_extras(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_developer_extras webkit_settings_set_enable_developer_extras = FuncLoader.LoadFunction<d_webkit_settings_set_enable_developer_extras>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_developer_extras"));

		[GLib.Property ("enable-developer-extras")]
		public bool EnableDeveloperExtras {
			get  {
				bool raw_ret = webkit_settings_get_enable_developer_extras(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_developer_extras(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_dns_prefetching(IntPtr raw);
		static d_webkit_settings_get_enable_dns_prefetching webkit_settings_get_enable_dns_prefetching = FuncLoader.LoadFunction<d_webkit_settings_get_enable_dns_prefetching>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_dns_prefetching"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_dns_prefetching(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_dns_prefetching webkit_settings_set_enable_dns_prefetching = FuncLoader.LoadFunction<d_webkit_settings_set_enable_dns_prefetching>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_dns_prefetching"));

		[GLib.Property ("enable-dns-prefetching")]
		public bool EnableDnsPrefetching {
			get  {
				bool raw_ret = webkit_settings_get_enable_dns_prefetching(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_dns_prefetching(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_encrypted_media(IntPtr raw);
		static d_webkit_settings_get_enable_encrypted_media webkit_settings_get_enable_encrypted_media = FuncLoader.LoadFunction<d_webkit_settings_get_enable_encrypted_media>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_encrypted_media"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_encrypted_media(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_encrypted_media webkit_settings_set_enable_encrypted_media = FuncLoader.LoadFunction<d_webkit_settings_set_enable_encrypted_media>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_encrypted_media"));

		[GLib.Property ("enable-encrypted-media")]
		public bool EnableEncryptedMedia {
			get  {
				bool raw_ret = webkit_settings_get_enable_encrypted_media(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_encrypted_media(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_frame_flattening(IntPtr raw);
		static d_webkit_settings_get_enable_frame_flattening webkit_settings_get_enable_frame_flattening = FuncLoader.LoadFunction<d_webkit_settings_get_enable_frame_flattening>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_frame_flattening"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_frame_flattening(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_frame_flattening webkit_settings_set_enable_frame_flattening = FuncLoader.LoadFunction<d_webkit_settings_set_enable_frame_flattening>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_frame_flattening"));

		[GLib.Property ("enable-frame-flattening")]
		public bool EnableFrameFlattening {
			get  {
				bool raw_ret = webkit_settings_get_enable_frame_flattening(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_frame_flattening(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_fullscreen(IntPtr raw);
		static d_webkit_settings_get_enable_fullscreen webkit_settings_get_enable_fullscreen = FuncLoader.LoadFunction<d_webkit_settings_get_enable_fullscreen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_fullscreen"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_fullscreen(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_fullscreen webkit_settings_set_enable_fullscreen = FuncLoader.LoadFunction<d_webkit_settings_set_enable_fullscreen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_fullscreen"));

		[GLib.Property ("enable-fullscreen")]
		public bool EnableFullscreen {
			get  {
				bool raw_ret = webkit_settings_get_enable_fullscreen(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_fullscreen(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_html5_database(IntPtr raw);
		static d_webkit_settings_get_enable_html5_database webkit_settings_get_enable_html5_database = FuncLoader.LoadFunction<d_webkit_settings_get_enable_html5_database>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_html5_database"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_html5_database(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_html5_database webkit_settings_set_enable_html5_database = FuncLoader.LoadFunction<d_webkit_settings_set_enable_html5_database>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_html5_database"));

		[GLib.Property ("enable-html5-database")]
		public bool EnableHtml5Database {
			get  {
				bool raw_ret = webkit_settings_get_enable_html5_database(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_html5_database(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_html5_local_storage(IntPtr raw);
		static d_webkit_settings_get_enable_html5_local_storage webkit_settings_get_enable_html5_local_storage = FuncLoader.LoadFunction<d_webkit_settings_get_enable_html5_local_storage>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_html5_local_storage"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_html5_local_storage(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_html5_local_storage webkit_settings_set_enable_html5_local_storage = FuncLoader.LoadFunction<d_webkit_settings_set_enable_html5_local_storage>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_html5_local_storage"));

		[GLib.Property ("enable-html5-local-storage")]
		public bool EnableHtml5LocalStorage {
			get  {
				bool raw_ret = webkit_settings_get_enable_html5_local_storage(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_html5_local_storage(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_hyperlink_auditing(IntPtr raw);
		static d_webkit_settings_get_enable_hyperlink_auditing webkit_settings_get_enable_hyperlink_auditing = FuncLoader.LoadFunction<d_webkit_settings_get_enable_hyperlink_auditing>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_hyperlink_auditing"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_hyperlink_auditing(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_hyperlink_auditing webkit_settings_set_enable_hyperlink_auditing = FuncLoader.LoadFunction<d_webkit_settings_set_enable_hyperlink_auditing>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_hyperlink_auditing"));

		[GLib.Property ("enable-hyperlink-auditing")]
		public bool EnableHyperlinkAuditing {
			get  {
				bool raw_ret = webkit_settings_get_enable_hyperlink_auditing(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_hyperlink_auditing(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_java(IntPtr raw);
		static d_webkit_settings_get_enable_java webkit_settings_get_enable_java = FuncLoader.LoadFunction<d_webkit_settings_get_enable_java>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_java"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_java(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_java webkit_settings_set_enable_java = FuncLoader.LoadFunction<d_webkit_settings_set_enable_java>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_java"));

		[GLib.Property ("enable-java")]
		public bool EnableJava {
			get  {
				bool raw_ret = webkit_settings_get_enable_java(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_java(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_javascript(IntPtr raw);
		static d_webkit_settings_get_enable_javascript webkit_settings_get_enable_javascript = FuncLoader.LoadFunction<d_webkit_settings_get_enable_javascript>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_javascript"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_javascript(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_javascript webkit_settings_set_enable_javascript = FuncLoader.LoadFunction<d_webkit_settings_set_enable_javascript>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_javascript"));

		[GLib.Property ("enable-javascript")]
		public bool EnableJavascript {
			get  {
				bool raw_ret = webkit_settings_get_enable_javascript(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_javascript(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_javascript_markup(IntPtr raw);
		static d_webkit_settings_get_enable_javascript_markup webkit_settings_get_enable_javascript_markup = FuncLoader.LoadFunction<d_webkit_settings_get_enable_javascript_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_javascript_markup"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_javascript_markup(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_javascript_markup webkit_settings_set_enable_javascript_markup = FuncLoader.LoadFunction<d_webkit_settings_set_enable_javascript_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_javascript_markup"));

		[GLib.Property ("enable-javascript-markup")]
		public bool EnableJavascriptMarkup {
			get  {
				bool raw_ret = webkit_settings_get_enable_javascript_markup(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_javascript_markup(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_media(IntPtr raw);
		static d_webkit_settings_get_enable_media webkit_settings_get_enable_media = FuncLoader.LoadFunction<d_webkit_settings_get_enable_media>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_media"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_media(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_media webkit_settings_set_enable_media = FuncLoader.LoadFunction<d_webkit_settings_set_enable_media>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_media"));

		[GLib.Property ("enable-media")]
		public bool EnableMedia {
			get  {
				bool raw_ret = webkit_settings_get_enable_media(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_media(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_media_capabilities(IntPtr raw);
		static d_webkit_settings_get_enable_media_capabilities webkit_settings_get_enable_media_capabilities = FuncLoader.LoadFunction<d_webkit_settings_get_enable_media_capabilities>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_media_capabilities"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_media_capabilities(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_media_capabilities webkit_settings_set_enable_media_capabilities = FuncLoader.LoadFunction<d_webkit_settings_set_enable_media_capabilities>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_media_capabilities"));

		[GLib.Property ("enable-media-capabilities")]
		public bool EnableMediaCapabilities {
			get  {
				bool raw_ret = webkit_settings_get_enable_media_capabilities(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_media_capabilities(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_media_stream(IntPtr raw);
		static d_webkit_settings_get_enable_media_stream webkit_settings_get_enable_media_stream = FuncLoader.LoadFunction<d_webkit_settings_get_enable_media_stream>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_media_stream"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_media_stream(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_media_stream webkit_settings_set_enable_media_stream = FuncLoader.LoadFunction<d_webkit_settings_set_enable_media_stream>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_media_stream"));

		[GLib.Property ("enable-media-stream")]
		public bool EnableMediaStream {
			get  {
				bool raw_ret = webkit_settings_get_enable_media_stream(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_media_stream(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_mediasource(IntPtr raw);
		static d_webkit_settings_get_enable_mediasource webkit_settings_get_enable_mediasource = FuncLoader.LoadFunction<d_webkit_settings_get_enable_mediasource>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_mediasource"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_mediasource(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_mediasource webkit_settings_set_enable_mediasource = FuncLoader.LoadFunction<d_webkit_settings_set_enable_mediasource>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_mediasource"));

		[GLib.Property ("enable-mediasource")]
		public bool EnableMediasource {
			get  {
				bool raw_ret = webkit_settings_get_enable_mediasource(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_mediasource(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_mock_capture_devices(IntPtr raw);
		static d_webkit_settings_get_enable_mock_capture_devices webkit_settings_get_enable_mock_capture_devices = FuncLoader.LoadFunction<d_webkit_settings_get_enable_mock_capture_devices>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_mock_capture_devices"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_mock_capture_devices(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_mock_capture_devices webkit_settings_set_enable_mock_capture_devices = FuncLoader.LoadFunction<d_webkit_settings_set_enable_mock_capture_devices>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_mock_capture_devices"));

		[GLib.Property ("enable-mock-capture-devices")]
		public bool EnableMockCaptureDevices {
			get  {
				bool raw_ret = webkit_settings_get_enable_mock_capture_devices(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_mock_capture_devices(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_offline_web_application_cache(IntPtr raw);
		static d_webkit_settings_get_enable_offline_web_application_cache webkit_settings_get_enable_offline_web_application_cache = FuncLoader.LoadFunction<d_webkit_settings_get_enable_offline_web_application_cache>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_offline_web_application_cache"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_offline_web_application_cache(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_offline_web_application_cache webkit_settings_set_enable_offline_web_application_cache = FuncLoader.LoadFunction<d_webkit_settings_set_enable_offline_web_application_cache>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_offline_web_application_cache"));

		[GLib.Property ("enable-offline-web-application-cache")]
		public bool EnableOfflineWebApplicationCache {
			get  {
				bool raw_ret = webkit_settings_get_enable_offline_web_application_cache(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_offline_web_application_cache(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_page_cache(IntPtr raw);
		static d_webkit_settings_get_enable_page_cache webkit_settings_get_enable_page_cache = FuncLoader.LoadFunction<d_webkit_settings_get_enable_page_cache>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_page_cache"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_page_cache(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_page_cache webkit_settings_set_enable_page_cache = FuncLoader.LoadFunction<d_webkit_settings_set_enable_page_cache>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_page_cache"));

		[GLib.Property ("enable-page-cache")]
		public bool EnablePageCache {
			get  {
				bool raw_ret = webkit_settings_get_enable_page_cache(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_page_cache(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_plugins(IntPtr raw);
		static d_webkit_settings_get_enable_plugins webkit_settings_get_enable_plugins = FuncLoader.LoadFunction<d_webkit_settings_get_enable_plugins>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_plugins"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_plugins(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_plugins webkit_settings_set_enable_plugins = FuncLoader.LoadFunction<d_webkit_settings_set_enable_plugins>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_plugins"));

		[Obsolete]
		[GLib.Property ("enable-plugins")]
		public bool EnablePlugins {
			get  {
				bool raw_ret = webkit_settings_get_enable_plugins(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_plugins(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_private_browsing(IntPtr raw);
		static d_webkit_settings_get_enable_private_browsing webkit_settings_get_enable_private_browsing = FuncLoader.LoadFunction<d_webkit_settings_get_enable_private_browsing>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_private_browsing"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_private_browsing(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_private_browsing webkit_settings_set_enable_private_browsing = FuncLoader.LoadFunction<d_webkit_settings_set_enable_private_browsing>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_private_browsing"));

		[Obsolete]
		[GLib.Property ("enable-private-browsing")]
		public bool EnablePrivateBrowsing {
			get  {
				bool raw_ret = webkit_settings_get_enable_private_browsing(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_private_browsing(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_resizable_text_areas(IntPtr raw);
		static d_webkit_settings_get_enable_resizable_text_areas webkit_settings_get_enable_resizable_text_areas = FuncLoader.LoadFunction<d_webkit_settings_get_enable_resizable_text_areas>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_resizable_text_areas"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_resizable_text_areas(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_resizable_text_areas webkit_settings_set_enable_resizable_text_areas = FuncLoader.LoadFunction<d_webkit_settings_set_enable_resizable_text_areas>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_resizable_text_areas"));

		[GLib.Property ("enable-resizable-text-areas")]
		public bool EnableResizableTextAreas {
			get  {
				bool raw_ret = webkit_settings_get_enable_resizable_text_areas(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_resizable_text_areas(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_site_specific_quirks(IntPtr raw);
		static d_webkit_settings_get_enable_site_specific_quirks webkit_settings_get_enable_site_specific_quirks = FuncLoader.LoadFunction<d_webkit_settings_get_enable_site_specific_quirks>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_site_specific_quirks"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_site_specific_quirks(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_site_specific_quirks webkit_settings_set_enable_site_specific_quirks = FuncLoader.LoadFunction<d_webkit_settings_set_enable_site_specific_quirks>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_site_specific_quirks"));

		[GLib.Property ("enable-site-specific-quirks")]
		public bool EnableSiteSpecificQuirks {
			get  {
				bool raw_ret = webkit_settings_get_enable_site_specific_quirks(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_site_specific_quirks(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_smooth_scrolling(IntPtr raw);
		static d_webkit_settings_get_enable_smooth_scrolling webkit_settings_get_enable_smooth_scrolling = FuncLoader.LoadFunction<d_webkit_settings_get_enable_smooth_scrolling>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_smooth_scrolling"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_smooth_scrolling(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_smooth_scrolling webkit_settings_set_enable_smooth_scrolling = FuncLoader.LoadFunction<d_webkit_settings_set_enable_smooth_scrolling>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_smooth_scrolling"));

		[GLib.Property ("enable-smooth-scrolling")]
		public bool EnableSmoothScrolling {
			get  {
				bool raw_ret = webkit_settings_get_enable_smooth_scrolling(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_smooth_scrolling(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_spatial_navigation(IntPtr raw);
		static d_webkit_settings_get_enable_spatial_navigation webkit_settings_get_enable_spatial_navigation = FuncLoader.LoadFunction<d_webkit_settings_get_enable_spatial_navigation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_spatial_navigation"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_spatial_navigation(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_spatial_navigation webkit_settings_set_enable_spatial_navigation = FuncLoader.LoadFunction<d_webkit_settings_set_enable_spatial_navigation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_spatial_navigation"));

		[GLib.Property ("enable-spatial-navigation")]
		public bool EnableSpatialNavigation {
			get  {
				bool raw_ret = webkit_settings_get_enable_spatial_navigation(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_spatial_navigation(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_tabs_to_links(IntPtr raw);
		static d_webkit_settings_get_enable_tabs_to_links webkit_settings_get_enable_tabs_to_links = FuncLoader.LoadFunction<d_webkit_settings_get_enable_tabs_to_links>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_tabs_to_links"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_tabs_to_links(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_tabs_to_links webkit_settings_set_enable_tabs_to_links = FuncLoader.LoadFunction<d_webkit_settings_set_enable_tabs_to_links>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_tabs_to_links"));

		[GLib.Property ("enable-tabs-to-links")]
		public bool EnableTabsToLinks {
			get  {
				bool raw_ret = webkit_settings_get_enable_tabs_to_links(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_tabs_to_links(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_webaudio(IntPtr raw);
		static d_webkit_settings_get_enable_webaudio webkit_settings_get_enable_webaudio = FuncLoader.LoadFunction<d_webkit_settings_get_enable_webaudio>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_webaudio"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_webaudio(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_webaudio webkit_settings_set_enable_webaudio = FuncLoader.LoadFunction<d_webkit_settings_set_enable_webaudio>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_webaudio"));

		[GLib.Property ("enable-webaudio")]
		public bool EnableWebaudio {
			get  {
				bool raw_ret = webkit_settings_get_enable_webaudio(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_webaudio(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_webgl(IntPtr raw);
		static d_webkit_settings_get_enable_webgl webkit_settings_get_enable_webgl = FuncLoader.LoadFunction<d_webkit_settings_get_enable_webgl>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_webgl"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_webgl(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_webgl webkit_settings_set_enable_webgl = FuncLoader.LoadFunction<d_webkit_settings_set_enable_webgl>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_webgl"));

		[GLib.Property ("enable-webgl")]
		public bool EnableWebgl {
			get  {
				bool raw_ret = webkit_settings_get_enable_webgl(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_webgl(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_write_console_messages_to_stdout(IntPtr raw);
		static d_webkit_settings_get_enable_write_console_messages_to_stdout webkit_settings_get_enable_write_console_messages_to_stdout = FuncLoader.LoadFunction<d_webkit_settings_get_enable_write_console_messages_to_stdout>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_write_console_messages_to_stdout"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_write_console_messages_to_stdout(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_write_console_messages_to_stdout webkit_settings_set_enable_write_console_messages_to_stdout = FuncLoader.LoadFunction<d_webkit_settings_set_enable_write_console_messages_to_stdout>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_write_console_messages_to_stdout"));

		[GLib.Property ("enable-write-console-messages-to-stdout")]
		public bool EnableWriteConsoleMessagesToStdout {
			get  {
				bool raw_ret = webkit_settings_get_enable_write_console_messages_to_stdout(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_write_console_messages_to_stdout(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_enable_xss_auditor(IntPtr raw);
		static d_webkit_settings_get_enable_xss_auditor webkit_settings_get_enable_xss_auditor = FuncLoader.LoadFunction<d_webkit_settings_get_enable_xss_auditor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_enable_xss_auditor"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_enable_xss_auditor(IntPtr raw, bool enabled);
		static d_webkit_settings_set_enable_xss_auditor webkit_settings_set_enable_xss_auditor = FuncLoader.LoadFunction<d_webkit_settings_set_enable_xss_auditor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_enable_xss_auditor"));

		[GLib.Property ("enable-xss-auditor")]
		public bool EnableXssAuditor {
			get  {
				bool raw_ret = webkit_settings_get_enable_xss_auditor(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_enable_xss_auditor(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_fantasy_font_family(IntPtr raw);
		static d_webkit_settings_get_fantasy_font_family webkit_settings_get_fantasy_font_family = FuncLoader.LoadFunction<d_webkit_settings_get_fantasy_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_fantasy_font_family"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_fantasy_font_family(IntPtr raw, IntPtr fantasy_font_family);
		static d_webkit_settings_set_fantasy_font_family webkit_settings_set_fantasy_font_family = FuncLoader.LoadFunction<d_webkit_settings_set_fantasy_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_fantasy_font_family"));

		[GLib.Property ("fantasy-font-family")]
		public string FantasyFontFamily {
			get  {
				IntPtr raw_ret = webkit_settings_get_fantasy_font_family(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_fantasy_font_family(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_webkit_settings_get_hardware_acceleration_policy(IntPtr raw);
		static d_webkit_settings_get_hardware_acceleration_policy webkit_settings_get_hardware_acceleration_policy = FuncLoader.LoadFunction<d_webkit_settings_get_hardware_acceleration_policy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_hardware_acceleration_policy"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_hardware_acceleration_policy(IntPtr raw, int policy);
		static d_webkit_settings_set_hardware_acceleration_policy webkit_settings_set_hardware_acceleration_policy = FuncLoader.LoadFunction<d_webkit_settings_set_hardware_acceleration_policy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_hardware_acceleration_policy"));

		[GLib.Property ("hardware-acceleration-policy")]
		public WebKit.HardwareAccelerationPolicy HardwareAccelerationPolicy {
			get  {
				int raw_ret = webkit_settings_get_hardware_acceleration_policy(Handle);
				WebKit.HardwareAccelerationPolicy ret = (WebKit.HardwareAccelerationPolicy) raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_hardware_acceleration_policy(Handle, (int) value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_javascript_can_access_clipboard(IntPtr raw);
		static d_webkit_settings_get_javascript_can_access_clipboard webkit_settings_get_javascript_can_access_clipboard = FuncLoader.LoadFunction<d_webkit_settings_get_javascript_can_access_clipboard>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_javascript_can_access_clipboard"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_javascript_can_access_clipboard(IntPtr raw, bool enabled);
		static d_webkit_settings_set_javascript_can_access_clipboard webkit_settings_set_javascript_can_access_clipboard = FuncLoader.LoadFunction<d_webkit_settings_set_javascript_can_access_clipboard>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_javascript_can_access_clipboard"));

		[GLib.Property ("javascript-can-access-clipboard")]
		public bool JavascriptCanAccessClipboard {
			get  {
				bool raw_ret = webkit_settings_get_javascript_can_access_clipboard(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_javascript_can_access_clipboard(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_javascript_can_open_windows_automatically(IntPtr raw);
		static d_webkit_settings_get_javascript_can_open_windows_automatically webkit_settings_get_javascript_can_open_windows_automatically = FuncLoader.LoadFunction<d_webkit_settings_get_javascript_can_open_windows_automatically>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_javascript_can_open_windows_automatically"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_javascript_can_open_windows_automatically(IntPtr raw, bool enabled);
		static d_webkit_settings_set_javascript_can_open_windows_automatically webkit_settings_set_javascript_can_open_windows_automatically = FuncLoader.LoadFunction<d_webkit_settings_set_javascript_can_open_windows_automatically>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_javascript_can_open_windows_automatically"));

		[GLib.Property ("javascript-can-open-windows-automatically")]
		public bool JavascriptCanOpenWindowsAutomatically {
			get  {
				bool raw_ret = webkit_settings_get_javascript_can_open_windows_automatically(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_javascript_can_open_windows_automatically(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_load_icons_ignoring_image_load_setting(IntPtr raw);
		static d_webkit_settings_get_load_icons_ignoring_image_load_setting webkit_settings_get_load_icons_ignoring_image_load_setting = FuncLoader.LoadFunction<d_webkit_settings_get_load_icons_ignoring_image_load_setting>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_load_icons_ignoring_image_load_setting"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_load_icons_ignoring_image_load_setting(IntPtr raw, bool enabled);
		static d_webkit_settings_set_load_icons_ignoring_image_load_setting webkit_settings_set_load_icons_ignoring_image_load_setting = FuncLoader.LoadFunction<d_webkit_settings_set_load_icons_ignoring_image_load_setting>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_load_icons_ignoring_image_load_setting"));

		[GLib.Property ("load-icons-ignoring-image-load-setting")]
		public bool LoadIconsIgnoringImageLoadSetting {
			get  {
				bool raw_ret = webkit_settings_get_load_icons_ignoring_image_load_setting(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_load_icons_ignoring_image_load_setting(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_media_content_types_requiring_hardware_support(IntPtr raw);
		static d_webkit_settings_get_media_content_types_requiring_hardware_support webkit_settings_get_media_content_types_requiring_hardware_support = FuncLoader.LoadFunction<d_webkit_settings_get_media_content_types_requiring_hardware_support>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_media_content_types_requiring_hardware_support"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_media_content_types_requiring_hardware_support(IntPtr raw, IntPtr content_types);
		static d_webkit_settings_set_media_content_types_requiring_hardware_support webkit_settings_set_media_content_types_requiring_hardware_support = FuncLoader.LoadFunction<d_webkit_settings_set_media_content_types_requiring_hardware_support>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_media_content_types_requiring_hardware_support"));

		[GLib.Property ("media-content-types-requiring-hardware-support")]
		public string MediaContentTypesRequiringHardwareSupport {
			get  {
				IntPtr raw_ret = webkit_settings_get_media_content_types_requiring_hardware_support(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_media_content_types_requiring_hardware_support(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_media_playback_allows_inline(IntPtr raw);
		static d_webkit_settings_get_media_playback_allows_inline webkit_settings_get_media_playback_allows_inline = FuncLoader.LoadFunction<d_webkit_settings_get_media_playback_allows_inline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_media_playback_allows_inline"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_media_playback_allows_inline(IntPtr raw, bool enabled);
		static d_webkit_settings_set_media_playback_allows_inline webkit_settings_set_media_playback_allows_inline = FuncLoader.LoadFunction<d_webkit_settings_set_media_playback_allows_inline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_media_playback_allows_inline"));

		[GLib.Property ("media-playback-allows-inline")]
		public bool MediaPlaybackAllowsInline {
			get  {
				bool raw_ret = webkit_settings_get_media_playback_allows_inline(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_media_playback_allows_inline(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_media_playback_requires_user_gesture(IntPtr raw);
		static d_webkit_settings_get_media_playback_requires_user_gesture webkit_settings_get_media_playback_requires_user_gesture = FuncLoader.LoadFunction<d_webkit_settings_get_media_playback_requires_user_gesture>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_media_playback_requires_user_gesture"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_media_playback_requires_user_gesture(IntPtr raw, bool enabled);
		static d_webkit_settings_set_media_playback_requires_user_gesture webkit_settings_set_media_playback_requires_user_gesture = FuncLoader.LoadFunction<d_webkit_settings_set_media_playback_requires_user_gesture>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_media_playback_requires_user_gesture"));

		[GLib.Property ("media-playback-requires-user-gesture")]
		public bool MediaPlaybackRequiresUserGesture {
			get  {
				bool raw_ret = webkit_settings_get_media_playback_requires_user_gesture(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_media_playback_requires_user_gesture(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_webkit_settings_get_minimum_font_size(IntPtr raw);
		static d_webkit_settings_get_minimum_font_size webkit_settings_get_minimum_font_size = FuncLoader.LoadFunction<d_webkit_settings_get_minimum_font_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_minimum_font_size"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_minimum_font_size(IntPtr raw, uint font_size);
		static d_webkit_settings_set_minimum_font_size webkit_settings_set_minimum_font_size = FuncLoader.LoadFunction<d_webkit_settings_set_minimum_font_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_minimum_font_size"));

		[GLib.Property ("minimum-font-size")]
		public uint MinimumFontSize {
			get  {
				uint raw_ret = webkit_settings_get_minimum_font_size(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_minimum_font_size(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_monospace_font_family(IntPtr raw);
		static d_webkit_settings_get_monospace_font_family webkit_settings_get_monospace_font_family = FuncLoader.LoadFunction<d_webkit_settings_get_monospace_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_monospace_font_family"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_monospace_font_family(IntPtr raw, IntPtr monospace_font_family);
		static d_webkit_settings_set_monospace_font_family webkit_settings_set_monospace_font_family = FuncLoader.LoadFunction<d_webkit_settings_set_monospace_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_monospace_font_family"));

		[GLib.Property ("monospace-font-family")]
		public string MonospaceFontFamily {
			get  {
				IntPtr raw_ret = webkit_settings_get_monospace_font_family(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_monospace_font_family(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_pictograph_font_family(IntPtr raw);
		static d_webkit_settings_get_pictograph_font_family webkit_settings_get_pictograph_font_family = FuncLoader.LoadFunction<d_webkit_settings_get_pictograph_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_pictograph_font_family"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_pictograph_font_family(IntPtr raw, IntPtr pictograph_font_family);
		static d_webkit_settings_set_pictograph_font_family webkit_settings_set_pictograph_font_family = FuncLoader.LoadFunction<d_webkit_settings_set_pictograph_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_pictograph_font_family"));

		[GLib.Property ("pictograph-font-family")]
		public string PictographFontFamily {
			get  {
				IntPtr raw_ret = webkit_settings_get_pictograph_font_family(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_pictograph_font_family(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_print_backgrounds(IntPtr raw);
		static d_webkit_settings_get_print_backgrounds webkit_settings_get_print_backgrounds = FuncLoader.LoadFunction<d_webkit_settings_get_print_backgrounds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_print_backgrounds"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_print_backgrounds(IntPtr raw, bool print_backgrounds);
		static d_webkit_settings_set_print_backgrounds webkit_settings_set_print_backgrounds = FuncLoader.LoadFunction<d_webkit_settings_set_print_backgrounds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_print_backgrounds"));

		[GLib.Property ("print-backgrounds")]
		public bool PrintBackgrounds {
			get  {
				bool raw_ret = webkit_settings_get_print_backgrounds(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_print_backgrounds(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_sans_serif_font_family(IntPtr raw);
		static d_webkit_settings_get_sans_serif_font_family webkit_settings_get_sans_serif_font_family = FuncLoader.LoadFunction<d_webkit_settings_get_sans_serif_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_sans_serif_font_family"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_sans_serif_font_family(IntPtr raw, IntPtr sans_serif_font_family);
		static d_webkit_settings_set_sans_serif_font_family webkit_settings_set_sans_serif_font_family = FuncLoader.LoadFunction<d_webkit_settings_set_sans_serif_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_sans_serif_font_family"));

		[GLib.Property ("sans-serif-font-family")]
		public string SansSerifFontFamily {
			get  {
				IntPtr raw_ret = webkit_settings_get_sans_serif_font_family(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_sans_serif_font_family(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_serif_font_family(IntPtr raw);
		static d_webkit_settings_get_serif_font_family webkit_settings_get_serif_font_family = FuncLoader.LoadFunction<d_webkit_settings_get_serif_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_serif_font_family"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_serif_font_family(IntPtr raw, IntPtr serif_font_family);
		static d_webkit_settings_set_serif_font_family webkit_settings_set_serif_font_family = FuncLoader.LoadFunction<d_webkit_settings_set_serif_font_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_serif_font_family"));

		[GLib.Property ("serif-font-family")]
		public string SerifFontFamily {
			get  {
				IntPtr raw_ret = webkit_settings_get_serif_font_family(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_serif_font_family(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_user_agent(IntPtr raw);
		static d_webkit_settings_get_user_agent webkit_settings_get_user_agent = FuncLoader.LoadFunction<d_webkit_settings_get_user_agent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_user_agent"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_user_agent(IntPtr raw, IntPtr user_agent);
		static d_webkit_settings_set_user_agent webkit_settings_set_user_agent = FuncLoader.LoadFunction<d_webkit_settings_set_user_agent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_user_agent"));

		[GLib.Property ("user-agent")]
		public string UserAgent {
			get  {
				IntPtr raw_ret = webkit_settings_get_user_agent(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_settings_set_user_agent(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_settings_get_zoom_text_only(IntPtr raw);
		static d_webkit_settings_get_zoom_text_only webkit_settings_get_zoom_text_only = FuncLoader.LoadFunction<d_webkit_settings_get_zoom_text_only>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_zoom_text_only"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_zoom_text_only(IntPtr raw, bool zoom_text_only);
		static d_webkit_settings_set_zoom_text_only webkit_settings_set_zoom_text_only = FuncLoader.LoadFunction<d_webkit_settings_set_zoom_text_only>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_zoom_text_only"));

		[GLib.Property ("zoom-text-only")]
		public bool ZoomTextOnly {
			get  {
				bool raw_ret = webkit_settings_get_zoom_text_only(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_settings_set_zoom_text_only(Handle, value);
			}
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public unsafe new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("_webkit_reserved0"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // _webkit_reserved0
							, null
							, "_webkit_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_webkit_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _webkit_reserved1
							, "_webkit_reserved0"
							, "_webkit_reserved2"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_webkit_reserved2"
							, -1
							, (uint) sizeof( IntPtr ) // _webkit_reserved2
							, "_webkit_reserved1"
							, "_webkit_reserved3"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_webkit_reserved3"
							, -1
							, (uint) sizeof( IntPtr ) // _webkit_reserved3
							, "_webkit_reserved2"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_settings_get_type();
		static d_webkit_settings_get_type webkit_settings_get_type = FuncLoader.LoadFunction<d_webkit_settings_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_get_type"));

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = webkit_settings_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_webkit_settings_font_size_to_pixels(uint points);
		static d_webkit_settings_font_size_to_pixels webkit_settings_font_size_to_pixels = FuncLoader.LoadFunction<d_webkit_settings_font_size_to_pixels>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_font_size_to_pixels"));

		public static uint FontSizeToPixels(uint points) {
			uint raw_ret = webkit_settings_font_size_to_pixels(points);
			uint ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_webkit_settings_font_size_to_points(uint pixels);
		static d_webkit_settings_font_size_to_points webkit_settings_font_size_to_points = FuncLoader.LoadFunction<d_webkit_settings_font_size_to_points>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_font_size_to_points"));

		public static uint FontSizeToPoints(uint pixels) {
			uint raw_ret = webkit_settings_font_size_to_points(pixels);
			uint ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_settings_set_user_agent_with_application_details(IntPtr raw, IntPtr application_name, IntPtr application_version);
		static d_webkit_settings_set_user_agent_with_application_details webkit_settings_set_user_agent_with_application_details = FuncLoader.LoadFunction<d_webkit_settings_set_user_agent_with_application_details>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_settings_set_user_agent_with_application_details"));

		public void SetUserAgentWithApplicationDetails(string application_name, string application_version) {
			IntPtr native_application_name = GLib.Marshaller.StringToPtrGStrdup (application_name);
			IntPtr native_application_version = GLib.Marshaller.StringToPtrGStrdup (application_version);
			webkit_settings_set_user_agent_with_application_details(Handle, native_application_name, native_application_version);
			GLib.Marshaller.Free (native_application_name);
			GLib.Marshaller.Free (native_application_version);
		}

		public void SetUserAgentWithApplicationDetails() {
			SetUserAgentWithApplicationDetails (null, null);
		}


		static Settings ()
		{
			GtkSharp.WebkitGtkSharp.ObjectManager.Initialize ();
		}

		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public unsafe new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("priv"
							, GLib.Object.abi_info.Fields
							, (uint) sizeof( IntPtr ) // priv
							, null
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
