KioskApp/GtkSharp/Source/Libs/WebkitGtkSharp/Generated/WebKit/WebView.cs

// 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 WebView : WebKit.WebViewBase {

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

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

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

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

		public WebView (WebKit.WebContext context) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (WebView)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = webkit_web_view_new_with_context(context == null ? IntPtr.Zero : context.Handle);
		}

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

		public WebView (WebKit.WebView web_view) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (WebView)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = webkit_web_view_new_with_related_view(web_view == null ? IntPtr.Zero : web_view.Handle);
		}

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

		public WebView (WebKit.Settings settings) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (WebView)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				if (settings != null) {
					names.Add ("settings");
					vals.Add (new GLib.Value (settings));
				}
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = webkit_web_view_new_with_settings(settings == null ? IntPtr.Zero : settings.Handle);
		}

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

		public WebView (WebKit.UserContentManager user_content_manager) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (WebView)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				if (user_content_manager != null) {
					names.Add ("user_content_manager");
					vals.Add (new GLib.Value (user_content_manager));
				}
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = webkit_web_view_new_with_user_content_manager(user_content_manager == null ? IntPtr.Zero : user_content_manager.Handle);
		}

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

		[GLib.Property ("automation-presentation-type")]
		public WebKit.AutomationBrowsingContextPresentation AutomationPresentationType {
			get  {
				int raw_ret = webkit_web_view_get_automation_presentation_type(Handle);
				WebKit.AutomationBrowsingContextPresentation ret = (WebKit.AutomationBrowsingContextPresentation) raw_ret;
				return ret;
			}
		}

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

		[GLib.Property ("editable")]
		public bool Editable {
			get {
				GLib.Value val = GetProperty ("editable");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set  {
				webkit_web_view_set_editable(Handle, value);
			}
		}

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

		[GLib.Property ("estimated-load-progress")]
		public double EstimatedLoadProgress {
			get  {
				double raw_ret = webkit_web_view_get_estimated_load_progress(Handle);
				double ret = raw_ret;
				return ret;
			}
		}

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

		[GLib.Property ("favicon")]
		public Cairo.Surface Favicon {
			get  {
				IntPtr raw_ret = webkit_web_view_get_favicon(Handle);
				Cairo.Surface ret = Cairo.Surface.Lookup (raw_ret, true);
				return ret;
			}
		}

		[GLib.Property ("is-controlled-by-automation")]
		public bool IsControlledByAutomationProp
       {
			get {
				GLib.Value val = GetProperty ("is-controlled-by-automation");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("is-ephemeral")]
		public bool IsEphemeralProp
       {
			get {
				GLib.Value val = GetProperty ("is-ephemeral");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("is-loading")]
		public bool IsLoadingProp
       {
			get {
				GLib.Value val = GetProperty ("is-loading");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

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

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

		[GLib.Property ("is-muted")]
		public bool IsMuted {
			get  {
				bool raw_ret = webkit_web_view_get_is_muted(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				webkit_web_view_set_is_muted(Handle, value);
			}
		}

		[GLib.Property ("is-playing-audio")]
		public bool IsPlayingAudioProp
       {
			get {
				GLib.Value val = GetProperty ("is-playing-audio");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Property ("page-id")]
		public ulong PageId {
			get  {
				ulong raw_ret = webkit_web_view_get_page_id(Handle);
				ulong ret = raw_ret;
				return ret;
			}
		}

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

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

		[GLib.Property ("settings")]
		public WebKit.Settings Settings {
			get  {
				IntPtr raw_ret = webkit_web_view_get_settings(Handle);
				WebKit.Settings ret = GLib.Object.GetObject(raw_ret) as WebKit.Settings;
				return ret;
			}
			set  {
				webkit_web_view_set_settings(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[GLib.Property ("title")]
		public string Title {
			get  {
				IntPtr raw_ret = webkit_web_view_get_title(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
		}

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

		[GLib.Property ("uri")]
		public string Uri {
			get  {
				IntPtr raw_ret = webkit_web_view_get_uri(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
		}

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

		[GLib.Property ("user-content-manager")]
		public WebKit.UserContentManager UserContentManager {
			get  {
				IntPtr raw_ret = webkit_web_view_get_user_content_manager(Handle);
				WebKit.UserContentManager ret = GLib.Object.GetObject(raw_ret) as WebKit.UserContentManager;
				return ret;
			}
		}

		[GLib.Property ("web-context")]
		public WebKit.WebContext WebContext {
			get {
				GLib.Value val = GetProperty ("web-context");
				WebKit.WebContext ret = (WebKit.WebContext) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Property ("website-policies")]
		public WebKit.WebsitePolicies WebsitePolicies {
			get  {
				IntPtr raw_ret = webkit_web_view_get_website_policies(Handle);
				WebKit.WebsitePolicies ret = GLib.Object.GetObject(raw_ret) as WebKit.WebsitePolicies;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_set_zoom_level(IntPtr raw, double zoom_level);
		static d_webkit_web_view_set_zoom_level webkit_web_view_set_zoom_level = FuncLoader.LoadFunction<d_webkit_web_view_set_zoom_level>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_set_zoom_level"));

		[GLib.Property ("zoom-level")]
		public double ZoomLevel {
			get  {
				double raw_ret = webkit_web_view_get_zoom_level(Handle);
				double ret = raw_ret;
				return ret;
			}
			set  {
				webkit_web_view_set_zoom_level(Handle, value);
			}
		}

		[GLib.Signal("load-failed")]
		public event WebKit.LoadFailedHandler LoadFailed {
			add {
				this.AddSignalHandler ("load-failed", value, typeof (WebKit.LoadFailedArgs));
			}
			remove {
				this.RemoveSignalHandler ("load-failed", value);
			}
		}

		[GLib.Signal("mouse-target-changed")]
		public event WebKit.MouseTargetChangedHandler MouseTargetChanged {
			add {
				this.AddSignalHandler ("mouse-target-changed", value, typeof (WebKit.MouseTargetChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("mouse-target-changed", value);
			}
		}

		[GLib.Signal("script-dialog")]
		public event WebKit.ScriptDialogHandler ScriptDialog {
			add {
				this.AddSignalHandler ("script-dialog", value, typeof (WebKit.ScriptDialogArgs));
			}
			remove {
				this.RemoveSignalHandler ("script-dialog", value);
			}
		}

		[GLib.Signal("resource-load-started")]
		public event WebKit.ResourceLoadStartedHandler ResourceLoadStarted {
			add {
				this.AddSignalHandler ("resource-load-started", value, typeof (WebKit.ResourceLoadStartedArgs));
			}
			remove {
				this.RemoveSignalHandler ("resource-load-started", value);
			}
		}

		[GLib.Signal("user-message-received")]
		public event WebKit.UserMessageReceivedHandler UserMessageReceived {
			add {
				this.AddSignalHandler ("user-message-received", value, typeof (WebKit.UserMessageReceivedArgs));
			}
			remove {
				this.RemoveSignalHandler ("user-message-received", value);
			}
		}

		[GLib.Signal("show-notification")]
		public event WebKit.ShowNotificationHandler ShowNotification {
			add {
				this.AddSignalHandler ("show-notification", value, typeof (WebKit.ShowNotificationArgs));
			}
			remove {
				this.RemoveSignalHandler ("show-notification", value);
			}
		}

		[GLib.Signal("leave-fullscreen")]
		public event WebKit.LeaveFullscreenHandler LeaveFullscreen {
			add {
				this.AddSignalHandler ("leave-fullscreen", value, typeof (WebKit.LeaveFullscreenArgs));
			}
			remove {
				this.RemoveSignalHandler ("leave-fullscreen", value);
			}
		}

		[GLib.Signal("ready-to-show")]
		public event System.EventHandler ReadyToShow {
			add {
				this.AddSignalHandler ("ready-to-show", value);
			}
			remove {
				this.RemoveSignalHandler ("ready-to-show", value);
			}
		}

		[GLib.Signal("decide-policy")]
		public event WebKit.DecidePolicyHandler DecidePolicy {
			add {
				this.AddSignalHandler ("decide-policy", value, typeof (WebKit.DecidePolicyArgs));
			}
			remove {
				this.RemoveSignalHandler ("decide-policy", value);
			}
		}

		[GLib.Signal("run-file-chooser")]
		public event WebKit.RunFileChooserHandler RunFileChooser {
			add {
				this.AddSignalHandler ("run-file-chooser", value, typeof (WebKit.RunFileChooserArgs));
			}
			remove {
				this.RemoveSignalHandler ("run-file-chooser", value);
			}
		}

		[GLib.Signal("insecure-content-detected")]
		public event WebKit.InsecureContentDetectedHandler InsecureContentDetected {
			add {
				this.AddSignalHandler ("insecure-content-detected", value, typeof (WebKit.InsecureContentDetectedArgs));
			}
			remove {
				this.RemoveSignalHandler ("insecure-content-detected", value);
			}
		}

		[GLib.Signal("web-process-crashed")]
		public event WebKit.WebProcessCrashedHandler WebProcessCrashed {
			add {
				this.AddSignalHandler ("web-process-crashed", value, typeof (WebKit.WebProcessCrashedArgs));
			}
			remove {
				this.RemoveSignalHandler ("web-process-crashed", value);
			}
		}

		[GLib.Signal("load-changed")]
		public event WebKit.LoadChangedHandler LoadChanged {
			add {
				this.AddSignalHandler ("load-changed", value, typeof (WebKit.LoadChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("load-changed", value);
			}
		}

		[GLib.Signal("load-failed-with-tls-errors")]
		public event WebKit.LoadFailedWithTlsErrorsHandler LoadFailedWithTlsErrors {
			add {
				this.AddSignalHandler ("load-failed-with-tls-errors", value, typeof (WebKit.LoadFailedWithTlsErrorsArgs));
			}
			remove {
				this.RemoveSignalHandler ("load-failed-with-tls-errors", value);
			}
		}

		[GLib.Signal("close")]
		public event System.EventHandler Close {
			add {
				this.AddSignalHandler ("close", value);
			}
			remove {
				this.RemoveSignalHandler ("close", value);
			}
		}

		[GLib.Signal("context-menu-dismissed")]
		public event System.EventHandler ContextMenuDismissed {
			add {
				this.AddSignalHandler ("context-menu-dismissed", value);
			}
			remove {
				this.RemoveSignalHandler ("context-menu-dismissed", value);
			}
		}

		[GLib.Signal("context-menu")]
		public event WebKit.ContextMenuHandler ContextMenu {
			add {
				this.AddSignalHandler ("context-menu", value, typeof (WebKit.ContextMenuArgs));
			}
			remove {
				this.RemoveSignalHandler ("context-menu", value);
			}
		}

		[GLib.Signal("run-color-chooser")]
		public event WebKit.RunColorChooserHandler RunColorChooser {
			add {
				this.AddSignalHandler ("run-color-chooser", value, typeof (WebKit.RunColorChooserArgs));
			}
			remove {
				this.RemoveSignalHandler ("run-color-chooser", value);
			}
		}

		[GLib.Signal("enter-fullscreen")]
		public event WebKit.EnterFullscreenHandler EnterFullscreen {
			add {
				this.AddSignalHandler ("enter-fullscreen", value, typeof (WebKit.EnterFullscreenArgs));
			}
			remove {
				this.RemoveSignalHandler ("enter-fullscreen", value);
			}
		}

		[GLib.Signal("web-process-terminated")]
		public event WebKit.WebProcessTerminatedHandler WebProcessTerminated {
			add {
				this.AddSignalHandler ("web-process-terminated", value, typeof (WebKit.WebProcessTerminatedArgs));
			}
			remove {
				this.RemoveSignalHandler ("web-process-terminated", value);
			}
		}

		[GLib.Signal("create")]
		public event WebKit.CreateHandler Create {
			add {
				this.AddSignalHandler ("create", value, typeof (WebKit.CreateArgs));
			}
			remove {
				this.RemoveSignalHandler ("create", value);
			}
		}

		[GLib.Signal("run-as-modal")]
		public event System.EventHandler RunAsModal {
			add {
				this.AddSignalHandler ("run-as-modal", value);
			}
			remove {
				this.RemoveSignalHandler ("run-as-modal", value);
			}
		}

		[GLib.Signal("submit-form")]
		public event WebKit.SubmitFormHandler SubmitForm {
			add {
				this.AddSignalHandler ("submit-form", value, typeof (WebKit.SubmitFormArgs));
			}
			remove {
				this.RemoveSignalHandler ("submit-form", value);
			}
		}

		[GLib.Signal("permission-request")]
		public event WebKit.PermissionRequestHandler PermissionRequest {
			add {
				this.AddSignalHandler ("permission-request", value, typeof (WebKit.PermissionRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("permission-request", value);
			}
		}

		[GLib.Signal("authenticate")]
		public event WebKit.AuthenticateHandler Authenticate {
			add {
				this.AddSignalHandler ("authenticate", value, typeof (WebKit.AuthenticateArgs));
			}
			remove {
				this.RemoveSignalHandler ("authenticate", value);
			}
		}

		[GLib.Signal("show-option-menu")]
		public event WebKit.ShowOptionMenuHandler ShowOptionMenu {
			add {
				this.AddSignalHandler ("show-option-menu", value, typeof (WebKit.ShowOptionMenuArgs));
			}
			remove {
				this.RemoveSignalHandler ("show-option-menu", value);
			}
		}

		[GLib.Signal("print")]
		public event WebKit.PrintHandler Print {
			add {
				this.AddSignalHandler ("print", value, typeof (WebKit.PrintArgs));
			}
			remove {
				this.RemoveSignalHandler ("print", value);
			}
		}

		static LoadChangedNativeDelegate LoadChanged_cb_delegate;
		static LoadChangedNativeDelegate LoadChangedVMCallback {
			get {
				if (LoadChanged_cb_delegate == null)
					LoadChanged_cb_delegate = new LoadChangedNativeDelegate (LoadChanged_cb);
				return LoadChanged_cb_delegate;
			}
		}

		static void OverrideLoadChanged (GLib.GType gtype)
		{
			OverrideLoadChanged (gtype, LoadChangedVMCallback);
		}

		static void OverrideLoadChanged (GLib.GType gtype, LoadChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("load_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void LoadChangedNativeDelegate (IntPtr inst, int load_event);

		static void LoadChanged_cb (IntPtr inst, int load_event)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnLoadChanged ((WebKit.LoadEvent) load_event);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideLoadChanged")]
		protected virtual void OnLoadChanged (WebKit.LoadEvent load_event)
		{
			InternalLoadChanged (load_event);
		}

		private void InternalLoadChanged (WebKit.LoadEvent load_event)
		{
			LoadChangedNativeDelegate unmanaged = class_abi.BaseOverride<LoadChangedNativeDelegate>(this.LookupGType(), "load_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) load_event);
		}

		static LoadFailedNativeDelegate LoadFailed_cb_delegate;
		static LoadFailedNativeDelegate LoadFailedVMCallback {
			get {
				if (LoadFailed_cb_delegate == null)
					LoadFailed_cb_delegate = new LoadFailedNativeDelegate (LoadFailed_cb);
				return LoadFailed_cb_delegate;
			}
		}

		static void OverrideLoadFailed (GLib.GType gtype)
		{
			OverrideLoadFailed (gtype, LoadFailedVMCallback);
		}

		static void OverrideLoadFailed (GLib.GType gtype, LoadFailedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("load_failed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool LoadFailedNativeDelegate (IntPtr inst, int load_event, IntPtr failing_uri, IntPtr error);

		static bool LoadFailed_cb (IntPtr inst, int load_event, IntPtr failing_uri, IntPtr error)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnLoadFailed ((WebKit.LoadEvent) load_event, GLib.Marshaller.Utf8PtrToString (failing_uri), error);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideLoadFailed")]
		protected virtual bool OnLoadFailed (WebKit.LoadEvent load_event, string failing_uri, IntPtr error)
		{
			return InternalLoadFailed (load_event, failing_uri, error);
		}

		private bool InternalLoadFailed (WebKit.LoadEvent load_event, string failing_uri, IntPtr error)
		{
			LoadFailedNativeDelegate unmanaged = class_abi.BaseOverride<LoadFailedNativeDelegate>(this.LookupGType(), "load_failed");
			if (unmanaged == null) return false;

			IntPtr native_failing_uri = GLib.Marshaller.StringToPtrGStrdup (failing_uri);
			bool __result = unmanaged (this.Handle, (int) load_event, native_failing_uri, error);
			GLib.Marshaller.Free (native_failing_uri);
			return __result;
		}

		static CreateNativeDelegate Create_cb_delegate;
		static CreateNativeDelegate CreateVMCallback {
			get {
				if (Create_cb_delegate == null)
					Create_cb_delegate = new CreateNativeDelegate (Create_cb);
				return Create_cb_delegate;
			}
		}

		static void OverrideCreate (GLib.GType gtype)
		{
			OverrideCreate (gtype, CreateVMCallback);
		}

		static void OverrideCreate (GLib.GType gtype, CreateNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("create"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr CreateNativeDelegate (IntPtr inst, IntPtr navigation_action);

		static IntPtr Create_cb (IntPtr inst, IntPtr navigation_action)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				Gtk.Widget __result;
				__result = __obj.OnCreate (WebKit.NavigationAction.New (navigation_action));
				return __result == null ? IntPtr.Zero : __result.OwnedHandle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideCreate")]
		protected virtual Gtk.Widget OnCreate (WebKit.NavigationAction navigation_action)
		{
			return InternalCreate (navigation_action);
		}

		private Gtk.Widget InternalCreate (WebKit.NavigationAction navigation_action)
		{
			CreateNativeDelegate unmanaged = class_abi.BaseOverride<CreateNativeDelegate>(this.LookupGType(), "create");
			if (unmanaged == null) return null;

			IntPtr native_navigation_action = GLib.Marshaller.StructureToPtrAlloc (navigation_action);
			IntPtr __result = unmanaged (this.Handle, native_navigation_action);
			Marshal.FreeHGlobal (native_navigation_action);
			return GLib.Object.GetObject(__result, true) as Gtk.Widget;
		}

		static ReadyToShowNativeDelegate ReadyToShow_cb_delegate;
		static ReadyToShowNativeDelegate ReadyToShowVMCallback {
			get {
				if (ReadyToShow_cb_delegate == null)
					ReadyToShow_cb_delegate = new ReadyToShowNativeDelegate (ReadyToShow_cb);
				return ReadyToShow_cb_delegate;
			}
		}

		static void OverrideReadyToShow (GLib.GType gtype)
		{
			OverrideReadyToShow (gtype, ReadyToShowVMCallback);
		}

		static void OverrideReadyToShow (GLib.GType gtype, ReadyToShowNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("ready_to_show"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ReadyToShowNativeDelegate (IntPtr inst);

		static void ReadyToShow_cb (IntPtr inst)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnReadyToShow ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideReadyToShow")]
		protected virtual void OnReadyToShow ()
		{
			InternalReadyToShow ();
		}

		private void InternalReadyToShow ()
		{
			ReadyToShowNativeDelegate unmanaged = class_abi.BaseOverride<ReadyToShowNativeDelegate>(this.LookupGType(), "ready_to_show");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static RunAsModalNativeDelegate RunAsModal_cb_delegate;
		static RunAsModalNativeDelegate RunAsModalVMCallback {
			get {
				if (RunAsModal_cb_delegate == null)
					RunAsModal_cb_delegate = new RunAsModalNativeDelegate (RunAsModal_cb);
				return RunAsModal_cb_delegate;
			}
		}

		static void OverrideRunAsModal (GLib.GType gtype)
		{
			OverrideRunAsModal (gtype, RunAsModalVMCallback);
		}

		static void OverrideRunAsModal (GLib.GType gtype, RunAsModalNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("run_as_modal"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RunAsModalNativeDelegate (IntPtr inst);

		static void RunAsModal_cb (IntPtr inst)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnRunAsModal ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideRunAsModal")]
		protected virtual void OnRunAsModal ()
		{
			InternalRunAsModal ();
		}

		private void InternalRunAsModal ()
		{
			RunAsModalNativeDelegate unmanaged = class_abi.BaseOverride<RunAsModalNativeDelegate>(this.LookupGType(), "run_as_modal");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static CloseNativeDelegate Close_cb_delegate;
		static CloseNativeDelegate CloseVMCallback {
			get {
				if (Close_cb_delegate == null)
					Close_cb_delegate = new CloseNativeDelegate (Close_cb);
				return Close_cb_delegate;
			}
		}

		static void OverrideClose (GLib.GType gtype)
		{
			OverrideClose (gtype, CloseVMCallback);
		}

		static void OverrideClose (GLib.GType gtype, CloseNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("close"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void CloseNativeDelegate (IntPtr inst);

		static void Close_cb (IntPtr inst)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnClose ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideClose")]
		protected virtual void OnClose ()
		{
			InternalClose ();
		}

		private void InternalClose ()
		{
			CloseNativeDelegate unmanaged = class_abi.BaseOverride<CloseNativeDelegate>(this.LookupGType(), "close");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ScriptDialogNativeDelegate ScriptDialog_cb_delegate;
		static ScriptDialogNativeDelegate ScriptDialogVMCallback {
			get {
				if (ScriptDialog_cb_delegate == null)
					ScriptDialog_cb_delegate = new ScriptDialogNativeDelegate (ScriptDialog_cb);
				return ScriptDialog_cb_delegate;
			}
		}

		static void OverrideScriptDialog (GLib.GType gtype)
		{
			OverrideScriptDialog (gtype, ScriptDialogVMCallback);
		}

		static void OverrideScriptDialog (GLib.GType gtype, ScriptDialogNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("script_dialog"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ScriptDialogNativeDelegate (IntPtr inst, IntPtr dialog);

		static bool ScriptDialog_cb (IntPtr inst, IntPtr dialog)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnScriptDialog (WebKit.ScriptDialog.New (dialog));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideScriptDialog")]
		protected virtual bool OnScriptDialog (WebKit.ScriptDialog dialog)
		{
			return InternalScriptDialog (dialog);
		}

		private bool InternalScriptDialog (WebKit.ScriptDialog dialog)
		{
			ScriptDialogNativeDelegate unmanaged = class_abi.BaseOverride<ScriptDialogNativeDelegate>(this.LookupGType(), "script_dialog");
			if (unmanaged == null) return false;

			IntPtr native_dialog = GLib.Marshaller.StructureToPtrAlloc (dialog);
			bool __result = unmanaged (this.Handle, native_dialog);
			Marshal.FreeHGlobal (native_dialog);
			return __result;
		}

		static DecidePolicyNativeDelegate DecidePolicy_cb_delegate;
		static DecidePolicyNativeDelegate DecidePolicyVMCallback {
			get {
				if (DecidePolicy_cb_delegate == null)
					DecidePolicy_cb_delegate = new DecidePolicyNativeDelegate (DecidePolicy_cb);
				return DecidePolicy_cb_delegate;
			}
		}

		static void OverrideDecidePolicy (GLib.GType gtype)
		{
			OverrideDecidePolicy (gtype, DecidePolicyVMCallback);
		}

		static void OverrideDecidePolicy (GLib.GType gtype, DecidePolicyNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("decide_policy"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DecidePolicyNativeDelegate (IntPtr inst, IntPtr decision, int decision_type);

		static bool DecidePolicy_cb (IntPtr inst, IntPtr decision, int decision_type)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnDecidePolicy (GLib.Object.GetObject(decision) as WebKit.PolicyDecision, (WebKit.PolicyDecisionType) decision_type);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideDecidePolicy")]
		protected virtual bool OnDecidePolicy (WebKit.PolicyDecision decision, WebKit.PolicyDecisionType decision_type)
		{
			return InternalDecidePolicy (decision, decision_type);
		}

		private bool InternalDecidePolicy (WebKit.PolicyDecision decision, WebKit.PolicyDecisionType decision_type)
		{
			DecidePolicyNativeDelegate unmanaged = class_abi.BaseOverride<DecidePolicyNativeDelegate>(this.LookupGType(), "decide_policy");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, decision == null ? IntPtr.Zero : decision.Handle, (int) decision_type);
			return __result;
		}

		static PermissionRequestNativeDelegate PermissionRequest_cb_delegate;
		static PermissionRequestNativeDelegate PermissionRequestVMCallback {
			get {
				if (PermissionRequest_cb_delegate == null)
					PermissionRequest_cb_delegate = new PermissionRequestNativeDelegate (PermissionRequest_cb);
				return PermissionRequest_cb_delegate;
			}
		}

		static void OverridePermissionRequest (GLib.GType gtype)
		{
			OverridePermissionRequest (gtype, PermissionRequestVMCallback);
		}

		static void OverridePermissionRequest (GLib.GType gtype, PermissionRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("permission_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool PermissionRequestNativeDelegate (IntPtr inst, IntPtr request);

		static bool PermissionRequest_cb (IntPtr inst, IntPtr request)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnPermissionRequest (WebKit.PermissionRequestAdapter.GetObject (request, false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverridePermissionRequest")]
		protected virtual bool OnPermissionRequest (WebKit.IPermissionRequest request)
		{
			return InternalPermissionRequest (request);
		}

		private bool InternalPermissionRequest (WebKit.IPermissionRequest request)
		{
			PermissionRequestNativeDelegate unmanaged = class_abi.BaseOverride<PermissionRequestNativeDelegate>(this.LookupGType(), "permission_request");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, request == null ? IntPtr.Zero : ((request is GLib.Object) ? (request as GLib.Object).Handle : (request as WebKit.PermissionRequestAdapter).Handle));
			return __result;
		}

		static MouseTargetChangedNativeDelegate MouseTargetChanged_cb_delegate;
		static MouseTargetChangedNativeDelegate MouseTargetChangedVMCallback {
			get {
				if (MouseTargetChanged_cb_delegate == null)
					MouseTargetChanged_cb_delegate = new MouseTargetChangedNativeDelegate (MouseTargetChanged_cb);
				return MouseTargetChanged_cb_delegate;
			}
		}

		static void OverrideMouseTargetChanged (GLib.GType gtype)
		{
			OverrideMouseTargetChanged (gtype, MouseTargetChangedVMCallback);
		}

		static void OverrideMouseTargetChanged (GLib.GType gtype, MouseTargetChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("mouse_target_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MouseTargetChangedNativeDelegate (IntPtr inst, IntPtr hit_test_result, uint modifiers);

		static void MouseTargetChanged_cb (IntPtr inst, IntPtr hit_test_result, uint modifiers)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnMouseTargetChanged (GLib.Object.GetObject(hit_test_result) as WebKit.HitTestResult, modifiers);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideMouseTargetChanged")]
		protected virtual void OnMouseTargetChanged (WebKit.HitTestResult hit_test_result, uint modifiers)
		{
			InternalMouseTargetChanged (hit_test_result, modifiers);
		}

		private void InternalMouseTargetChanged (WebKit.HitTestResult hit_test_result, uint modifiers)
		{
			MouseTargetChangedNativeDelegate unmanaged = class_abi.BaseOverride<MouseTargetChangedNativeDelegate>(this.LookupGType(), "mouse_target_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle, hit_test_result == null ? IntPtr.Zero : hit_test_result.Handle, modifiers);
		}

		static PrintNativeDelegate Print_cb_delegate;
		static PrintNativeDelegate PrintVMCallback {
			get {
				if (Print_cb_delegate == null)
					Print_cb_delegate = new PrintNativeDelegate (Print_cb);
				return Print_cb_delegate;
			}
		}

		static void OverridePrint (GLib.GType gtype)
		{
			OverridePrint (gtype, PrintVMCallback);
		}

		static void OverridePrint (GLib.GType gtype, PrintNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("print"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool PrintNativeDelegate (IntPtr inst, IntPtr print_operation);

		static bool Print_cb (IntPtr inst, IntPtr print_operation)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnPrint (GLib.Object.GetObject(print_operation) as WebKit.PrintOperation);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverridePrint")]
		protected virtual bool OnPrint (WebKit.PrintOperation print_operation)
		{
			return InternalPrint (print_operation);
		}

		private bool InternalPrint (WebKit.PrintOperation print_operation)
		{
			PrintNativeDelegate unmanaged = class_abi.BaseOverride<PrintNativeDelegate>(this.LookupGType(), "print");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, print_operation == null ? IntPtr.Zero : print_operation.Handle);
			return __result;
		}

		static ResourceLoadStartedNativeDelegate ResourceLoadStarted_cb_delegate;
		static ResourceLoadStartedNativeDelegate ResourceLoadStartedVMCallback {
			get {
				if (ResourceLoadStarted_cb_delegate == null)
					ResourceLoadStarted_cb_delegate = new ResourceLoadStartedNativeDelegate (ResourceLoadStarted_cb);
				return ResourceLoadStarted_cb_delegate;
			}
		}

		static void OverrideResourceLoadStarted (GLib.GType gtype)
		{
			OverrideResourceLoadStarted (gtype, ResourceLoadStartedVMCallback);
		}

		static void OverrideResourceLoadStarted (GLib.GType gtype, ResourceLoadStartedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("resource_load_started"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ResourceLoadStartedNativeDelegate (IntPtr inst, IntPtr resource, IntPtr request);

		static void ResourceLoadStarted_cb (IntPtr inst, IntPtr resource, IntPtr request)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnResourceLoadStarted (GLib.Object.GetObject(resource) as WebKit.WebResource, GLib.Object.GetObject(request) as WebKit.URIRequest);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideResourceLoadStarted")]
		protected virtual void OnResourceLoadStarted (WebKit.WebResource resource, WebKit.URIRequest request)
		{
			InternalResourceLoadStarted (resource, request);
		}

		private void InternalResourceLoadStarted (WebKit.WebResource resource, WebKit.URIRequest request)
		{
			ResourceLoadStartedNativeDelegate unmanaged = class_abi.BaseOverride<ResourceLoadStartedNativeDelegate>(this.LookupGType(), "resource_load_started");
			if (unmanaged == null) return;

			unmanaged (this.Handle, resource == null ? IntPtr.Zero : resource.Handle, request == null ? IntPtr.Zero : request.Handle);
		}

		static EnterFullscreenNativeDelegate EnterFullscreen_cb_delegate;
		static EnterFullscreenNativeDelegate EnterFullscreenVMCallback {
			get {
				if (EnterFullscreen_cb_delegate == null)
					EnterFullscreen_cb_delegate = new EnterFullscreenNativeDelegate (EnterFullscreen_cb);
				return EnterFullscreen_cb_delegate;
			}
		}

		static void OverrideEnterFullscreen (GLib.GType gtype)
		{
			OverrideEnterFullscreen (gtype, EnterFullscreenVMCallback);
		}

		static void OverrideEnterFullscreen (GLib.GType gtype, EnterFullscreenNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("enter_fullscreen"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool EnterFullscreenNativeDelegate (IntPtr inst);

		static bool EnterFullscreen_cb (IntPtr inst)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnEnterFullscreen ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideEnterFullscreen")]
		protected virtual bool OnEnterFullscreen ()
		{
			return InternalEnterFullscreen ();
		}

		private bool InternalEnterFullscreen ()
		{
			EnterFullscreenNativeDelegate unmanaged = class_abi.BaseOverride<EnterFullscreenNativeDelegate>(this.LookupGType(), "enter_fullscreen");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static LeaveFullscreenNativeDelegate LeaveFullscreen_cb_delegate;
		static LeaveFullscreenNativeDelegate LeaveFullscreenVMCallback {
			get {
				if (LeaveFullscreen_cb_delegate == null)
					LeaveFullscreen_cb_delegate = new LeaveFullscreenNativeDelegate (LeaveFullscreen_cb);
				return LeaveFullscreen_cb_delegate;
			}
		}

		static void OverrideLeaveFullscreen (GLib.GType gtype)
		{
			OverrideLeaveFullscreen (gtype, LeaveFullscreenVMCallback);
		}

		static void OverrideLeaveFullscreen (GLib.GType gtype, LeaveFullscreenNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("leave_fullscreen"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool LeaveFullscreenNativeDelegate (IntPtr inst);

		static bool LeaveFullscreen_cb (IntPtr inst)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnLeaveFullscreen ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideLeaveFullscreen")]
		protected virtual bool OnLeaveFullscreen ()
		{
			return InternalLeaveFullscreen ();
		}

		private bool InternalLeaveFullscreen ()
		{
			LeaveFullscreenNativeDelegate unmanaged = class_abi.BaseOverride<LeaveFullscreenNativeDelegate>(this.LookupGType(), "leave_fullscreen");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static RunFileChooserNativeDelegate RunFileChooser_cb_delegate;
		static RunFileChooserNativeDelegate RunFileChooserVMCallback {
			get {
				if (RunFileChooser_cb_delegate == null)
					RunFileChooser_cb_delegate = new RunFileChooserNativeDelegate (RunFileChooser_cb);
				return RunFileChooser_cb_delegate;
			}
		}

		static void OverrideRunFileChooser (GLib.GType gtype)
		{
			OverrideRunFileChooser (gtype, RunFileChooserVMCallback);
		}

		static void OverrideRunFileChooser (GLib.GType gtype, RunFileChooserNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("run_file_chooser"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool RunFileChooserNativeDelegate (IntPtr inst, IntPtr request);

		static bool RunFileChooser_cb (IntPtr inst, IntPtr request)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnRunFileChooser (GLib.Object.GetObject(request) as WebKit.FileChooserRequest);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideRunFileChooser")]
		protected virtual bool OnRunFileChooser (WebKit.FileChooserRequest request)
		{
			return InternalRunFileChooser (request);
		}

		private bool InternalRunFileChooser (WebKit.FileChooserRequest request)
		{
			RunFileChooserNativeDelegate unmanaged = class_abi.BaseOverride<RunFileChooserNativeDelegate>(this.LookupGType(), "run_file_chooser");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, request == null ? IntPtr.Zero : request.Handle);
			return __result;
		}

		static ContextMenuNativeDelegate ContextMenu_cb_delegate;
		static ContextMenuNativeDelegate ContextMenuVMCallback {
			get {
				if (ContextMenu_cb_delegate == null)
					ContextMenu_cb_delegate = new ContextMenuNativeDelegate (ContextMenu_cb);
				return ContextMenu_cb_delegate;
			}
		}

		static void OverrideContextMenu (GLib.GType gtype)
		{
			OverrideContextMenu (gtype, ContextMenuVMCallback);
		}

		static void OverrideContextMenu (GLib.GType gtype, ContextMenuNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("context_menu"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ContextMenuNativeDelegate (IntPtr inst, IntPtr context_menu, IntPtr evnt, IntPtr hit_test_result);

		static bool ContextMenu_cb (IntPtr inst, IntPtr context_menu, IntPtr evnt, IntPtr hit_test_result)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnContextMenu (GLib.Object.GetObject(context_menu) as WebKit.ContextMenu, Gdk.Event.GetEvent (evnt), GLib.Object.GetObject(hit_test_result) as WebKit.HitTestResult);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideContextMenu")]
		protected virtual bool OnContextMenu (WebKit.ContextMenu context_menu, Gdk.Event evnt, WebKit.HitTestResult hit_test_result)
		{
			return InternalContextMenu (context_menu, evnt, hit_test_result);
		}

		private bool InternalContextMenu (WebKit.ContextMenu context_menu, Gdk.Event evnt, WebKit.HitTestResult hit_test_result)
		{
			ContextMenuNativeDelegate unmanaged = class_abi.BaseOverride<ContextMenuNativeDelegate>(this.LookupGType(), "context_menu");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, context_menu == null ? IntPtr.Zero : context_menu.Handle, evnt == null ? IntPtr.Zero : evnt.Handle, hit_test_result == null ? IntPtr.Zero : hit_test_result.Handle);
			return __result;
		}

		static ContextMenuDismissedNativeDelegate ContextMenuDismissed_cb_delegate;
		static ContextMenuDismissedNativeDelegate ContextMenuDismissedVMCallback {
			get {
				if (ContextMenuDismissed_cb_delegate == null)
					ContextMenuDismissed_cb_delegate = new ContextMenuDismissedNativeDelegate (ContextMenuDismissed_cb);
				return ContextMenuDismissed_cb_delegate;
			}
		}

		static void OverrideContextMenuDismissed (GLib.GType gtype)
		{
			OverrideContextMenuDismissed (gtype, ContextMenuDismissedVMCallback);
		}

		static void OverrideContextMenuDismissed (GLib.GType gtype, ContextMenuDismissedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("context_menu_dismissed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ContextMenuDismissedNativeDelegate (IntPtr inst);

		static void ContextMenuDismissed_cb (IntPtr inst)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnContextMenuDismissed ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideContextMenuDismissed")]
		protected virtual void OnContextMenuDismissed ()
		{
			InternalContextMenuDismissed ();
		}

		private void InternalContextMenuDismissed ()
		{
			ContextMenuDismissedNativeDelegate unmanaged = class_abi.BaseOverride<ContextMenuDismissedNativeDelegate>(this.LookupGType(), "context_menu_dismissed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static SubmitFormNativeDelegate SubmitForm_cb_delegate;
		static SubmitFormNativeDelegate SubmitFormVMCallback {
			get {
				if (SubmitForm_cb_delegate == null)
					SubmitForm_cb_delegate = new SubmitFormNativeDelegate (SubmitForm_cb);
				return SubmitForm_cb_delegate;
			}
		}

		static void OverrideSubmitForm (GLib.GType gtype)
		{
			OverrideSubmitForm (gtype, SubmitFormVMCallback);
		}

		static void OverrideSubmitForm (GLib.GType gtype, SubmitFormNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("submit_form"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SubmitFormNativeDelegate (IntPtr inst, IntPtr request);

		static void SubmitForm_cb (IntPtr inst, IntPtr request)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnSubmitForm (GLib.Object.GetObject(request) as WebKit.FormSubmissionRequest);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideSubmitForm")]
		protected virtual void OnSubmitForm (WebKit.FormSubmissionRequest request)
		{
			InternalSubmitForm (request);
		}

		private void InternalSubmitForm (WebKit.FormSubmissionRequest request)
		{
			SubmitFormNativeDelegate unmanaged = class_abi.BaseOverride<SubmitFormNativeDelegate>(this.LookupGType(), "submit_form");
			if (unmanaged == null) return;

			unmanaged (this.Handle, request == null ? IntPtr.Zero : request.Handle);
		}

		static InsecureContentDetectedNativeDelegate InsecureContentDetected_cb_delegate;
		static InsecureContentDetectedNativeDelegate InsecureContentDetectedVMCallback {
			get {
				if (InsecureContentDetected_cb_delegate == null)
					InsecureContentDetected_cb_delegate = new InsecureContentDetectedNativeDelegate (InsecureContentDetected_cb);
				return InsecureContentDetected_cb_delegate;
			}
		}

		static void OverrideInsecureContentDetected (GLib.GType gtype)
		{
			OverrideInsecureContentDetected (gtype, InsecureContentDetectedVMCallback);
		}

		static void OverrideInsecureContentDetected (GLib.GType gtype, InsecureContentDetectedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("insecure_content_detected"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void InsecureContentDetectedNativeDelegate (IntPtr inst, int evnt);

		static void InsecureContentDetected_cb (IntPtr inst, int evnt)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnInsecureContentDetected ((WebKit.InsecureContentEvent) evnt);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideInsecureContentDetected")]
		protected virtual void OnInsecureContentDetected (WebKit.InsecureContentEvent evnt)
		{
			InternalInsecureContentDetected (evnt);
		}

		private void InternalInsecureContentDetected (WebKit.InsecureContentEvent evnt)
		{
			InsecureContentDetectedNativeDelegate unmanaged = class_abi.BaseOverride<InsecureContentDetectedNativeDelegate>(this.LookupGType(), "insecure_content_detected");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) evnt);
		}

		static WebProcessCrashedNativeDelegate WebProcessCrashed_cb_delegate;
		static WebProcessCrashedNativeDelegate WebProcessCrashedVMCallback {
			get {
				if (WebProcessCrashed_cb_delegate == null)
					WebProcessCrashed_cb_delegate = new WebProcessCrashedNativeDelegate (WebProcessCrashed_cb);
				return WebProcessCrashed_cb_delegate;
			}
		}

		static void OverrideWebProcessCrashed (GLib.GType gtype)
		{
			OverrideWebProcessCrashed (gtype, WebProcessCrashedVMCallback);
		}

		static void OverrideWebProcessCrashed (GLib.GType gtype, WebProcessCrashedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("web_process_crashed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool WebProcessCrashedNativeDelegate (IntPtr inst);

		static bool WebProcessCrashed_cb (IntPtr inst)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnWebProcessCrashed ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideWebProcessCrashed")]
		protected virtual bool OnWebProcessCrashed ()
		{
			return InternalWebProcessCrashed ();
		}

		private bool InternalWebProcessCrashed ()
		{
			WebProcessCrashedNativeDelegate unmanaged = class_abi.BaseOverride<WebProcessCrashedNativeDelegate>(this.LookupGType(), "web_process_crashed");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static AuthenticateNativeDelegate Authenticate_cb_delegate;
		static AuthenticateNativeDelegate AuthenticateVMCallback {
			get {
				if (Authenticate_cb_delegate == null)
					Authenticate_cb_delegate = new AuthenticateNativeDelegate (Authenticate_cb);
				return Authenticate_cb_delegate;
			}
		}

		static void OverrideAuthenticate (GLib.GType gtype)
		{
			OverrideAuthenticate (gtype, AuthenticateVMCallback);
		}

		static void OverrideAuthenticate (GLib.GType gtype, AuthenticateNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("authenticate"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool AuthenticateNativeDelegate (IntPtr inst, IntPtr request);

		static bool Authenticate_cb (IntPtr inst, IntPtr request)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnAuthenticate (GLib.Object.GetObject(request) as WebKit.AuthenticationRequest);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideAuthenticate")]
		protected virtual bool OnAuthenticate (WebKit.AuthenticationRequest request)
		{
			return InternalAuthenticate (request);
		}

		private bool InternalAuthenticate (WebKit.AuthenticationRequest request)
		{
			AuthenticateNativeDelegate unmanaged = class_abi.BaseOverride<AuthenticateNativeDelegate>(this.LookupGType(), "authenticate");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, request == null ? IntPtr.Zero : request.Handle);
			return __result;
		}

		static LoadFailedWithTlsErrorsNativeDelegate LoadFailedWithTlsErrors_cb_delegate;
		static LoadFailedWithTlsErrorsNativeDelegate LoadFailedWithTlsErrorsVMCallback {
			get {
				if (LoadFailedWithTlsErrors_cb_delegate == null)
					LoadFailedWithTlsErrors_cb_delegate = new LoadFailedWithTlsErrorsNativeDelegate (LoadFailedWithTlsErrors_cb);
				return LoadFailedWithTlsErrors_cb_delegate;
			}
		}

		static void OverrideLoadFailedWithTlsErrors (GLib.GType gtype)
		{
			OverrideLoadFailedWithTlsErrors (gtype, LoadFailedWithTlsErrorsVMCallback);
		}

		static void OverrideLoadFailedWithTlsErrors (GLib.GType gtype, LoadFailedWithTlsErrorsNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("load_failed_with_tls_errors"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool LoadFailedWithTlsErrorsNativeDelegate (IntPtr inst, IntPtr failing_uri, IntPtr certificate, int errors);

		static bool LoadFailedWithTlsErrors_cb (IntPtr inst, IntPtr failing_uri, IntPtr certificate, int errors)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnLoadFailedWithTlsErrors (GLib.Marshaller.Utf8PtrToString (failing_uri), GLib.Object.GetObject(certificate) as GLib.TlsCertificate, (GLib.TlsCertificateFlags) errors);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideLoadFailedWithTlsErrors")]
		protected virtual bool OnLoadFailedWithTlsErrors (string failing_uri, GLib.TlsCertificate certificate, GLib.TlsCertificateFlags errors)
		{
			return InternalLoadFailedWithTlsErrors (failing_uri, certificate, errors);
		}

		private bool InternalLoadFailedWithTlsErrors (string failing_uri, GLib.TlsCertificate certificate, GLib.TlsCertificateFlags errors)
		{
			LoadFailedWithTlsErrorsNativeDelegate unmanaged = class_abi.BaseOverride<LoadFailedWithTlsErrorsNativeDelegate>(this.LookupGType(), "load_failed_with_tls_errors");
			if (unmanaged == null) return false;

			IntPtr native_failing_uri = GLib.Marshaller.StringToPtrGStrdup (failing_uri);
			bool __result = unmanaged (this.Handle, native_failing_uri, certificate == null ? IntPtr.Zero : certificate.Handle, (int) errors);
			GLib.Marshaller.Free (native_failing_uri);
			return __result;
		}

		static ShowNotificationNativeDelegate ShowNotification_cb_delegate;
		static ShowNotificationNativeDelegate ShowNotificationVMCallback {
			get {
				if (ShowNotification_cb_delegate == null)
					ShowNotification_cb_delegate = new ShowNotificationNativeDelegate (ShowNotification_cb);
				return ShowNotification_cb_delegate;
			}
		}

		static void OverrideShowNotification (GLib.GType gtype)
		{
			OverrideShowNotification (gtype, ShowNotificationVMCallback);
		}

		static void OverrideShowNotification (GLib.GType gtype, ShowNotificationNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("show_notification"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ShowNotificationNativeDelegate (IntPtr inst, IntPtr notification);

		static bool ShowNotification_cb (IntPtr inst, IntPtr notification)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnShowNotification (GLib.Object.GetObject(notification) as WebKit.Notification);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideShowNotification")]
		protected virtual bool OnShowNotification (WebKit.Notification notification)
		{
			return InternalShowNotification (notification);
		}

		private bool InternalShowNotification (WebKit.Notification notification)
		{
			ShowNotificationNativeDelegate unmanaged = class_abi.BaseOverride<ShowNotificationNativeDelegate>(this.LookupGType(), "show_notification");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, notification == null ? IntPtr.Zero : notification.Handle);
			return __result;
		}

		static RunColorChooserNativeDelegate RunColorChooser_cb_delegate;
		static RunColorChooserNativeDelegate RunColorChooserVMCallback {
			get {
				if (RunColorChooser_cb_delegate == null)
					RunColorChooser_cb_delegate = new RunColorChooserNativeDelegate (RunColorChooser_cb);
				return RunColorChooser_cb_delegate;
			}
		}

		static void OverrideRunColorChooser (GLib.GType gtype)
		{
			OverrideRunColorChooser (gtype, RunColorChooserVMCallback);
		}

		static void OverrideRunColorChooser (GLib.GType gtype, RunColorChooserNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("run_color_chooser"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool RunColorChooserNativeDelegate (IntPtr inst, IntPtr request);

		static bool RunColorChooser_cb (IntPtr inst, IntPtr request)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnRunColorChooser (GLib.Object.GetObject(request) as WebKit.ColorChooserRequest);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideRunColorChooser")]
		protected virtual bool OnRunColorChooser (WebKit.ColorChooserRequest request)
		{
			return InternalRunColorChooser (request);
		}

		private bool InternalRunColorChooser (WebKit.ColorChooserRequest request)
		{
			RunColorChooserNativeDelegate unmanaged = class_abi.BaseOverride<RunColorChooserNativeDelegate>(this.LookupGType(), "run_color_chooser");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, request == null ? IntPtr.Zero : request.Handle);
			return __result;
		}

		static ShowOptionMenuNativeDelegate ShowOptionMenu_cb_delegate;
		static ShowOptionMenuNativeDelegate ShowOptionMenuVMCallback {
			get {
				if (ShowOptionMenu_cb_delegate == null)
					ShowOptionMenu_cb_delegate = new ShowOptionMenuNativeDelegate (ShowOptionMenu_cb);
				return ShowOptionMenu_cb_delegate;
			}
		}

		static void OverrideShowOptionMenu (GLib.GType gtype)
		{
			OverrideShowOptionMenu (gtype, ShowOptionMenuVMCallback);
		}

		static void OverrideShowOptionMenu (GLib.GType gtype, ShowOptionMenuNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("show_option_menu"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ShowOptionMenuNativeDelegate (IntPtr inst, IntPtr _object, IntPtr p0, IntPtr p1);

		static bool ShowOptionMenu_cb (IntPtr inst, IntPtr _object, IntPtr p0, IntPtr p1)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnShowOptionMenu (GLib.Object.GetObject(_object) as WebKit.OptionMenu, Gdk.Event.GetEvent (p0), (Gdk.Rectangle) Marshal.PtrToStructure (p1, typeof (Gdk.Rectangle)));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideShowOptionMenu")]
		protected virtual bool OnShowOptionMenu (WebKit.OptionMenu _object, Gdk.Event p0, Gdk.Rectangle p1)
		{
			return InternalShowOptionMenu (_object, p0, p1);
		}

		private bool InternalShowOptionMenu (WebKit.OptionMenu _object, Gdk.Event p0, Gdk.Rectangle p1)
		{
			ShowOptionMenuNativeDelegate unmanaged = class_abi.BaseOverride<ShowOptionMenuNativeDelegate>(this.LookupGType(), "show_option_menu");
			if (unmanaged == null) return false;

			IntPtr native_p1 = GLib.Marshaller.StructureToPtrAlloc (p1);
			bool __result = unmanaged (this.Handle, _object == null ? IntPtr.Zero : _object.Handle, p0 == null ? IntPtr.Zero : p0.Handle, native_p1);
			Marshal.FreeHGlobal (native_p1);
			return __result;
		}

		static WebProcessTerminatedNativeDelegate WebProcessTerminated_cb_delegate;
		static WebProcessTerminatedNativeDelegate WebProcessTerminatedVMCallback {
			get {
				if (WebProcessTerminated_cb_delegate == null)
					WebProcessTerminated_cb_delegate = new WebProcessTerminatedNativeDelegate (WebProcessTerminated_cb);
				return WebProcessTerminated_cb_delegate;
			}
		}

		static void OverrideWebProcessTerminated (GLib.GType gtype)
		{
			OverrideWebProcessTerminated (gtype, WebProcessTerminatedVMCallback);
		}

		static void OverrideWebProcessTerminated (GLib.GType gtype, WebProcessTerminatedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("web_process_terminated"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void WebProcessTerminatedNativeDelegate (IntPtr inst, int reason);

		static void WebProcessTerminated_cb (IntPtr inst, int reason)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				__obj.OnWebProcessTerminated ((WebKit.WebProcessTerminationReason) reason);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideWebProcessTerminated")]
		protected virtual void OnWebProcessTerminated (WebKit.WebProcessTerminationReason reason)
		{
			InternalWebProcessTerminated (reason);
		}

		private void InternalWebProcessTerminated (WebKit.WebProcessTerminationReason reason)
		{
			WebProcessTerminatedNativeDelegate unmanaged = class_abi.BaseOverride<WebProcessTerminatedNativeDelegate>(this.LookupGType(), "web_process_terminated");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) reason);
		}

		static UserMessageReceivedNativeDelegate UserMessageReceived_cb_delegate;
		static UserMessageReceivedNativeDelegate UserMessageReceivedVMCallback {
			get {
				if (UserMessageReceived_cb_delegate == null)
					UserMessageReceived_cb_delegate = new UserMessageReceivedNativeDelegate (UserMessageReceived_cb);
				return UserMessageReceived_cb_delegate;
			}
		}

		static void OverrideUserMessageReceived (GLib.GType gtype)
		{
			OverrideUserMessageReceived (gtype, UserMessageReceivedVMCallback);
		}

		static void OverrideUserMessageReceived (GLib.GType gtype, UserMessageReceivedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("user_message_received"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool UserMessageReceivedNativeDelegate (IntPtr inst, IntPtr message);

		static bool UserMessageReceived_cb (IntPtr inst, IntPtr message)
		{
			try {
				WebView __obj = GLib.Object.GetObject (inst, false) as WebView;
				bool __result;
				__result = __obj.OnUserMessageReceived (GLib.Object.GetObject(message) as WebKit.UserMessage);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(WebKit.WebView), ConnectionMethod="OverrideUserMessageReceived")]
		protected virtual bool OnUserMessageReceived (WebKit.UserMessage message)
		{
			return InternalUserMessageReceived (message);
		}

		private bool InternalUserMessageReceived (WebKit.UserMessage message)
		{
			UserMessageReceivedNativeDelegate unmanaged = class_abi.BaseOverride<UserMessageReceivedNativeDelegate>(this.LookupGType(), "user_message_received");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, message == null ? IntPtr.Zero : message.Handle);
			return __result;
		}


		// 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("load_changed"
							, WebKit.WebViewBase.class_abi.Fields
							, (uint) sizeof( IntPtr ) // load_changed
							, null
							, "load_failed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("load_failed"
							, -1
							, (uint) sizeof( IntPtr ) // load_failed
							, "load_changed"
							, "create"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("create"
							, -1
							, (uint) sizeof( IntPtr ) // create
							, "load_failed"
							, "ready_to_show"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("ready_to_show"
							, -1
							, (uint) sizeof( IntPtr ) // ready_to_show
							, "create"
							, "run_as_modal"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("run_as_modal"
							, -1
							, (uint) sizeof( IntPtr ) // run_as_modal
							, "ready_to_show"
							, "close"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("close"
							, -1
							, (uint) sizeof( IntPtr ) // close
							, "run_as_modal"
							, "script_dialog"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("script_dialog"
							, -1
							, (uint) sizeof( IntPtr ) // script_dialog
							, "close"
							, "decide_policy"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("decide_policy"
							, -1
							, (uint) sizeof( IntPtr ) // decide_policy
							, "script_dialog"
							, "permission_request"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("permission_request"
							, -1
							, (uint) sizeof( IntPtr ) // permission_request
							, "decide_policy"
							, "mouse_target_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("mouse_target_changed"
							, -1
							, (uint) sizeof( IntPtr ) // mouse_target_changed
							, "permission_request"
							, "print"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("print"
							, -1
							, (uint) sizeof( IntPtr ) // print
							, "mouse_target_changed"
							, "resource_load_started"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("resource_load_started"
							, -1
							, (uint) sizeof( IntPtr ) // resource_load_started
							, "print"
							, "enter_fullscreen"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("enter_fullscreen"
							, -1
							, (uint) sizeof( IntPtr ) // enter_fullscreen
							, "resource_load_started"
							, "leave_fullscreen"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("leave_fullscreen"
							, -1
							, (uint) sizeof( IntPtr ) // leave_fullscreen
							, "enter_fullscreen"
							, "run_file_chooser"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("run_file_chooser"
							, -1
							, (uint) sizeof( IntPtr ) // run_file_chooser
							, "leave_fullscreen"
							, "context_menu"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("context_menu"
							, -1
							, (uint) sizeof( IntPtr ) // context_menu
							, "run_file_chooser"
							, "context_menu_dismissed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("context_menu_dismissed"
							, -1
							, (uint) sizeof( IntPtr ) // context_menu_dismissed
							, "context_menu"
							, "submit_form"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("submit_form"
							, -1
							, (uint) sizeof( IntPtr ) // submit_form
							, "context_menu_dismissed"
							, "insecure_content_detected"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("insecure_content_detected"
							, -1
							, (uint) sizeof( IntPtr ) // insecure_content_detected
							, "submit_form"
							, "web_process_crashed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("web_process_crashed"
							, -1
							, (uint) sizeof( IntPtr ) // web_process_crashed
							, "insecure_content_detected"
							, "authenticate"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("authenticate"
							, -1
							, (uint) sizeof( IntPtr ) // authenticate
							, "web_process_crashed"
							, "load_failed_with_tls_errors"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("load_failed_with_tls_errors"
							, -1
							, (uint) sizeof( IntPtr ) // load_failed_with_tls_errors
							, "authenticate"
							, "show_notification"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("show_notification"
							, -1
							, (uint) sizeof( IntPtr ) // show_notification
							, "load_failed_with_tls_errors"
							, "run_color_chooser"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("run_color_chooser"
							, -1
							, (uint) sizeof( IntPtr ) // run_color_chooser
							, "show_notification"
							, "show_option_menu"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("show_option_menu"
							, -1
							, (uint) sizeof( IntPtr ) // show_option_menu
							, "run_color_chooser"
							, "web_process_terminated"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("web_process_terminated"
							, -1
							, (uint) sizeof( IntPtr ) // web_process_terminated
							, "show_option_menu"
							, "user_message_received"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("user_message_received"
							, -1
							, (uint) sizeof( IntPtr ) // user_message_received
							, "web_process_terminated"
							, "_webkit_reserved0"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_webkit_reserved0"
							, -1
							, (uint) sizeof( IntPtr ) // _webkit_reserved0
							, "user_message_received"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_can_execute_editing_command(IntPtr raw, IntPtr command, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_can_execute_editing_command webkit_web_view_can_execute_editing_command = FuncLoader.LoadFunction<d_webkit_web_view_can_execute_editing_command>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_can_execute_editing_command"));

		public void CanExecuteEditingCommand(string command, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			IntPtr native_command = GLib.Marshaller.StringToPtrGStrdup (command);
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_can_execute_editing_command(Handle, native_command, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
			GLib.Marshaller.Free (native_command);
		}

		public void CanExecuteEditingCommand(string command) {
			CanExecuteEditingCommand (command, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_web_view_can_execute_editing_command_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_can_execute_editing_command_finish webkit_web_view_can_execute_editing_command_finish = FuncLoader.LoadFunction<d_webkit_web_view_can_execute_editing_command_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_can_execute_editing_command_finish"));

		public unsafe bool CanExecuteEditingCommandFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			bool raw_ret = webkit_web_view_can_execute_editing_command_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			bool ret = raw_ret;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

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

		public bool CanGoBack() {
			bool raw_ret = webkit_web_view_can_go_back(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool CanGoForward() {
			bool raw_ret = webkit_web_view_can_go_forward(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool CanShowMimeType(string mime_type) {
			IntPtr native_mime_type = GLib.Marshaller.StringToPtrGStrdup (mime_type);
			bool raw_ret = webkit_web_view_can_show_mime_type(Handle, native_mime_type);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_mime_type);
			return ret;
		}

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

		public WebKit.Download DownloadUri(string uri) {
			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
			IntPtr raw_ret = webkit_web_view_download_uri(Handle, native_uri);
			WebKit.Download ret = GLib.Object.GetObject(raw_ret, true) as WebKit.Download;
			GLib.Marshaller.Free (native_uri);
			return ret;
		}

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

		public void ExecuteEditingCommand(string command) {
			IntPtr native_command = GLib.Marshaller.StringToPtrGStrdup (command);
			webkit_web_view_execute_editing_command(Handle, native_command);
			GLib.Marshaller.Free (native_command);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_execute_editing_command_with_argument(IntPtr raw, IntPtr command, IntPtr argument);
		static d_webkit_web_view_execute_editing_command_with_argument webkit_web_view_execute_editing_command_with_argument = FuncLoader.LoadFunction<d_webkit_web_view_execute_editing_command_with_argument>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_execute_editing_command_with_argument"));

		public void ExecuteEditingCommandWithArgument(string command, string argument) {
			IntPtr native_command = GLib.Marshaller.StringToPtrGStrdup (command);
			IntPtr native_argument = GLib.Marshaller.StringToPtrGStrdup (argument);
			webkit_web_view_execute_editing_command_with_argument(Handle, native_command, native_argument);
			GLib.Marshaller.Free (native_command);
			GLib.Marshaller.Free (native_argument);
		}

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

		public WebKit.BackForwardList BackForwardList { 
			get {
				IntPtr raw_ret = webkit_web_view_get_back_forward_list(Handle);
				WebKit.BackForwardList ret = GLib.Object.GetObject(raw_ret) as WebKit.BackForwardList;
				return ret;
			}
		}

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

		public Gdk.RGBA BackgroundColor { 
			get {
				Gdk.RGBA rgba;
				IntPtr native_rgba = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.RGBA>());
				webkit_web_view_get_background_color(Handle, native_rgba);
				rgba = Gdk.RGBA.New (native_rgba);
				Marshal.FreeHGlobal (native_rgba);
				return rgba;
			}
		}

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

		public WebKit.WebContext Context { 
			get {
				IntPtr raw_ret = webkit_web_view_get_context(Handle);
				WebKit.WebContext ret = GLib.Object.GetObject(raw_ret) as WebKit.WebContext;
				return ret;
			}
		}

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

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

		public string CustomCharset { 
			get {
				IntPtr raw_ret = webkit_web_view_get_custom_charset(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				webkit_web_view_set_custom_charset(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		public WebKit.EditorState EditorState { 
			get {
				IntPtr raw_ret = webkit_web_view_get_editor_state(Handle);
				WebKit.EditorState ret = GLib.Object.GetObject(raw_ret) as WebKit.EditorState;
				return ret;
			}
		}

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

		public WebKit.FindController FindController { 
			get {
				IntPtr raw_ret = webkit_web_view_get_find_controller(Handle);
				WebKit.FindController ret = GLib.Object.GetObject(raw_ret) as WebKit.FindController;
				return ret;
			}
		}

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

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

		public WebKit.InputMethodContext InputMethodContext { 
			get {
				IntPtr raw_ret = webkit_web_view_get_input_method_context(Handle);
				WebKit.InputMethodContext ret = GLib.Object.GetObject(raw_ret) as WebKit.InputMethodContext;
				return ret;
			}
			set {
				webkit_web_view_set_input_method_context(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public WebKit.WebInspector Inspector { 
			get {
				IntPtr raw_ret = webkit_web_view_get_inspector(Handle);
				WebKit.WebInspector ret = GLib.Object.GetObject(raw_ret) as WebKit.WebInspector;
				return ret;
			}
		}

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

		public WebKit.WebResource MainResource { 
			get {
				IntPtr raw_ret = webkit_web_view_get_main_resource(Handle);
				WebKit.WebResource ret = GLib.Object.GetObject(raw_ret) as WebKit.WebResource;
				return ret;
			}
		}

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

		public WebKit.WebViewSessionState SessionState { 
			get {
				IntPtr raw_ret = webkit_web_view_get_session_state(Handle);
				WebKit.WebViewSessionState ret = WebKit.WebViewSessionState.New (raw_ret);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_get_snapshot(IntPtr raw, int region, int options, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_get_snapshot webkit_web_view_get_snapshot = FuncLoader.LoadFunction<d_webkit_web_view_get_snapshot>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_get_snapshot"));

		public void GetSnapshot(WebKit.SnapshotRegion region, WebKit.SnapshotOptions options, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_get_snapshot(Handle, (int) region, (int) options, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
		}

		public void GetSnapshot(WebKit.SnapshotRegion region, WebKit.SnapshotOptions options) {
			GetSnapshot (region, options, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_web_view_get_snapshot_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_get_snapshot_finish webkit_web_view_get_snapshot_finish = FuncLoader.LoadFunction<d_webkit_web_view_get_snapshot_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_get_snapshot_finish"));

		public unsafe Cairo.Surface GetSnapshotFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = webkit_web_view_get_snapshot_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			Cairo.Surface ret = Cairo.Surface.Lookup (raw_ret, true);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_web_view_get_tls_info(IntPtr raw, out IntPtr certificate, out int errors);
		static d_webkit_web_view_get_tls_info webkit_web_view_get_tls_info = FuncLoader.LoadFunction<d_webkit_web_view_get_tls_info>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_get_tls_info"));

		public bool GetTlsInfo(out GLib.TlsCertificate certificate, out GLib.TlsCertificateFlags errors) {
			IntPtr native_certificate;
			int native_errors;
			bool raw_ret = webkit_web_view_get_tls_info(Handle, out native_certificate, out native_errors);
			bool ret = raw_ret;
			certificate = GLib.Object.GetObject(native_certificate) as GLib.TlsCertificate;
			errors = (GLib.TlsCertificateFlags) native_errors;
			return ret;
		}

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

		public WebKit.WebsiteDataManager WebsiteDataManager { 
			get {
				IntPtr raw_ret = webkit_web_view_get_website_data_manager(Handle);
				WebKit.WebsiteDataManager ret = GLib.Object.GetObject(raw_ret) as WebKit.WebsiteDataManager;
				return ret;
			}
		}

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

		public WebKit.WindowProperties WindowProperties { 
			get {
				IntPtr raw_ret = webkit_web_view_get_window_properties(Handle);
				WebKit.WindowProperties ret = GLib.Object.GetObject(raw_ret) as WebKit.WindowProperties;
				return ret;
			}
		}

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

		public void GoBack() {
			webkit_web_view_go_back(Handle);
		}

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

		public void GoForward() {
			webkit_web_view_go_forward(Handle);
		}

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

		public void GoToBackForwardListItem(WebKit.BackForwardListItem list_item) {
			webkit_web_view_go_to_back_forward_list_item(Handle, list_item == null ? IntPtr.Zero : list_item.Handle);
		}

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

		public bool IsControlledByAutomation { 
			get {
				bool raw_ret = webkit_web_view_is_controlled_by_automation(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsEditable { 
			get {
				bool raw_ret = webkit_web_view_is_editable(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsEphemeral { 
			get {
				bool raw_ret = webkit_web_view_is_ephemeral(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsLoading { 
			get {
				bool raw_ret = webkit_web_view_is_loading(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsPlayingAudio { 
			get {
				bool raw_ret = webkit_web_view_is_playing_audio(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_load_alternate_html(IntPtr raw, IntPtr content, IntPtr content_uri, IntPtr base_uri);
		static d_webkit_web_view_load_alternate_html webkit_web_view_load_alternate_html = FuncLoader.LoadFunction<d_webkit_web_view_load_alternate_html>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_load_alternate_html"));

		public void LoadAlternateHtml(string content, string content_uri, string base_uri) {
			IntPtr native_content = GLib.Marshaller.StringToPtrGStrdup (content);
			IntPtr native_content_uri = GLib.Marshaller.StringToPtrGStrdup (content_uri);
			IntPtr native_base_uri = GLib.Marshaller.StringToPtrGStrdup (base_uri);
			webkit_web_view_load_alternate_html(Handle, native_content, native_content_uri, native_base_uri);
			GLib.Marshaller.Free (native_content);
			GLib.Marshaller.Free (native_content_uri);
			GLib.Marshaller.Free (native_base_uri);
		}

		public void LoadAlternateHtml(string content, string content_uri) {
			LoadAlternateHtml (content, content_uri, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_load_bytes(IntPtr raw, IntPtr bytes, IntPtr mime_type, IntPtr encoding, IntPtr base_uri);
		static d_webkit_web_view_load_bytes webkit_web_view_load_bytes = FuncLoader.LoadFunction<d_webkit_web_view_load_bytes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_load_bytes"));

		public void LoadBytes(GLib.Bytes bytes, string mime_type, string encoding, string base_uri) {
			IntPtr native_mime_type = GLib.Marshaller.StringToPtrGStrdup (mime_type);
			IntPtr native_encoding = GLib.Marshaller.StringToPtrGStrdup (encoding);
			IntPtr native_base_uri = GLib.Marshaller.StringToPtrGStrdup (base_uri);
			webkit_web_view_load_bytes(Handle, bytes == null ? IntPtr.Zero : bytes.Handle, native_mime_type, native_encoding, native_base_uri);
			GLib.Marshaller.Free (native_mime_type);
			GLib.Marshaller.Free (native_encoding);
			GLib.Marshaller.Free (native_base_uri);
		}

		public void LoadBytes(GLib.Bytes bytes) {
			LoadBytes (bytes, null, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_load_html(IntPtr raw, IntPtr content, IntPtr base_uri);
		static d_webkit_web_view_load_html webkit_web_view_load_html = FuncLoader.LoadFunction<d_webkit_web_view_load_html>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_load_html"));

		public void LoadHtml(string content, string base_uri) {
			IntPtr native_content = GLib.Marshaller.StringToPtrGStrdup (content);
			IntPtr native_base_uri = GLib.Marshaller.StringToPtrGStrdup (base_uri);
			webkit_web_view_load_html(Handle, native_content, native_base_uri);
			GLib.Marshaller.Free (native_content);
			GLib.Marshaller.Free (native_base_uri);
		}

		public void LoadHtml(string content) {
			LoadHtml (content, null);
		}

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

		public void LoadPlainText(string plain_text) {
			IntPtr native_plain_text = GLib.Marshaller.StringToPtrGStrdup (plain_text);
			webkit_web_view_load_plain_text(Handle, native_plain_text);
			GLib.Marshaller.Free (native_plain_text);
		}

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

		public void LoadRequest(WebKit.URIRequest request) {
			webkit_web_view_load_request(Handle, request == null ? IntPtr.Zero : request.Handle);
		}

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

		public void LoadUri(string uri) {
			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
			webkit_web_view_load_uri(Handle, native_uri);
			GLib.Marshaller.Free (native_uri);
		}

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

		public void Reload() {
			webkit_web_view_reload(Handle);
		}

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

		public void ReloadBypassCache() {
			webkit_web_view_reload_bypass_cache(Handle);
		}

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

		public void RestoreSessionState(WebKit.WebViewSessionState state) {
			IntPtr native_state = GLib.Marshaller.StructureToPtrAlloc (state);
			webkit_web_view_restore_session_state(Handle, native_state);
			Marshal.FreeHGlobal (native_state);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_run_javascript(IntPtr raw, IntPtr script, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_run_javascript webkit_web_view_run_javascript = FuncLoader.LoadFunction<d_webkit_web_view_run_javascript>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_run_javascript"));

		public void RunJavascript(string script, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			IntPtr native_script = GLib.Marshaller.StringToPtrGStrdup (script);
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_run_javascript(Handle, native_script, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
			GLib.Marshaller.Free (native_script);
		}

		public void RunJavascript(string script) {
			RunJavascript (script, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_web_view_run_javascript_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_run_javascript_finish webkit_web_view_run_javascript_finish = FuncLoader.LoadFunction<d_webkit_web_view_run_javascript_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_run_javascript_finish"));

		public unsafe WebKit.JavascriptResult RunJavascriptFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = webkit_web_view_run_javascript_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			WebKit.JavascriptResult ret = raw_ret == IntPtr.Zero ? null : (WebKit.JavascriptResult) GLib.Opaque.GetOpaque (raw_ret, typeof (WebKit.JavascriptResult), true);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_run_javascript_from_gresource(IntPtr raw, IntPtr resource, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_run_javascript_from_gresource webkit_web_view_run_javascript_from_gresource = FuncLoader.LoadFunction<d_webkit_web_view_run_javascript_from_gresource>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_run_javascript_from_gresource"));

		public void RunJavascriptFromGresource(string resource, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			IntPtr native_resource = GLib.Marshaller.StringToPtrGStrdup (resource);
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_run_javascript_from_gresource(Handle, native_resource, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
			GLib.Marshaller.Free (native_resource);
		}

		public void RunJavascriptFromGresource(string resource) {
			RunJavascriptFromGresource (resource, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_web_view_run_javascript_from_gresource_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_run_javascript_from_gresource_finish webkit_web_view_run_javascript_from_gresource_finish = FuncLoader.LoadFunction<d_webkit_web_view_run_javascript_from_gresource_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_run_javascript_from_gresource_finish"));

		public unsafe WebKit.JavascriptResult RunJavascriptFromGresourceFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = webkit_web_view_run_javascript_from_gresource_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			WebKit.JavascriptResult ret = raw_ret == IntPtr.Zero ? null : (WebKit.JavascriptResult) GLib.Opaque.GetOpaque (raw_ret, typeof (WebKit.JavascriptResult), true);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_run_javascript_in_world(IntPtr raw, IntPtr script, IntPtr world_name, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_run_javascript_in_world webkit_web_view_run_javascript_in_world = FuncLoader.LoadFunction<d_webkit_web_view_run_javascript_in_world>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_run_javascript_in_world"));

		public void RunJavascriptInWorld(string script, string world_name, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			IntPtr native_script = GLib.Marshaller.StringToPtrGStrdup (script);
			IntPtr native_world_name = GLib.Marshaller.StringToPtrGStrdup (world_name);
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_run_javascript_in_world(Handle, native_script, native_world_name, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
			GLib.Marshaller.Free (native_script);
			GLib.Marshaller.Free (native_world_name);
		}

		public void RunJavascriptInWorld(string script, string world_name) {
			RunJavascriptInWorld (script, world_name, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_web_view_run_javascript_in_world_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_run_javascript_in_world_finish webkit_web_view_run_javascript_in_world_finish = FuncLoader.LoadFunction<d_webkit_web_view_run_javascript_in_world_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_run_javascript_in_world_finish"));

		public unsafe WebKit.JavascriptResult RunJavascriptInWorldFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = webkit_web_view_run_javascript_in_world_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			WebKit.JavascriptResult ret = raw_ret == IntPtr.Zero ? null : (WebKit.JavascriptResult) GLib.Opaque.GetOpaque (raw_ret, typeof (WebKit.JavascriptResult), true);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_save(IntPtr raw, int save_mode, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_save webkit_web_view_save = FuncLoader.LoadFunction<d_webkit_web_view_save>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_save"));

		public void Save(WebKit.SaveMode save_mode, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_save(Handle, (int) save_mode, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
		}

		public void Save(WebKit.SaveMode save_mode) {
			Save (save_mode, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_web_view_save_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_save_finish webkit_web_view_save_finish = FuncLoader.LoadFunction<d_webkit_web_view_save_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_save_finish"));

		public unsafe GLib.InputStream SaveFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = webkit_web_view_save_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			GLib.InputStream ret = GLib.Object.GetObject(raw_ret, true) as GLib.InputStream;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_save_to_file(IntPtr raw, IntPtr file, int save_mode, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_save_to_file webkit_web_view_save_to_file = FuncLoader.LoadFunction<d_webkit_web_view_save_to_file>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_save_to_file"));

		public void SaveToFile(GLib.IFile file, WebKit.SaveMode save_mode, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_save_to_file(Handle, file == null ? IntPtr.Zero : ((file is GLib.Object) ? (file as GLib.Object).Handle : (file as GLib.FileAdapter).Handle), (int) save_mode, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
		}

		public void SaveToFile(GLib.IFile file, WebKit.SaveMode save_mode) {
			SaveToFile (file, save_mode, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_webkit_web_view_save_to_file_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_save_to_file_finish webkit_web_view_save_to_file_finish = FuncLoader.LoadFunction<d_webkit_web_view_save_to_file_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_save_to_file_finish"));

		public unsafe bool SaveToFileFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			bool raw_ret = webkit_web_view_save_to_file_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			bool ret = raw_ret;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_webkit_web_view_send_message_to_page(IntPtr raw, IntPtr message, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
		static d_webkit_web_view_send_message_to_page webkit_web_view_send_message_to_page = FuncLoader.LoadFunction<d_webkit_web_view_send_message_to_page>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_send_message_to_page"));

		public void SendMessageToPage(WebKit.UserMessage message, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
			cb_wrapper.PersistUntilCalled ();
			webkit_web_view_send_message_to_page(Handle, message == null ? IntPtr.Zero : message.Handle, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
		}

		public void SendMessageToPage(WebKit.UserMessage message) {
			SendMessageToPage (message, null, null);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_webkit_web_view_send_message_to_page_finish(IntPtr raw, IntPtr _result, out IntPtr error);
		static d_webkit_web_view_send_message_to_page_finish webkit_web_view_send_message_to_page_finish = FuncLoader.LoadFunction<d_webkit_web_view_send_message_to_page_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Webkit), "webkit_web_view_send_message_to_page_finish"));

		public unsafe WebKit.UserMessage SendMessageToPageFinish(GLib.IAsyncResult _result) {
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = webkit_web_view_send_message_to_page_finish(Handle, _result == null ? IntPtr.Zero : ((_result is GLib.Object) ? (_result as GLib.Object).Handle : (_result as GLib.AsyncResultAdapter).Handle), out error);
			WebKit.UserMessage ret = GLib.Object.GetObject(raw_ret, true) as WebKit.UserMessage;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

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

		public void SetBackgroundColor(Gdk.RGBA rgba) {
			IntPtr native_rgba = GLib.Marshaller.StructureToPtrAlloc (rgba);
			webkit_web_view_set_background_color(Handle, native_rgba);
			Marshal.FreeHGlobal (native_rgba);
		}

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

		public void StopLoading() {
			webkit_web_view_stop_loading(Handle);
		}

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

		public void TryClose() {
			webkit_web_view_try_close(Handle);
		}


		static WebView ()
		{
			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"
							, WebKit.WebViewBase.abi_info.Fields
							, (uint) sizeof( IntPtr ) // priv
							, null
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}