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

namespace Gtk {

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

#region Autogenerated code
	[GLib.TypeInitializer (typeof (Gtk.Widget), "ClassInit")]
	public partial class Widget : GLib.InitiallyUnowned, Atk.IImplementor {

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

		protected Widget() : base(IntPtr.Zero)
		{
			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_name(IntPtr raw, IntPtr name);
		static d_gtk_widget_set_name gtk_widget_set_name = FuncLoader.LoadFunction<d_gtk_widget_set_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_name"));

		[GLib.Property ("name")]
		public string Name {
			get  {
				IntPtr raw_ret = gtk_widget_get_name(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_widget_set_name(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_parent(IntPtr raw, IntPtr parent);
		static d_gtk_widget_set_parent gtk_widget_set_parent = FuncLoader.LoadFunction<d_gtk_widget_set_parent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_parent"));

		[GLib.Property ("parent")]
		public Gtk.Widget Parent {
			get  {
				IntPtr raw_ret = gtk_widget_get_parent(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
			set  {
				gtk_widget_set_parent(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[GLib.Property ("width-request")]
		public int WidthRequest {
			get {
				GLib.Value val = GetProperty ("width-request");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("width-request", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("height-request")]
		public int HeightRequest {
			get {
				GLib.Value val = GetProperty ("height-request");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("height-request", val);
				val.Dispose ();
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_visible(IntPtr raw, bool visible);
		static d_gtk_widget_set_visible gtk_widget_set_visible = FuncLoader.LoadFunction<d_gtk_widget_set_visible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_visible"));

		[GLib.Property ("visible")]
		public bool Visible {
			get  {
				bool raw_ret = gtk_widget_get_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_visible(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_sensitive(IntPtr raw, bool sensitive);
		static d_gtk_widget_set_sensitive gtk_widget_set_sensitive = FuncLoader.LoadFunction<d_gtk_widget_set_sensitive>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_sensitive"));

		[GLib.Property ("sensitive")]
		public bool Sensitive {
			get  {
				bool raw_ret = gtk_widget_get_sensitive(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_sensitive(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_app_paintable(IntPtr raw, bool app_paintable);
		static d_gtk_widget_set_app_paintable gtk_widget_set_app_paintable = FuncLoader.LoadFunction<d_gtk_widget_set_app_paintable>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_app_paintable"));

		[GLib.Property ("app-paintable")]
		public bool AppPaintable {
			get  {
				bool raw_ret = gtk_widget_get_app_paintable(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_app_paintable(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_can_focus(IntPtr raw, bool can_focus);
		static d_gtk_widget_set_can_focus gtk_widget_set_can_focus = FuncLoader.LoadFunction<d_gtk_widget_set_can_focus>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_can_focus"));

		[GLib.Property ("can-focus")]
		public bool CanFocus {
			get  {
				bool raw_ret = gtk_widget_get_can_focus(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_can_focus(Handle, value);
			}
		}

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

		[GLib.Property ("has-focus")]
		public bool HasFocus {
			get  {
				bool raw_ret = gtk_widget_has_focus(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("has-focus", val);
				val.Dispose ();
			}
		}

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

		[GLib.Property ("is-focus")]
		public bool IsFocus {
			get  {
				bool raw_ret = gtk_widget_is_focus(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("is-focus", val);
				val.Dispose ();
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_focus_on_click(IntPtr raw, bool focus_on_click);
		static d_gtk_widget_set_focus_on_click gtk_widget_set_focus_on_click = FuncLoader.LoadFunction<d_gtk_widget_set_focus_on_click>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_focus_on_click"));

		[GLib.Property ("focus-on-click")]
		public bool FocusOnClick {
			get  {
				bool raw_ret = gtk_widget_get_focus_on_click(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_focus_on_click(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_can_default(IntPtr raw, bool can_default);
		static d_gtk_widget_set_can_default gtk_widget_set_can_default = FuncLoader.LoadFunction<d_gtk_widget_set_can_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_can_default"));

		[GLib.Property ("can-default")]
		public bool CanDefault {
			get  {
				bool raw_ret = gtk_widget_get_can_default(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_can_default(Handle, value);
			}
		}

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

		[GLib.Property ("has-default")]
		public bool HasDefault {
			get  {
				bool raw_ret = gtk_widget_has_default(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("has-default", val);
				val.Dispose ();
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_receives_default(IntPtr raw, bool receives_default);
		static d_gtk_widget_set_receives_default gtk_widget_set_receives_default = FuncLoader.LoadFunction<d_gtk_widget_set_receives_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_receives_default"));

		[GLib.Property ("receives-default")]
		public bool ReceivesDefault {
			get  {
				bool raw_ret = gtk_widget_get_receives_default(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_receives_default(Handle, value);
			}
		}

		[GLib.Property ("composite-child")]
		public bool CompositeChild {
			get {
				GLib.Value val = GetProperty ("composite-child");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_style(IntPtr raw, IntPtr style);
		static d_gtk_widget_set_style gtk_widget_set_style = FuncLoader.LoadFunction<d_gtk_widget_set_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_style"));

		[Obsolete]
		[GLib.Property ("style")]
		public Gtk.Style Style {
			get  {
				IntPtr raw_ret = gtk_widget_get_style(Handle);
				Gtk.Style ret = GLib.Object.GetObject(raw_ret) as Gtk.Style;
				return ret;
			}
			set  {
				gtk_widget_set_style(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_events(IntPtr raw, int events);
		static d_gtk_widget_set_events gtk_widget_set_events = FuncLoader.LoadFunction<d_gtk_widget_set_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_events"));

		[GLib.Property ("events")]
		public Gdk.EventMask Events {
			get  {
				int raw_ret = gtk_widget_get_events(Handle);
				Gdk.EventMask ret = (Gdk.EventMask) raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_events(Handle, (int) value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_no_show_all(IntPtr raw, bool no_show_all);
		static d_gtk_widget_set_no_show_all gtk_widget_set_no_show_all = FuncLoader.LoadFunction<d_gtk_widget_set_no_show_all>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_no_show_all"));

		[GLib.Property ("no-show-all")]
		public bool NoShowAll {
			get  {
				bool raw_ret = gtk_widget_get_no_show_all(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_no_show_all(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_has_tooltip(IntPtr raw, bool has_tooltip);
		static d_gtk_widget_set_has_tooltip gtk_widget_set_has_tooltip = FuncLoader.LoadFunction<d_gtk_widget_set_has_tooltip>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_has_tooltip"));

		[GLib.Property ("has-tooltip")]
		public bool HasTooltip {
			get  {
				bool raw_ret = gtk_widget_get_has_tooltip(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_has_tooltip(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_tooltip_text(IntPtr raw, IntPtr text);
		static d_gtk_widget_set_tooltip_text gtk_widget_set_tooltip_text = FuncLoader.LoadFunction<d_gtk_widget_set_tooltip_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_tooltip_text"));

		[GLib.Property ("tooltip-text")]
		public string TooltipText {
			get  {
				IntPtr raw_ret = gtk_widget_get_tooltip_text(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_widget_set_tooltip_text(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_tooltip_markup(IntPtr raw, IntPtr markup);
		static d_gtk_widget_set_tooltip_markup gtk_widget_set_tooltip_markup = FuncLoader.LoadFunction<d_gtk_widget_set_tooltip_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_tooltip_markup"));

		[GLib.Property ("tooltip-markup")]
		public string TooltipMarkup {
			get  {
				IntPtr raw_ret = gtk_widget_get_tooltip_markup(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_widget_set_tooltip_markup(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_window(IntPtr raw, IntPtr window);
		static d_gtk_widget_set_window gtk_widget_set_window = FuncLoader.LoadFunction<d_gtk_widget_set_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_window"));

		[GLib.Property ("window")]
		public Gdk.Window Window {
			get  {
				IntPtr raw_ret = gtk_widget_get_window(Handle);
				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
				return ret;
			}
			set  {
				gtk_widget_set_window(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_double_buffered(IntPtr raw, bool double_buffered);
		static d_gtk_widget_set_double_buffered gtk_widget_set_double_buffered = FuncLoader.LoadFunction<d_gtk_widget_set_double_buffered>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_double_buffered"));

		[Obsolete]
		[GLib.Property ("double-buffered")]
		public bool DoubleBuffered {
			get  {
				bool raw_ret = gtk_widget_get_double_buffered(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_double_buffered(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_halign(IntPtr raw, int align);
		static d_gtk_widget_set_halign gtk_widget_set_halign = FuncLoader.LoadFunction<d_gtk_widget_set_halign>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_halign"));

		[GLib.Property ("halign")]
		public Gtk.Align Halign {
			get  {
				int raw_ret = gtk_widget_get_halign(Handle);
				Gtk.Align ret = (Gtk.Align) raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_halign(Handle, (int) value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_valign(IntPtr raw, int align);
		static d_gtk_widget_set_valign gtk_widget_set_valign = FuncLoader.LoadFunction<d_gtk_widget_set_valign>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_valign"));

		[GLib.Property ("valign")]
		public Gtk.Align Valign {
			get  {
				int raw_ret = gtk_widget_get_valign(Handle);
				Gtk.Align ret = (Gtk.Align) raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_valign(Handle, (int) value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_margin_left(IntPtr raw, int margin);
		static d_gtk_widget_set_margin_left gtk_widget_set_margin_left = FuncLoader.LoadFunction<d_gtk_widget_set_margin_left>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_margin_left"));

		[Obsolete]
		[GLib.Property ("margin-left")]
		public int MarginLeft {
			get  {
				int raw_ret = gtk_widget_get_margin_left(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_margin_left(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_margin_right(IntPtr raw, int margin);
		static d_gtk_widget_set_margin_right gtk_widget_set_margin_right = FuncLoader.LoadFunction<d_gtk_widget_set_margin_right>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_margin_right"));

		[Obsolete]
		[GLib.Property ("margin-right")]
		public int MarginRight {
			get  {
				int raw_ret = gtk_widget_get_margin_right(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_margin_right(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_margin_start(IntPtr raw, int margin);
		static d_gtk_widget_set_margin_start gtk_widget_set_margin_start = FuncLoader.LoadFunction<d_gtk_widget_set_margin_start>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_margin_start"));

		[GLib.Property ("margin-start")]
		public int MarginStart {
			get  {
				int raw_ret = gtk_widget_get_margin_start(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_margin_start(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_margin_end(IntPtr raw, int margin);
		static d_gtk_widget_set_margin_end gtk_widget_set_margin_end = FuncLoader.LoadFunction<d_gtk_widget_set_margin_end>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_margin_end"));

		[GLib.Property ("margin-end")]
		public int MarginEnd {
			get  {
				int raw_ret = gtk_widget_get_margin_end(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_margin_end(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_margin_top(IntPtr raw, int margin);
		static d_gtk_widget_set_margin_top gtk_widget_set_margin_top = FuncLoader.LoadFunction<d_gtk_widget_set_margin_top>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_margin_top"));

		[GLib.Property ("margin-top")]
		public int MarginTop {
			get  {
				int raw_ret = gtk_widget_get_margin_top(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_margin_top(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_margin_bottom(IntPtr raw, int margin);
		static d_gtk_widget_set_margin_bottom gtk_widget_set_margin_bottom = FuncLoader.LoadFunction<d_gtk_widget_set_margin_bottom>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_margin_bottom"));

		[GLib.Property ("margin-bottom")]
		public int MarginBottom {
			get  {
				int raw_ret = gtk_widget_get_margin_bottom(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_margin_bottom(Handle, value);
			}
		}

		[GLib.Property ("margin")]
		public int Margin {
			get {
				GLib.Value val = GetProperty ("margin");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("margin", val);
				val.Dispose ();
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_hexpand(IntPtr raw, bool expand);
		static d_gtk_widget_set_hexpand gtk_widget_set_hexpand = FuncLoader.LoadFunction<d_gtk_widget_set_hexpand>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_hexpand"));

		[GLib.Property ("hexpand")]
		public bool Hexpand {
			get  {
				bool raw_ret = gtk_widget_get_hexpand(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_hexpand(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_hexpand_set(IntPtr raw, bool set);
		static d_gtk_widget_set_hexpand_set gtk_widget_set_hexpand_set = FuncLoader.LoadFunction<d_gtk_widget_set_hexpand_set>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_hexpand_set"));

		[GLib.Property ("hexpand-set")]
		public bool HexpandSet {
			get  {
				bool raw_ret = gtk_widget_get_hexpand_set(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_hexpand_set(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_vexpand(IntPtr raw, bool expand);
		static d_gtk_widget_set_vexpand gtk_widget_set_vexpand = FuncLoader.LoadFunction<d_gtk_widget_set_vexpand>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_vexpand"));

		[GLib.Property ("vexpand")]
		public bool Vexpand {
			get  {
				bool raw_ret = gtk_widget_get_vexpand(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_vexpand(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_vexpand_set(IntPtr raw, bool set);
		static d_gtk_widget_set_vexpand_set gtk_widget_set_vexpand_set = FuncLoader.LoadFunction<d_gtk_widget_set_vexpand_set>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_vexpand_set"));

		[GLib.Property ("vexpand-set")]
		public bool VexpandSet {
			get  {
				bool raw_ret = gtk_widget_get_vexpand_set(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_vexpand_set(Handle, value);
			}
		}

		[GLib.Property ("expand")]
		public bool Expand {
			get {
				GLib.Value val = GetProperty ("expand");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("expand", val);
				val.Dispose ();
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_opacity(IntPtr raw, double opacity);
		static d_gtk_widget_set_opacity gtk_widget_set_opacity = FuncLoader.LoadFunction<d_gtk_widget_set_opacity>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_opacity"));

		[GLib.Property ("opacity")]
		public double Opacity {
			get  {
				double raw_ret = gtk_widget_get_opacity(Handle);
				double ret = raw_ret;
				return ret;
			}
			set  {
				gtk_widget_set_opacity(Handle, value);
			}
		}

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

		[GLib.Property ("scale-factor")]
		public int ScaleFactor {
			get  {
				int raw_ret = gtk_widget_get_scale_factor(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

		[Obsolete]
		public bool InteriorFocus {
			get {
				var val = (bool)StyleGetProperty("interior-focus");
				return val;
			}
		}

		[Obsolete]
		public int FocusLineWidth {
			get {
				var val = (int)StyleGetProperty("focus-line-width");
				return val;
			}
		}

		[Obsolete]
		public string FocusLinePattern {
			get {
				var val = (string)StyleGetProperty("focus-line-pattern");
				return val;
			}
		}

		[Obsolete]
		public int FocusPadding {
			get {
				var val = (int)StyleGetProperty("focus-padding");
				return val;
			}
		}

		[Obsolete]
		public Gdk.Color? CursorColor {
			get {
				var val = (Gdk.Color?)StyleGetProperty("cursor-color");
				return val;
			}
		}

		[Obsolete]
		public Gdk.Color? SecondaryCursorColor {
			get {
				var val = (Gdk.Color?)StyleGetProperty("secondary-cursor-color");
				return val;
			}
		}

		public float CursorAspectRatio {
			get {
				var val = (float)StyleGetProperty("cursor-aspect-ratio");
				return val;
			}
		}

		public bool WindowDragging {
			get {
				var val = (bool)StyleGetProperty("window-dragging");
				return val;
			}
		}

		[Obsolete]
		public Gdk.Color? LinkColor {
			get {
				var val = (Gdk.Color?)StyleGetProperty("link-color");
				return val;
			}
		}

		[Obsolete]
		public Gdk.Color? VisitedLinkColor {
			get {
				var val = (Gdk.Color?)StyleGetProperty("visited-link-color");
				return val;
			}
		}

		[Obsolete]
		public bool WideSeparators {
			get {
				var val = (bool)StyleGetProperty("wide-separators");
				return val;
			}
		}

		[Obsolete]
		public int SeparatorWidth {
			get {
				var val = (int)StyleGetProperty("separator-width");
				return val;
			}
		}

		[Obsolete]
		public int SeparatorHeight {
			get {
				var val = (int)StyleGetProperty("separator-height");
				return val;
			}
		}

		public int ScrollArrowHlength {
			get {
				var val = (int)StyleGetProperty("scroll-arrow-hlength");
				return val;
			}
		}

		public int ScrollArrowVlength {
			get {
				var val = (int)StyleGetProperty("scroll-arrow-vlength");
				return val;
			}
		}

		public int TextHandleWidth {
			get {
				var val = (int)StyleGetProperty("text-handle-width");
				return val;
			}
		}

		public int TextHandleHeight {
			get {
				var val = (int)StyleGetProperty("text-handle-height");
				return val;
			}
		}

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

		[GLib.Signal("drag-begin")]
		public event Gtk.DragBeginHandler DragBegin {
			add {
				this.AddSignalHandler ("drag-begin", value, typeof (Gtk.DragBeginArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-begin", value);
			}
		}

		[GLib.Signal("direction-changed")]
		public event Gtk.DirectionChangedHandler DirectionChanged {
			add {
				this.AddSignalHandler ("direction-changed", value, typeof (Gtk.DirectionChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("direction-changed", value);
			}
		}

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

		[GLib.Signal("popup-menu")]
		public event Gtk.PopupMenuHandler PopupMenu {
			add {
				this.AddSignalHandler ("popup-menu", value, typeof (Gtk.PopupMenuArgs));
			}
			remove {
				this.RemoveSignalHandler ("popup-menu", value);
			}
		}

		[GLib.Signal("focus-in-event")]
		public event Gtk.FocusInEventHandler FocusInEvent {
			add {
				this.AddSignalHandler ("focus-in-event", value, typeof (Gtk.FocusInEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("focus-in-event", value);
			}
		}

		[GLib.Signal("drag-data-get")]
		public event Gtk.DragDataGetHandler DragDataGet {
			add {
				this.AddSignalHandler ("drag-data-get", value, typeof (Gtk.DragDataGetArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-data-get", value);
			}
		}

		[GLib.Signal("state-changed")]
		public event Gtk.StateChangedHandler StateChanged {
			add {
				this.AddSignalHandler ("state-changed", value, typeof (Gtk.StateChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("state-changed", value);
			}
		}

		[GLib.Signal("scroll-event")]
		public event Gtk.ScrollEventHandler ScrollEvent {
			add {
				this.AddSignalHandler ("scroll-event", value, typeof (Gtk.ScrollEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("scroll-event", value);
			}
		}

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

		[GLib.Signal("key-press-event")]
		public event Gtk.KeyPressEventHandler KeyPressEvent {
			add {
				this.AddSignalHandler ("key-press-event", value, typeof (Gtk.KeyPressEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("key-press-event", value);
			}
		}

		[GLib.Signal("grab-broken-event")]
		public event Gtk.GrabBrokenEventHandler GrabBrokenEvent {
			add {
				this.AddSignalHandler ("grab-broken-event", value, typeof (Gtk.GrabBrokenEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("grab-broken-event", value);
			}
		}

		[GLib.Signal("window-state-event")]
		public event Gtk.WindowStateEventHandler WindowStateEvent {
			add {
				this.AddSignalHandler ("window-state-event", value, typeof (Gtk.WindowStateEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("window-state-event", value);
			}
		}

		[GLib.Signal("state-flags-changed")]
		public event Gtk.StateFlagsChangedHandler StateFlagsChanged {
			add {
				this.AddSignalHandler ("state-flags-changed", value, typeof (Gtk.StateFlagsChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("state-flags-changed", value);
			}
		}

		[GLib.Signal("touch-event")]
		public event Gtk.TouchEventHandler TouchEvent {
			add {
				this.AddSignalHandler ("touch-event", value, typeof (Gtk.TouchEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("touch-event", value);
			}
		}

		[GLib.Signal("size-allocate")]
		public event Gtk.SizeAllocatedHandler SizeAllocated {
			add {
				this.AddSignalHandler ("size-allocate", value, typeof (Gtk.SizeAllocatedArgs));
			}
			remove {
				this.RemoveSignalHandler ("size-allocate", value);
			}
		}

		[GLib.Signal("screen-changed")]
		public event Gtk.ScreenChangedHandler ScreenChanged {
			add {
				this.AddSignalHandler ("screen-changed", value, typeof (Gtk.ScreenChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("screen-changed", value);
			}
		}

		[GLib.Signal("destroy-event")]
		public event Gtk.DestroyEventHandler DestroyEvent {
			add {
				this.AddSignalHandler ("destroy-event", value, typeof (Gtk.DestroyEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("destroy-event", value);
			}
		}

		[GLib.Signal("selection-request-event")]
		public event Gtk.SelectionRequestEventHandler SelectionRequestEvent {
			add {
				this.AddSignalHandler ("selection-request-event", value, typeof (Gtk.SelectionRequestEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("selection-request-event", value);
			}
		}

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

		[GLib.Signal("grab-focus")]
		public event System.EventHandler FocusGrabbed {
			add {
				this.AddSignalHandler ("grab-focus", value);
			}
			remove {
				this.RemoveSignalHandler ("grab-focus", value);
			}
		}

		[GLib.Signal("selection-clear-event")]
		public event Gtk.SelectionClearEventHandler SelectionClearEvent {
			add {
				this.AddSignalHandler ("selection-clear-event", value, typeof (Gtk.SelectionClearEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("selection-clear-event", value);
			}
		}

		[GLib.Signal("selection-received")]
		public event Gtk.SelectionReceivedHandler SelectionReceived {
			add {
				this.AddSignalHandler ("selection-received", value, typeof (Gtk.SelectionReceivedArgs));
			}
			remove {
				this.RemoveSignalHandler ("selection-received", value);
			}
		}

		[GLib.Signal("show-help")]
		public event Gtk.HelpShownHandler HelpShown {
			add {
				this.AddSignalHandler ("show-help", value, typeof (Gtk.HelpShownArgs));
			}
			remove {
				this.RemoveSignalHandler ("show-help", value);
			}
		}

		[GLib.Signal("button-release-event")]
		public event Gtk.ButtonReleaseEventHandler ButtonReleaseEvent {
			add {
				this.AddSignalHandler ("button-release-event", value, typeof (Gtk.ButtonReleaseEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("button-release-event", value);
			}
		}

		[GLib.Signal("style-set")]
		public event Gtk.StyleSetHandler StyleSet {
			add {
				this.AddSignalHandler ("style-set", value, typeof (Gtk.StyleSetArgs));
			}
			remove {
				this.RemoveSignalHandler ("style-set", value);
			}
		}

		[GLib.Signal("unmap-event")]
		public event Gtk.UnmapEventHandler UnmapEvent {
			add {
				this.AddSignalHandler ("unmap-event", value, typeof (Gtk.UnmapEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("unmap-event", value);
			}
		}

		[GLib.Signal("move-focus")]
		public event Gtk.MoveFocusHandler MoveFocus {
			add {
				this.AddSignalHandler ("move-focus", value, typeof (Gtk.MoveFocusArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-focus", value);
			}
		}

		[GLib.Signal("grab-notify")]
		public event Gtk.GrabNotifyHandler GrabNotify {
			add {
				this.AddSignalHandler ("grab-notify", value, typeof (Gtk.GrabNotifyArgs));
			}
			remove {
				this.RemoveSignalHandler ("grab-notify", value);
			}
		}

		[GLib.Signal("hierarchy-changed")]
		public event Gtk.HierarchyChangedHandler HierarchyChanged {
			add {
				this.AddSignalHandler ("hierarchy-changed", value, typeof (Gtk.HierarchyChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("hierarchy-changed", value);
			}
		}

		[GLib.Signal("drag-failed")]
		public event Gtk.DragFailedHandler DragFailed {
			add {
				this.AddSignalHandler ("drag-failed", value, typeof (Gtk.DragFailedArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-failed", value);
			}
		}

		[GLib.Signal("parent-set")]
		public event Gtk.ParentSetHandler ParentSet {
			add {
				this.AddSignalHandler ("parent-set", value, typeof (Gtk.ParentSetArgs));
			}
			remove {
				this.RemoveSignalHandler ("parent-set", value);
			}
		}

		[GLib.Signal("button-press-event")]
		public event Gtk.ButtonPressEventHandler ButtonPressEvent {
			add {
				this.AddSignalHandler ("button-press-event", value, typeof (Gtk.ButtonPressEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("button-press-event", value);
			}
		}

		[GLib.Signal("drag-data-received")]
		public event Gtk.DragDataReceivedHandler DragDataReceived {
			add {
				this.AddSignalHandler ("drag-data-received", value, typeof (Gtk.DragDataReceivedArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-data-received", value);
			}
		}

		[GLib.Signal("can-activate-accel")]
		public event Gtk.AccelCanActivateHandler AccelCanActivate {
			add {
				this.AddSignalHandler ("can-activate-accel", value, typeof (Gtk.AccelCanActivateArgs));
			}
			remove {
				this.RemoveSignalHandler ("can-activate-accel", value);
			}
		}

		[GLib.Signal("query-tooltip")]
		public event Gtk.QueryTooltipHandler QueryTooltip {
			add {
				this.AddSignalHandler ("query-tooltip", value, typeof (Gtk.QueryTooltipArgs));
			}
			remove {
				this.RemoveSignalHandler ("query-tooltip", value);
			}
		}

		[GLib.Signal("enter-notify-event")]
		public event Gtk.EnterNotifyEventHandler EnterNotifyEvent {
			add {
				this.AddSignalHandler ("enter-notify-event", value, typeof (Gtk.EnterNotifyEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("enter-notify-event", value);
			}
		}

		[GLib.Signal("event")]
		public event Gtk.WidgetEventHandler WidgetEvent {
			add {
				this.AddSignalHandler ("event", value, typeof (Gtk.WidgetEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("event", value);
			}
		}

		[GLib.Signal("motion-notify-event")]
		public event Gtk.MotionNotifyEventHandler MotionNotifyEvent {
			add {
				this.AddSignalHandler ("motion-notify-event", value, typeof (Gtk.MotionNotifyEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("motion-notify-event", value);
			}
		}

		[GLib.Signal("map-event")]
		public event Gtk.MapEventHandler MapEvent {
			add {
				this.AddSignalHandler ("map-event", value, typeof (Gtk.MapEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("map-event", value);
			}
		}

		[GLib.Signal("accel-closures-changed")]
		public event System.EventHandler AccelClosuresChanged {
			add {
				this.AddSignalHandler ("accel-closures-changed", value);
			}
			remove {
				this.RemoveSignalHandler ("accel-closures-changed", value);
			}
		}

		[GLib.Signal("focus")]
		public event Gtk.FocusedHandler Focused {
			add {
				this.AddSignalHandler ("focus", value, typeof (Gtk.FocusedArgs));
			}
			remove {
				this.RemoveSignalHandler ("focus", value);
			}
		}

		[GLib.Signal("proximity-in-event")]
		public event Gtk.ProximityInEventHandler ProximityInEvent {
			add {
				this.AddSignalHandler ("proximity-in-event", value, typeof (Gtk.ProximityInEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("proximity-in-event", value);
			}
		}

		[GLib.Signal("leave-notify-event")]
		public event Gtk.LeaveNotifyEventHandler LeaveNotifyEvent {
			add {
				this.AddSignalHandler ("leave-notify-event", value, typeof (Gtk.LeaveNotifyEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("leave-notify-event", value);
			}
		}

		[GLib.Signal("key-release-event")]
		public event Gtk.KeyReleaseEventHandler KeyReleaseEvent {
			add {
				this.AddSignalHandler ("key-release-event", value, typeof (Gtk.KeyReleaseEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("key-release-event", value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DrawnSignalDelegate (IntPtr inst, IntPtr arg0, IntPtr gch);

		static bool DrawnSignalCallback (IntPtr inst, IntPtr arg0, IntPtr gch)
		{
			Gtk.DrawnArgs args = new Gtk.DrawnArgs ();
			Cairo.Context cr = null;
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[1];
				cr = new Cairo.Context (arg0, false);
				args.Args[0] = cr;
				Gtk.DrawnHandler handler = (Gtk.DrawnHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = cr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}

			try {
				if (args.RetVal == null)
					return false;
				return ((bool) args.RetVal);
			} catch (Exception) {
				Exception ex = new Exception ("args.RetVal or 'out' property unset or set to incorrect type in Gtk.DrawnHandler callback");
				GLib.ExceptionManager.RaiseUnhandledException (ex, true);
				// NOTREACHED: above call doesn't return.
				throw ex;
			}
		}

		[GLib.Signal("draw")]
		public event Gtk.DrawnHandler Drawn {
			add {
				this.AddSignalHandler ("draw", value, new DrawnSignalDelegate(DrawnSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("draw", value);
			}
		}

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

		[GLib.Signal("property-notify-event")]
		public event Gtk.PropertyNotifyEventHandler PropertyNotifyEvent {
			add {
				this.AddSignalHandler ("property-notify-event", value, typeof (Gtk.PropertyNotifyEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("property-notify-event", value);
			}
		}

		[GLib.Signal("drag-leave")]
		public event Gtk.DragLeaveHandler DragLeave {
			add {
				this.AddSignalHandler ("drag-leave", value, typeof (Gtk.DragLeaveArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-leave", value);
			}
		}

		[GLib.Signal("composited-changed")]
		public event System.EventHandler CompositedChanged {
			add {
				this.AddSignalHandler ("composited-changed", value);
			}
			remove {
				this.RemoveSignalHandler ("composited-changed", value);
			}
		}

		[GLib.Signal("selection-notify-event")]
		public event Gtk.SelectionNotifyEventHandler SelectionNotifyEvent {
			add {
				this.AddSignalHandler ("selection-notify-event", value, typeof (Gtk.SelectionNotifyEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("selection-notify-event", value);
			}
		}

		[GLib.Signal("focus-out-event")]
		public event Gtk.FocusOutEventHandler FocusOutEvent {
			add {
				this.AddSignalHandler ("focus-out-event", value, typeof (Gtk.FocusOutEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("focus-out-event", value);
			}
		}

		[GLib.Signal("selection-get")]
		public event Gtk.SelectionGetHandler SelectionGet {
			add {
				this.AddSignalHandler ("selection-get", value, typeof (Gtk.SelectionGetArgs));
			}
			remove {
				this.RemoveSignalHandler ("selection-get", value);
			}
		}

		[GLib.Signal("delete-event")]
		public event Gtk.DeleteEventHandler DeleteEvent {
			add {
				this.AddSignalHandler ("delete-event", value, typeof (Gtk.DeleteEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("delete-event", value);
			}
		}

		[GLib.Signal("proximity-out-event")]
		public event Gtk.ProximityOutEventHandler ProximityOutEvent {
			add {
				this.AddSignalHandler ("proximity-out-event", value, typeof (Gtk.ProximityOutEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("proximity-out-event", value);
			}
		}

		[GLib.Signal("event-after")]
		public event Gtk.WidgetEventAfterHandler WidgetEventAfter {
			add {
				this.AddSignalHandler ("event-after", value, typeof (Gtk.WidgetEventAfterArgs));
			}
			remove {
				this.RemoveSignalHandler ("event-after", value);
			}
		}

		[GLib.Signal("mnemonic-activate")]
		public event Gtk.MnemonicActivatedHandler MnemonicActivated {
			add {
				this.AddSignalHandler ("mnemonic-activate", value, typeof (Gtk.MnemonicActivatedArgs));
			}
			remove {
				this.RemoveSignalHandler ("mnemonic-activate", value);
			}
		}

		[GLib.Signal("drag-data-delete")]
		public event Gtk.DragDataDeleteHandler DragDataDelete {
			add {
				this.AddSignalHandler ("drag-data-delete", value, typeof (Gtk.DragDataDeleteArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-data-delete", value);
			}
		}

		[GLib.Signal("drag-motion")]
		public event Gtk.DragMotionHandler DragMotion {
			add {
				this.AddSignalHandler ("drag-motion", value, typeof (Gtk.DragMotionArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-motion", value);
			}
		}

		[GLib.Signal("visibility-notify-event")]
		public event Gtk.VisibilityNotifyEventHandler VisibilityNotifyEvent {
			add {
				this.AddSignalHandler ("visibility-notify-event", value, typeof (Gtk.VisibilityNotifyEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("visibility-notify-event", value);
			}
		}

		[GLib.Signal("drag-end")]
		public event Gtk.DragEndHandler DragEnd {
			add {
				this.AddSignalHandler ("drag-end", value, typeof (Gtk.DragEndArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-end", value);
			}
		}

		[GLib.Signal("style-updated")]
		public event System.EventHandler StyleUpdated {
			add {
				this.AddSignalHandler ("style-updated", value);
			}
			remove {
				this.RemoveSignalHandler ("style-updated", value);
			}
		}

		[GLib.Signal("child-notify")]
		public event Gtk.ChildNotifiedHandler ChildNotified {
			add {
				this.AddSignalHandler ("child-notify", value, typeof (Gtk.ChildNotifiedArgs));
			}
			remove {
				this.RemoveSignalHandler ("child-notify", value);
			}
		}

		[GLib.Signal("drag-drop")]
		public event Gtk.DragDropHandler DragDrop {
			add {
				this.AddSignalHandler ("drag-drop", value, typeof (Gtk.DragDropArgs));
			}
			remove {
				this.RemoveSignalHandler ("drag-drop", value);
			}
		}

		[GLib.Signal("configure-event")]
		public event Gtk.ConfigureEventHandler ConfigureEvent {
			add {
				this.AddSignalHandler ("configure-event", value, typeof (Gtk.ConfigureEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("configure-event", value);
			}
		}

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

		[GLib.Signal("damage-event")]
		public event Gtk.DamageEventHandler DamageEvent {
			add {
				this.AddSignalHandler ("damage-event", value, typeof (Gtk.DamageEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("damage-event", value);
			}
		}

		static WidgetEventAfterNativeDelegate WidgetEventAfter_cb_delegate;
		static WidgetEventAfterNativeDelegate WidgetEventAfterVMCallback {
			get {
				if (WidgetEventAfter_cb_delegate == null)
					WidgetEventAfter_cb_delegate = new WidgetEventAfterNativeDelegate (WidgetEventAfter_cb);
				return WidgetEventAfter_cb_delegate;
			}
		}

		static void OverrideWidgetEventAfter (GLib.GType gtype)
		{
			OverrideWidgetEventAfter (gtype, WidgetEventAfterVMCallback);
		}

		static void OverrideWidgetEventAfter (GLib.GType gtype, WidgetEventAfterNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "event-after", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void WidgetEventAfterNativeDelegate (IntPtr inst, IntPtr evnt);

		static void WidgetEventAfter_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnWidgetEventAfter (Gdk.Event.GetEvent (evnt));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideWidgetEventAfter")]
		protected virtual void OnWidgetEventAfter (Gdk.Event evnt)
		{
			InternalWidgetEventAfter (evnt);
		}

		private void InternalWidgetEventAfter (Gdk.Event evnt)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
			GLib.Value[] vals = new GLib.Value [2];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (evnt);
			inst_and_params.Append (vals [1]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static AccelClosuresChangedNativeDelegate AccelClosuresChanged_cb_delegate;
		static AccelClosuresChangedNativeDelegate AccelClosuresChangedVMCallback {
			get {
				if (AccelClosuresChanged_cb_delegate == null)
					AccelClosuresChanged_cb_delegate = new AccelClosuresChangedNativeDelegate (AccelClosuresChanged_cb);
				return AccelClosuresChanged_cb_delegate;
			}
		}

		static void OverrideAccelClosuresChanged (GLib.GType gtype)
		{
			OverrideAccelClosuresChanged (gtype, AccelClosuresChangedVMCallback);
		}

		static void OverrideAccelClosuresChanged (GLib.GType gtype, AccelClosuresChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "accel-closures-changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AccelClosuresChangedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideAccelClosuresChanged")]
		protected virtual void OnAccelClosuresChanged ()
		{
			InternalAccelClosuresChanged ();
		}

		private void InternalAccelClosuresChanged ()
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
			GLib.Value[] vals = new GLib.Value [1];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static DispatchChildPropertiesChangedNativeDelegate DispatchChildPropertiesChanged_cb_delegate;
		static DispatchChildPropertiesChangedNativeDelegate DispatchChildPropertiesChangedVMCallback {
			get {
				if (DispatchChildPropertiesChanged_cb_delegate == null)
					DispatchChildPropertiesChanged_cb_delegate = new DispatchChildPropertiesChangedNativeDelegate (DispatchChildPropertiesChanged_cb);
				return DispatchChildPropertiesChanged_cb_delegate;
			}
		}

		static void OverrideDispatchChildPropertiesChanged (GLib.GType gtype)
		{
			OverrideDispatchChildPropertiesChanged (gtype, DispatchChildPropertiesChangedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DispatchChildPropertiesChangedNativeDelegate (IntPtr inst, uint n_pspecs, IntPtr pspecs);

		static void DispatchChildPropertiesChanged_cb (IntPtr inst, uint n_pspecs, IntPtr pspecs)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDispatchChildPropertiesChanged (n_pspecs, pspecs);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDispatchChildPropertiesChanged")]
		protected virtual void OnDispatchChildPropertiesChanged (uint n_pspecs, IntPtr pspecs)
		{
			InternalDispatchChildPropertiesChanged (n_pspecs, pspecs);
		}

		private void InternalDispatchChildPropertiesChanged (uint n_pspecs, IntPtr pspecs)
		{
			DispatchChildPropertiesChangedNativeDelegate unmanaged = class_abi.BaseOverride<DispatchChildPropertiesChangedNativeDelegate>(this.LookupGType(), "dispatch_child_properties_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle, n_pspecs, pspecs);
		}

		static ShownNativeDelegate Shown_cb_delegate;
		static ShownNativeDelegate ShownVMCallback {
			get {
				if (Shown_cb_delegate == null)
					Shown_cb_delegate = new ShownNativeDelegate (Shown_cb);
				return Shown_cb_delegate;
			}
		}

		static void OverrideShown (GLib.GType gtype)
		{
			OverrideShown (gtype, ShownVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideShown")]
		protected virtual void OnShown ()
		{
			InternalShown ();
		}

		private void InternalShown ()
		{
			ShownNativeDelegate unmanaged = class_abi.BaseOverride<ShownNativeDelegate>(this.LookupGType(), "show");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ShowAllNativeDelegate ShowAll_cb_delegate;
		static ShowAllNativeDelegate ShowAllVMCallback {
			get {
				if (ShowAll_cb_delegate == null)
					ShowAll_cb_delegate = new ShowAllNativeDelegate (ShowAll_cb);
				return ShowAll_cb_delegate;
			}
		}

		static void OverrideShowAll (GLib.GType gtype)
		{
			OverrideShowAll (gtype, ShowAllVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideShowAll")]
		protected virtual void OnShowAll ()
		{
			InternalShowAll ();
		}

		private void InternalShowAll ()
		{
			ShowAllNativeDelegate unmanaged = class_abi.BaseOverride<ShowAllNativeDelegate>(this.LookupGType(), "show_all");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static HiddenNativeDelegate Hidden_cb_delegate;
		static HiddenNativeDelegate HiddenVMCallback {
			get {
				if (Hidden_cb_delegate == null)
					Hidden_cb_delegate = new HiddenNativeDelegate (Hidden_cb);
				return Hidden_cb_delegate;
			}
		}

		static void OverrideHidden (GLib.GType gtype)
		{
			OverrideHidden (gtype, HiddenVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideHidden")]
		protected virtual void OnHidden ()
		{
			InternalHidden ();
		}

		private void InternalHidden ()
		{
			HiddenNativeDelegate unmanaged = class_abi.BaseOverride<HiddenNativeDelegate>(this.LookupGType(), "hide");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static MappedNativeDelegate Mapped_cb_delegate;
		static MappedNativeDelegate MappedVMCallback {
			get {
				if (Mapped_cb_delegate == null)
					Mapped_cb_delegate = new MappedNativeDelegate (Mapped_cb);
				return Mapped_cb_delegate;
			}
		}

		static void OverrideMapped (GLib.GType gtype)
		{
			OverrideMapped (gtype, MappedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideMapped")]
		protected virtual void OnMapped ()
		{
			InternalMapped ();
		}

		private void InternalMapped ()
		{
			MappedNativeDelegate unmanaged = class_abi.BaseOverride<MappedNativeDelegate>(this.LookupGType(), "map");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static UnmappedNativeDelegate Unmapped_cb_delegate;
		static UnmappedNativeDelegate UnmappedVMCallback {
			get {
				if (Unmapped_cb_delegate == null)
					Unmapped_cb_delegate = new UnmappedNativeDelegate (Unmapped_cb);
				return Unmapped_cb_delegate;
			}
		}

		static void OverrideUnmapped (GLib.GType gtype)
		{
			OverrideUnmapped (gtype, UnmappedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideUnmapped")]
		protected virtual void OnUnmapped ()
		{
			InternalUnmapped ();
		}

		private void InternalUnmapped ()
		{
			UnmappedNativeDelegate unmanaged = class_abi.BaseOverride<UnmappedNativeDelegate>(this.LookupGType(), "unmap");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static RealizedNativeDelegate Realized_cb_delegate;
		static RealizedNativeDelegate RealizedVMCallback {
			get {
				if (Realized_cb_delegate == null)
					Realized_cb_delegate = new RealizedNativeDelegate (Realized_cb);
				return Realized_cb_delegate;
			}
		}

		static void OverrideRealized (GLib.GType gtype)
		{
			OverrideRealized (gtype, RealizedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideRealized")]
		protected virtual void OnRealized ()
		{
			InternalRealized ();
		}

		private void InternalRealized ()
		{
			RealizedNativeDelegate unmanaged = class_abi.BaseOverride<RealizedNativeDelegate>(this.LookupGType(), "realize");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static UnrealizedNativeDelegate Unrealized_cb_delegate;
		static UnrealizedNativeDelegate UnrealizedVMCallback {
			get {
				if (Unrealized_cb_delegate == null)
					Unrealized_cb_delegate = new UnrealizedNativeDelegate (Unrealized_cb);
				return Unrealized_cb_delegate;
			}
		}

		static void OverrideUnrealized (GLib.GType gtype)
		{
			OverrideUnrealized (gtype, UnrealizedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideUnrealized")]
		protected virtual void OnUnrealized ()
		{
			InternalUnrealized ();
		}

		private void InternalUnrealized ()
		{
			UnrealizedNativeDelegate unmanaged = class_abi.BaseOverride<UnrealizedNativeDelegate>(this.LookupGType(), "unrealize");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static SizeAllocatedNativeDelegate SizeAllocated_cb_delegate;
		static SizeAllocatedNativeDelegate SizeAllocatedVMCallback {
			get {
				if (SizeAllocated_cb_delegate == null)
					SizeAllocated_cb_delegate = new SizeAllocatedNativeDelegate (SizeAllocated_cb);
				return SizeAllocated_cb_delegate;
			}
		}

		static void OverrideSizeAllocated (GLib.GType gtype)
		{
			OverrideSizeAllocated (gtype, SizeAllocatedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SizeAllocatedNativeDelegate (IntPtr inst, IntPtr allocation);

		static void SizeAllocated_cb (IntPtr inst, IntPtr allocation)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnSizeAllocated ((Gdk.Rectangle) Marshal.PtrToStructure (allocation, typeof (Gdk.Rectangle)));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideSizeAllocated")]
		protected virtual void OnSizeAllocated (Gdk.Rectangle allocation)
		{
			InternalSizeAllocated (allocation);
		}

		private void InternalSizeAllocated (Gdk.Rectangle allocation)
		{
			SizeAllocatedNativeDelegate unmanaged = class_abi.BaseOverride<SizeAllocatedNativeDelegate>(this.LookupGType(), "size_allocate");
			if (unmanaged == null) return;

			IntPtr native_allocation = GLib.Marshaller.StructureToPtrAlloc (allocation);
			unmanaged (this.Handle, native_allocation);
			Marshal.FreeHGlobal (native_allocation);
		}

		static StateChangedNativeDelegate StateChanged_cb_delegate;
		static StateChangedNativeDelegate StateChangedVMCallback {
			get {
				if (StateChanged_cb_delegate == null)
					StateChanged_cb_delegate = new StateChangedNativeDelegate (StateChanged_cb);
				return StateChanged_cb_delegate;
			}
		}

		static void OverrideStateChanged (GLib.GType gtype)
		{
			OverrideStateChanged (gtype, StateChangedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void StateChangedNativeDelegate (IntPtr inst, int previous_state);

		static void StateChanged_cb (IntPtr inst, int previous_state)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnStateChanged ((Gtk.StateType) previous_state);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideStateChanged")]
		protected virtual void OnStateChanged (Gtk.StateType previous_state)
		{
			InternalStateChanged (previous_state);
		}

		private void InternalStateChanged (Gtk.StateType previous_state)
		{
			StateChangedNativeDelegate unmanaged = class_abi.BaseOverride<StateChangedNativeDelegate>(this.LookupGType(), "state_changed");
			if (unmanaged == null) return;

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

		static StateFlagsChangedNativeDelegate StateFlagsChanged_cb_delegate;
		static StateFlagsChangedNativeDelegate StateFlagsChangedVMCallback {
			get {
				if (StateFlagsChanged_cb_delegate == null)
					StateFlagsChanged_cb_delegate = new StateFlagsChangedNativeDelegate (StateFlagsChanged_cb);
				return StateFlagsChanged_cb_delegate;
			}
		}

		static void OverrideStateFlagsChanged (GLib.GType gtype)
		{
			OverrideStateFlagsChanged (gtype, StateFlagsChangedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void StateFlagsChangedNativeDelegate (IntPtr inst, int previous_state_flags);

		static void StateFlagsChanged_cb (IntPtr inst, int previous_state_flags)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnStateFlagsChanged ((Gtk.StateFlags) previous_state_flags);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideStateFlagsChanged")]
		protected virtual void OnStateFlagsChanged (Gtk.StateFlags previous_state_flags)
		{
			InternalStateFlagsChanged (previous_state_flags);
		}

		private void InternalStateFlagsChanged (Gtk.StateFlags previous_state_flags)
		{
			StateFlagsChangedNativeDelegate unmanaged = class_abi.BaseOverride<StateFlagsChangedNativeDelegate>(this.LookupGType(), "state_flags_changed");
			if (unmanaged == null) return;

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

		static ParentSetNativeDelegate ParentSet_cb_delegate;
		static ParentSetNativeDelegate ParentSetVMCallback {
			get {
				if (ParentSet_cb_delegate == null)
					ParentSet_cb_delegate = new ParentSetNativeDelegate (ParentSet_cb);
				return ParentSet_cb_delegate;
			}
		}

		static void OverrideParentSet (GLib.GType gtype)
		{
			OverrideParentSet (gtype, ParentSetVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ParentSetNativeDelegate (IntPtr inst, IntPtr previous_parent);

		static void ParentSet_cb (IntPtr inst, IntPtr previous_parent)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnParentSet (GLib.Object.GetObject(previous_parent) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideParentSet")]
		protected virtual void OnParentSet (Gtk.Widget previous_parent)
		{
			InternalParentSet (previous_parent);
		}

		private void InternalParentSet (Gtk.Widget previous_parent)
		{
			ParentSetNativeDelegate unmanaged = class_abi.BaseOverride<ParentSetNativeDelegate>(this.LookupGType(), "parent_set");
			if (unmanaged == null) return;

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

		static HierarchyChangedNativeDelegate HierarchyChanged_cb_delegate;
		static HierarchyChangedNativeDelegate HierarchyChangedVMCallback {
			get {
				if (HierarchyChanged_cb_delegate == null)
					HierarchyChanged_cb_delegate = new HierarchyChangedNativeDelegate (HierarchyChanged_cb);
				return HierarchyChanged_cb_delegate;
			}
		}

		static void OverrideHierarchyChanged (GLib.GType gtype)
		{
			OverrideHierarchyChanged (gtype, HierarchyChangedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void HierarchyChangedNativeDelegate (IntPtr inst, IntPtr previous_toplevel);

		static void HierarchyChanged_cb (IntPtr inst, IntPtr previous_toplevel)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnHierarchyChanged (GLib.Object.GetObject(previous_toplevel) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideHierarchyChanged")]
		protected virtual void OnHierarchyChanged (Gtk.Widget previous_toplevel)
		{
			InternalHierarchyChanged (previous_toplevel);
		}

		private void InternalHierarchyChanged (Gtk.Widget previous_toplevel)
		{
			HierarchyChangedNativeDelegate unmanaged = class_abi.BaseOverride<HierarchyChangedNativeDelegate>(this.LookupGType(), "hierarchy_changed");
			if (unmanaged == null) return;

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

		static StyleSetNativeDelegate StyleSet_cb_delegate;
		static StyleSetNativeDelegate StyleSetVMCallback {
			get {
				if (StyleSet_cb_delegate == null)
					StyleSet_cb_delegate = new StyleSetNativeDelegate (StyleSet_cb);
				return StyleSet_cb_delegate;
			}
		}

		static void OverrideStyleSet (GLib.GType gtype)
		{
			OverrideStyleSet (gtype, StyleSetVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void StyleSetNativeDelegate (IntPtr inst, IntPtr previous_style);

		static void StyleSet_cb (IntPtr inst, IntPtr previous_style)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnStyleSet (GLib.Object.GetObject(previous_style) as Gtk.Style);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideStyleSet")]
		protected virtual void OnStyleSet (Gtk.Style previous_style)
		{
			InternalStyleSet (previous_style);
		}

		private void InternalStyleSet (Gtk.Style previous_style)
		{
			StyleSetNativeDelegate unmanaged = class_abi.BaseOverride<StyleSetNativeDelegate>(this.LookupGType(), "style_set");
			if (unmanaged == null) return;

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

		static DirectionChangedNativeDelegate DirectionChanged_cb_delegate;
		static DirectionChangedNativeDelegate DirectionChangedVMCallback {
			get {
				if (DirectionChanged_cb_delegate == null)
					DirectionChanged_cb_delegate = new DirectionChangedNativeDelegate (DirectionChanged_cb);
				return DirectionChanged_cb_delegate;
			}
		}

		static void OverrideDirectionChanged (GLib.GType gtype)
		{
			OverrideDirectionChanged (gtype, DirectionChangedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DirectionChangedNativeDelegate (IntPtr inst, int previous_direction);

		static void DirectionChanged_cb (IntPtr inst, int previous_direction)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDirectionChanged ((Gtk.TextDirection) previous_direction);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDirectionChanged")]
		protected virtual void OnDirectionChanged (Gtk.TextDirection previous_direction)
		{
			InternalDirectionChanged (previous_direction);
		}

		private void InternalDirectionChanged (Gtk.TextDirection previous_direction)
		{
			DirectionChangedNativeDelegate unmanaged = class_abi.BaseOverride<DirectionChangedNativeDelegate>(this.LookupGType(), "direction_changed");
			if (unmanaged == null) return;

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

		static GrabNotifyNativeDelegate GrabNotify_cb_delegate;
		static GrabNotifyNativeDelegate GrabNotifyVMCallback {
			get {
				if (GrabNotify_cb_delegate == null)
					GrabNotify_cb_delegate = new GrabNotifyNativeDelegate (GrabNotify_cb);
				return GrabNotify_cb_delegate;
			}
		}

		static void OverrideGrabNotify (GLib.GType gtype)
		{
			OverrideGrabNotify (gtype, GrabNotifyVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GrabNotifyNativeDelegate (IntPtr inst, bool was_grabbed);

		static void GrabNotify_cb (IntPtr inst, bool was_grabbed)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnGrabNotify (was_grabbed);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGrabNotify")]
		protected virtual void OnGrabNotify (bool was_grabbed)
		{
			InternalGrabNotify (was_grabbed);
		}

		private void InternalGrabNotify (bool was_grabbed)
		{
			GrabNotifyNativeDelegate unmanaged = class_abi.BaseOverride<GrabNotifyNativeDelegate>(this.LookupGType(), "grab_notify");
			if (unmanaged == null) return;

			unmanaged (this.Handle, was_grabbed);
		}

		static ChildNotifiedNativeDelegate ChildNotified_cb_delegate;
		static ChildNotifiedNativeDelegate ChildNotifiedVMCallback {
			get {
				if (ChildNotified_cb_delegate == null)
					ChildNotified_cb_delegate = new ChildNotifiedNativeDelegate (ChildNotified_cb);
				return ChildNotified_cb_delegate;
			}
		}

		static void OverrideChildNotified (GLib.GType gtype)
		{
			OverrideChildNotified (gtype, ChildNotifiedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChildNotifiedNativeDelegate (IntPtr inst, IntPtr child_property);

		static void ChildNotified_cb (IntPtr inst, IntPtr child_property)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnChildNotified (child_property);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideChildNotified")]
		protected virtual void OnChildNotified (IntPtr child_property)
		{
			InternalChildNotified (child_property);
		}

		private void InternalChildNotified (IntPtr child_property)
		{
			ChildNotifiedNativeDelegate unmanaged = class_abi.BaseOverride<ChildNotifiedNativeDelegate>(this.LookupGType(), "child_notify");
			if (unmanaged == null) return;

			unmanaged (this.Handle, child_property);
		}

		static DrawnNativeDelegate Drawn_cb_delegate;
		static DrawnNativeDelegate DrawnVMCallback {
			get {
				if (Drawn_cb_delegate == null)
					Drawn_cb_delegate = new DrawnNativeDelegate (Drawn_cb);
				return Drawn_cb_delegate;
			}
		}

		static void OverrideDrawn (GLib.GType gtype)
		{
			OverrideDrawn (gtype, DrawnVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DrawnNativeDelegate (IntPtr inst, IntPtr cr);

		static bool Drawn_cb (IntPtr inst, IntPtr cr)
		{
			Cairo.Context mycr = null;

			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				mycr = new Cairo.Context (cr, false);
				__result = __obj.OnDrawn (mycr);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDrawn")]
		protected virtual bool OnDrawn (Cairo.Context cr)
		{
			return InternalDrawn (cr);
		}

		private bool InternalDrawn (Cairo.Context cr)
		{
			DrawnNativeDelegate unmanaged = class_abi.BaseOverride<DrawnNativeDelegate>(this.LookupGType(), "draw");
			if (unmanaged == null) return false;

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

		static GetRequestModeNativeDelegate GetRequestMode_cb_delegate;
		static GetRequestModeNativeDelegate GetRequestModeVMCallback {
			get {
				if (GetRequestMode_cb_delegate == null)
					GetRequestMode_cb_delegate = new GetRequestModeNativeDelegate (GetRequestMode_cb);
				return GetRequestMode_cb_delegate;
			}
		}

		static void OverrideGetRequestMode (GLib.GType gtype)
		{
			OverrideGetRequestMode (gtype, GetRequestModeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetRequestModeNativeDelegate (IntPtr inst);

		static int GetRequestMode_cb (IntPtr inst)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				Gtk.SizeRequestMode __result;
				__result = __obj.OnGetRequestMode ();
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGetRequestMode")]
		protected virtual Gtk.SizeRequestMode OnGetRequestMode ()
		{
			return InternalGetRequestMode ();
		}

		private Gtk.SizeRequestMode InternalGetRequestMode ()
		{
			GetRequestModeNativeDelegate unmanaged = class_abi.BaseOverride<GetRequestModeNativeDelegate>(this.LookupGType(), "get_request_mode");
			if (unmanaged == null) return (Gtk.SizeRequestMode) 0;

			int __result = unmanaged (this.Handle);
			return (Gtk.SizeRequestMode) __result;
		}

		static GetPreferredHeightNativeDelegate GetPreferredHeight_cb_delegate;
		static GetPreferredHeightNativeDelegate GetPreferredHeightVMCallback {
			get {
				if (GetPreferredHeight_cb_delegate == null)
					GetPreferredHeight_cb_delegate = new GetPreferredHeightNativeDelegate (GetPreferredHeight_cb);
				return GetPreferredHeight_cb_delegate;
			}
		}

		static void OverrideGetPreferredHeight (GLib.GType gtype)
		{
			OverrideGetPreferredHeight (gtype, GetPreferredHeightVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetPreferredHeightNativeDelegate (IntPtr inst, out int minimum_height, out int natural_height);

		static void GetPreferredHeight_cb (IntPtr inst, out int minimum_height, out int natural_height)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnGetPreferredHeight (out minimum_height, out natural_height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGetPreferredHeight")]
		protected virtual void OnGetPreferredHeight (out int minimum_height, out int natural_height)
		{
			InternalGetPreferredHeight (out minimum_height, out natural_height);
		}

		private void InternalGetPreferredHeight (out int minimum_height, out int natural_height)
		{
			GetPreferredHeightNativeDelegate unmanaged = class_abi.BaseOverride<GetPreferredHeightNativeDelegate>(this.LookupGType(), "get_preferred_height");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out minimum_height, out natural_height);
		}

		static GetPreferredWidthForHeightNativeDelegate GetPreferredWidthForHeight_cb_delegate;
		static GetPreferredWidthForHeightNativeDelegate GetPreferredWidthForHeightVMCallback {
			get {
				if (GetPreferredWidthForHeight_cb_delegate == null)
					GetPreferredWidthForHeight_cb_delegate = new GetPreferredWidthForHeightNativeDelegate (GetPreferredWidthForHeight_cb);
				return GetPreferredWidthForHeight_cb_delegate;
			}
		}

		static void OverrideGetPreferredWidthForHeight (GLib.GType gtype)
		{
			OverrideGetPreferredWidthForHeight (gtype, GetPreferredWidthForHeightVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetPreferredWidthForHeightNativeDelegate (IntPtr inst, int height, out int minimum_width, out int natural_width);

		static void GetPreferredWidthForHeight_cb (IntPtr inst, int height, out int minimum_width, out int natural_width)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnGetPreferredWidthForHeight (height, out minimum_width, out natural_width);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGetPreferredWidthForHeight")]
		protected virtual void OnGetPreferredWidthForHeight (int height, out int minimum_width, out int natural_width)
		{
			InternalGetPreferredWidthForHeight (height, out minimum_width, out natural_width);
		}

		private void InternalGetPreferredWidthForHeight (int height, out int minimum_width, out int natural_width)
		{
			GetPreferredWidthForHeightNativeDelegate unmanaged = class_abi.BaseOverride<GetPreferredWidthForHeightNativeDelegate>(this.LookupGType(), "get_preferred_width_for_height");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, height, out minimum_width, out natural_width);
		}

		static GetPreferredWidthNativeDelegate GetPreferredWidth_cb_delegate;
		static GetPreferredWidthNativeDelegate GetPreferredWidthVMCallback {
			get {
				if (GetPreferredWidth_cb_delegate == null)
					GetPreferredWidth_cb_delegate = new GetPreferredWidthNativeDelegate (GetPreferredWidth_cb);
				return GetPreferredWidth_cb_delegate;
			}
		}

		static void OverrideGetPreferredWidth (GLib.GType gtype)
		{
			OverrideGetPreferredWidth (gtype, GetPreferredWidthVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetPreferredWidthNativeDelegate (IntPtr inst, out int minimum_width, out int natural_width);

		static void GetPreferredWidth_cb (IntPtr inst, out int minimum_width, out int natural_width)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnGetPreferredWidth (out minimum_width, out natural_width);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGetPreferredWidth")]
		protected virtual void OnGetPreferredWidth (out int minimum_width, out int natural_width)
		{
			InternalGetPreferredWidth (out minimum_width, out natural_width);
		}

		private void InternalGetPreferredWidth (out int minimum_width, out int natural_width)
		{
			GetPreferredWidthNativeDelegate unmanaged = class_abi.BaseOverride<GetPreferredWidthNativeDelegate>(this.LookupGType(), "get_preferred_width");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out minimum_width, out natural_width);
		}

		static GetPreferredHeightForWidthNativeDelegate GetPreferredHeightForWidth_cb_delegate;
		static GetPreferredHeightForWidthNativeDelegate GetPreferredHeightForWidthVMCallback {
			get {
				if (GetPreferredHeightForWidth_cb_delegate == null)
					GetPreferredHeightForWidth_cb_delegate = new GetPreferredHeightForWidthNativeDelegate (GetPreferredHeightForWidth_cb);
				return GetPreferredHeightForWidth_cb_delegate;
			}
		}

		static void OverrideGetPreferredHeightForWidth (GLib.GType gtype)
		{
			OverrideGetPreferredHeightForWidth (gtype, GetPreferredHeightForWidthVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetPreferredHeightForWidthNativeDelegate (IntPtr inst, int width, out int minimum_height, out int natural_height);

		static void GetPreferredHeightForWidth_cb (IntPtr inst, int width, out int minimum_height, out int natural_height)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnGetPreferredHeightForWidth (width, out minimum_height, out natural_height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGetPreferredHeightForWidth")]
		protected virtual void OnGetPreferredHeightForWidth (int width, out int minimum_height, out int natural_height)
		{
			InternalGetPreferredHeightForWidth (width, out minimum_height, out natural_height);
		}

		private void InternalGetPreferredHeightForWidth (int width, out int minimum_height, out int natural_height)
		{
			GetPreferredHeightForWidthNativeDelegate unmanaged = class_abi.BaseOverride<GetPreferredHeightForWidthNativeDelegate>(this.LookupGType(), "get_preferred_height_for_width");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, width, out minimum_height, out natural_height);
		}

		static MnemonicActivatedNativeDelegate MnemonicActivated_cb_delegate;
		static MnemonicActivatedNativeDelegate MnemonicActivatedVMCallback {
			get {
				if (MnemonicActivated_cb_delegate == null)
					MnemonicActivated_cb_delegate = new MnemonicActivatedNativeDelegate (MnemonicActivated_cb);
				return MnemonicActivated_cb_delegate;
			}
		}

		static void OverrideMnemonicActivated (GLib.GType gtype)
		{
			OverrideMnemonicActivated (gtype, MnemonicActivatedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool MnemonicActivatedNativeDelegate (IntPtr inst, bool group_cycling);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideMnemonicActivated")]
		protected virtual bool OnMnemonicActivated (bool group_cycling)
		{
			return InternalMnemonicActivated (group_cycling);
		}

		private bool InternalMnemonicActivated (bool group_cycling)
		{
			MnemonicActivatedNativeDelegate unmanaged = class_abi.BaseOverride<MnemonicActivatedNativeDelegate>(this.LookupGType(), "mnemonic_activate");
			if (unmanaged == null) return false;

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

		static FocusGrabbedNativeDelegate FocusGrabbed_cb_delegate;
		static FocusGrabbedNativeDelegate FocusGrabbedVMCallback {
			get {
				if (FocusGrabbed_cb_delegate == null)
					FocusGrabbed_cb_delegate = new FocusGrabbedNativeDelegate (FocusGrabbed_cb);
				return FocusGrabbed_cb_delegate;
			}
		}

		static void OverrideFocusGrabbed (GLib.GType gtype)
		{
			OverrideFocusGrabbed (gtype, FocusGrabbedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideFocusGrabbed")]
		protected virtual void OnFocusGrabbed ()
		{
			InternalFocusGrabbed ();
		}

		private void InternalFocusGrabbed ()
		{
			FocusGrabbedNativeDelegate unmanaged = class_abi.BaseOverride<FocusGrabbedNativeDelegate>(this.LookupGType(), "grab_focus");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static FocusedNativeDelegate Focused_cb_delegate;
		static FocusedNativeDelegate FocusedVMCallback {
			get {
				if (Focused_cb_delegate == null)
					Focused_cb_delegate = new FocusedNativeDelegate (Focused_cb);
				return Focused_cb_delegate;
			}
		}

		static void OverrideFocused (GLib.GType gtype)
		{
			OverrideFocused (gtype, FocusedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool FocusedNativeDelegate (IntPtr inst, int direction);

		static bool Focused_cb (IntPtr inst, int direction)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnFocused ((Gtk.DirectionType) direction);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideFocused")]
		protected virtual bool OnFocused (Gtk.DirectionType direction)
		{
			return InternalFocused (direction);
		}

		private bool InternalFocused (Gtk.DirectionType direction)
		{
			FocusedNativeDelegate unmanaged = class_abi.BaseOverride<FocusedNativeDelegate>(this.LookupGType(), "focus");
			if (unmanaged == null) return false;

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

		static MoveFocusNativeDelegate MoveFocus_cb_delegate;
		static MoveFocusNativeDelegate MoveFocusVMCallback {
			get {
				if (MoveFocus_cb_delegate == null)
					MoveFocus_cb_delegate = new MoveFocusNativeDelegate (MoveFocus_cb);
				return MoveFocus_cb_delegate;
			}
		}

		static void OverrideMoveFocus (GLib.GType gtype)
		{
			OverrideMoveFocus (gtype, MoveFocusVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MoveFocusNativeDelegate (IntPtr inst, int direction);

		static void MoveFocus_cb (IntPtr inst, int direction)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnMoveFocus ((Gtk.DirectionType) direction);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideMoveFocus")]
		protected virtual void OnMoveFocus (Gtk.DirectionType direction)
		{
			InternalMoveFocus (direction);
		}

		private void InternalMoveFocus (Gtk.DirectionType direction)
		{
			MoveFocusNativeDelegate unmanaged = class_abi.BaseOverride<MoveFocusNativeDelegate>(this.LookupGType(), "move_focus");
			if (unmanaged == null) return;

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

		static WidgetEventNativeDelegate WidgetEvent_cb_delegate;
		static WidgetEventNativeDelegate WidgetEventVMCallback {
			get {
				if (WidgetEvent_cb_delegate == null)
					WidgetEvent_cb_delegate = new WidgetEventNativeDelegate (WidgetEvent_cb);
				return WidgetEvent_cb_delegate;
			}
		}

		static void OverrideWidgetEvent (GLib.GType gtype)
		{
			OverrideWidgetEvent (gtype, WidgetEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool WidgetEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool WidgetEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnWidgetEvent (Gdk.Event.GetEvent (evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideWidgetEvent")]
		protected virtual bool OnWidgetEvent (Gdk.Event evnt)
		{
			return InternalWidgetEvent (evnt);
		}

		private bool InternalWidgetEvent (Gdk.Event evnt)
		{
			WidgetEventNativeDelegate unmanaged = class_abi.BaseOverride<WidgetEventNativeDelegate>(this.LookupGType(), "event");
			if (unmanaged == null) return false;

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

		static ButtonPressEventNativeDelegate ButtonPressEvent_cb_delegate;
		static ButtonPressEventNativeDelegate ButtonPressEventVMCallback {
			get {
				if (ButtonPressEvent_cb_delegate == null)
					ButtonPressEvent_cb_delegate = new ButtonPressEventNativeDelegate (ButtonPressEvent_cb);
				return ButtonPressEvent_cb_delegate;
			}
		}

		static void OverrideButtonPressEvent (GLib.GType gtype)
		{
			OverrideButtonPressEvent (gtype, ButtonPressEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ButtonPressEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool ButtonPressEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnButtonPressEvent (new Gdk.EventButton(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideButtonPressEvent")]
		protected virtual bool OnButtonPressEvent (Gdk.EventButton evnt)
		{
			return InternalButtonPressEvent (evnt);
		}

		private bool InternalButtonPressEvent (Gdk.EventButton evnt)
		{
			ButtonPressEventNativeDelegate unmanaged = class_abi.BaseOverride<ButtonPressEventNativeDelegate>(this.LookupGType(), "button_press_event");
			if (unmanaged == null) return false;

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

		static ButtonReleaseEventNativeDelegate ButtonReleaseEvent_cb_delegate;
		static ButtonReleaseEventNativeDelegate ButtonReleaseEventVMCallback {
			get {
				if (ButtonReleaseEvent_cb_delegate == null)
					ButtonReleaseEvent_cb_delegate = new ButtonReleaseEventNativeDelegate (ButtonReleaseEvent_cb);
				return ButtonReleaseEvent_cb_delegate;
			}
		}

		static void OverrideButtonReleaseEvent (GLib.GType gtype)
		{
			OverrideButtonReleaseEvent (gtype, ButtonReleaseEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ButtonReleaseEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool ButtonReleaseEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnButtonReleaseEvent (new Gdk.EventButton(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideButtonReleaseEvent")]
		protected virtual bool OnButtonReleaseEvent (Gdk.EventButton evnt)
		{
			return InternalButtonReleaseEvent (evnt);
		}

		private bool InternalButtonReleaseEvent (Gdk.EventButton evnt)
		{
			ButtonReleaseEventNativeDelegate unmanaged = class_abi.BaseOverride<ButtonReleaseEventNativeDelegate>(this.LookupGType(), "button_release_event");
			if (unmanaged == null) return false;

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

		static ScrollEventNativeDelegate ScrollEvent_cb_delegate;
		static ScrollEventNativeDelegate ScrollEventVMCallback {
			get {
				if (ScrollEvent_cb_delegate == null)
					ScrollEvent_cb_delegate = new ScrollEventNativeDelegate (ScrollEvent_cb);
				return ScrollEvent_cb_delegate;
			}
		}

		static void OverrideScrollEvent (GLib.GType gtype)
		{
			OverrideScrollEvent (gtype, ScrollEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ScrollEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool ScrollEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnScrollEvent (new Gdk.EventScroll(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideScrollEvent")]
		protected virtual bool OnScrollEvent (Gdk.EventScroll evnt)
		{
			return InternalScrollEvent (evnt);
		}

		private bool InternalScrollEvent (Gdk.EventScroll evnt)
		{
			ScrollEventNativeDelegate unmanaged = class_abi.BaseOverride<ScrollEventNativeDelegate>(this.LookupGType(), "scroll_event");
			if (unmanaged == null) return false;

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

		static MotionNotifyEventNativeDelegate MotionNotifyEvent_cb_delegate;
		static MotionNotifyEventNativeDelegate MotionNotifyEventVMCallback {
			get {
				if (MotionNotifyEvent_cb_delegate == null)
					MotionNotifyEvent_cb_delegate = new MotionNotifyEventNativeDelegate (MotionNotifyEvent_cb);
				return MotionNotifyEvent_cb_delegate;
			}
		}

		static void OverrideMotionNotifyEvent (GLib.GType gtype)
		{
			OverrideMotionNotifyEvent (gtype, MotionNotifyEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool MotionNotifyEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool MotionNotifyEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnMotionNotifyEvent (new Gdk.EventMotion(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideMotionNotifyEvent")]
		protected virtual bool OnMotionNotifyEvent (Gdk.EventMotion evnt)
		{
			return InternalMotionNotifyEvent (evnt);
		}

		private bool InternalMotionNotifyEvent (Gdk.EventMotion evnt)
		{
			MotionNotifyEventNativeDelegate unmanaged = class_abi.BaseOverride<MotionNotifyEventNativeDelegate>(this.LookupGType(), "motion_notify_event");
			if (unmanaged == null) return false;

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

		static DeleteEventNativeDelegate DeleteEvent_cb_delegate;
		static DeleteEventNativeDelegate DeleteEventVMCallback {
			get {
				if (DeleteEvent_cb_delegate == null)
					DeleteEvent_cb_delegate = new DeleteEventNativeDelegate (DeleteEvent_cb);
				return DeleteEvent_cb_delegate;
			}
		}

		static void OverrideDeleteEvent (GLib.GType gtype)
		{
			OverrideDeleteEvent (gtype, DeleteEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DeleteEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool DeleteEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnDeleteEvent (Gdk.Event.GetEvent (evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDeleteEvent")]
		protected virtual bool OnDeleteEvent (Gdk.Event evnt)
		{
			return InternalDeleteEvent (evnt);
		}

		private bool InternalDeleteEvent (Gdk.Event evnt)
		{
			DeleteEventNativeDelegate unmanaged = class_abi.BaseOverride<DeleteEventNativeDelegate>(this.LookupGType(), "delete_event");
			if (unmanaged == null) return false;

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

		static DestroyEventNativeDelegate DestroyEvent_cb_delegate;
		static DestroyEventNativeDelegate DestroyEventVMCallback {
			get {
				if (DestroyEvent_cb_delegate == null)
					DestroyEvent_cb_delegate = new DestroyEventNativeDelegate (DestroyEvent_cb);
				return DestroyEvent_cb_delegate;
			}
		}

		static void OverrideDestroyEvent (GLib.GType gtype)
		{
			OverrideDestroyEvent (gtype, DestroyEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DestroyEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool DestroyEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnDestroyEvent (Gdk.Event.GetEvent (evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDestroyEvent")]
		protected virtual bool OnDestroyEvent (Gdk.Event evnt)
		{
			return InternalDestroyEvent (evnt);
		}

		private bool InternalDestroyEvent (Gdk.Event evnt)
		{
			DestroyEventNativeDelegate unmanaged = class_abi.BaseOverride<DestroyEventNativeDelegate>(this.LookupGType(), "destroy_event");
			if (unmanaged == null) return false;

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

		static KeyPressEventNativeDelegate KeyPressEvent_cb_delegate;
		static KeyPressEventNativeDelegate KeyPressEventVMCallback {
			get {
				if (KeyPressEvent_cb_delegate == null)
					KeyPressEvent_cb_delegate = new KeyPressEventNativeDelegate (KeyPressEvent_cb);
				return KeyPressEvent_cb_delegate;
			}
		}

		static void OverrideKeyPressEvent (GLib.GType gtype)
		{
			OverrideKeyPressEvent (gtype, KeyPressEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool KeyPressEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool KeyPressEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnKeyPressEvent (new Gdk.EventKey(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideKeyPressEvent")]
		protected virtual bool OnKeyPressEvent (Gdk.EventKey evnt)
		{
			return InternalKeyPressEvent (evnt);
		}

		private bool InternalKeyPressEvent (Gdk.EventKey evnt)
		{
			KeyPressEventNativeDelegate unmanaged = class_abi.BaseOverride<KeyPressEventNativeDelegate>(this.LookupGType(), "key_press_event");
			if (unmanaged == null) return false;

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

		static KeyReleaseEventNativeDelegate KeyReleaseEvent_cb_delegate;
		static KeyReleaseEventNativeDelegate KeyReleaseEventVMCallback {
			get {
				if (KeyReleaseEvent_cb_delegate == null)
					KeyReleaseEvent_cb_delegate = new KeyReleaseEventNativeDelegate (KeyReleaseEvent_cb);
				return KeyReleaseEvent_cb_delegate;
			}
		}

		static void OverrideKeyReleaseEvent (GLib.GType gtype)
		{
			OverrideKeyReleaseEvent (gtype, KeyReleaseEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool KeyReleaseEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool KeyReleaseEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnKeyReleaseEvent (new Gdk.EventKey(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideKeyReleaseEvent")]
		protected virtual bool OnKeyReleaseEvent (Gdk.EventKey evnt)
		{
			return InternalKeyReleaseEvent (evnt);
		}

		private bool InternalKeyReleaseEvent (Gdk.EventKey evnt)
		{
			KeyReleaseEventNativeDelegate unmanaged = class_abi.BaseOverride<KeyReleaseEventNativeDelegate>(this.LookupGType(), "key_release_event");
			if (unmanaged == null) return false;

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

		static EnterNotifyEventNativeDelegate EnterNotifyEvent_cb_delegate;
		static EnterNotifyEventNativeDelegate EnterNotifyEventVMCallback {
			get {
				if (EnterNotifyEvent_cb_delegate == null)
					EnterNotifyEvent_cb_delegate = new EnterNotifyEventNativeDelegate (EnterNotifyEvent_cb);
				return EnterNotifyEvent_cb_delegate;
			}
		}

		static void OverrideEnterNotifyEvent (GLib.GType gtype)
		{
			OverrideEnterNotifyEvent (gtype, EnterNotifyEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool EnterNotifyEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool EnterNotifyEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnEnterNotifyEvent (new Gdk.EventCrossing(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideEnterNotifyEvent")]
		protected virtual bool OnEnterNotifyEvent (Gdk.EventCrossing evnt)
		{
			return InternalEnterNotifyEvent (evnt);
		}

		private bool InternalEnterNotifyEvent (Gdk.EventCrossing evnt)
		{
			EnterNotifyEventNativeDelegate unmanaged = class_abi.BaseOverride<EnterNotifyEventNativeDelegate>(this.LookupGType(), "enter_notify_event");
			if (unmanaged == null) return false;

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

		static LeaveNotifyEventNativeDelegate LeaveNotifyEvent_cb_delegate;
		static LeaveNotifyEventNativeDelegate LeaveNotifyEventVMCallback {
			get {
				if (LeaveNotifyEvent_cb_delegate == null)
					LeaveNotifyEvent_cb_delegate = new LeaveNotifyEventNativeDelegate (LeaveNotifyEvent_cb);
				return LeaveNotifyEvent_cb_delegate;
			}
		}

		static void OverrideLeaveNotifyEvent (GLib.GType gtype)
		{
			OverrideLeaveNotifyEvent (gtype, LeaveNotifyEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool LeaveNotifyEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool LeaveNotifyEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnLeaveNotifyEvent (new Gdk.EventCrossing(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideLeaveNotifyEvent")]
		protected virtual bool OnLeaveNotifyEvent (Gdk.EventCrossing evnt)
		{
			return InternalLeaveNotifyEvent (evnt);
		}

		private bool InternalLeaveNotifyEvent (Gdk.EventCrossing evnt)
		{
			LeaveNotifyEventNativeDelegate unmanaged = class_abi.BaseOverride<LeaveNotifyEventNativeDelegate>(this.LookupGType(), "leave_notify_event");
			if (unmanaged == null) return false;

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

		static ConfigureEventNativeDelegate ConfigureEvent_cb_delegate;
		static ConfigureEventNativeDelegate ConfigureEventVMCallback {
			get {
				if (ConfigureEvent_cb_delegate == null)
					ConfigureEvent_cb_delegate = new ConfigureEventNativeDelegate (ConfigureEvent_cb);
				return ConfigureEvent_cb_delegate;
			}
		}

		static void OverrideConfigureEvent (GLib.GType gtype)
		{
			OverrideConfigureEvent (gtype, ConfigureEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ConfigureEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool ConfigureEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnConfigureEvent (new Gdk.EventConfigure(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideConfigureEvent")]
		protected virtual bool OnConfigureEvent (Gdk.EventConfigure evnt)
		{
			return InternalConfigureEvent (evnt);
		}

		private bool InternalConfigureEvent (Gdk.EventConfigure evnt)
		{
			ConfigureEventNativeDelegate unmanaged = class_abi.BaseOverride<ConfigureEventNativeDelegate>(this.LookupGType(), "configure_event");
			if (unmanaged == null) return false;

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

		static FocusInEventNativeDelegate FocusInEvent_cb_delegate;
		static FocusInEventNativeDelegate FocusInEventVMCallback {
			get {
				if (FocusInEvent_cb_delegate == null)
					FocusInEvent_cb_delegate = new FocusInEventNativeDelegate (FocusInEvent_cb);
				return FocusInEvent_cb_delegate;
			}
		}

		static void OverrideFocusInEvent (GLib.GType gtype)
		{
			OverrideFocusInEvent (gtype, FocusInEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool FocusInEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool FocusInEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnFocusInEvent (new Gdk.EventFocus(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideFocusInEvent")]
		protected virtual bool OnFocusInEvent (Gdk.EventFocus evnt)
		{
			return InternalFocusInEvent (evnt);
		}

		private bool InternalFocusInEvent (Gdk.EventFocus evnt)
		{
			FocusInEventNativeDelegate unmanaged = class_abi.BaseOverride<FocusInEventNativeDelegate>(this.LookupGType(), "focus_in_event");
			if (unmanaged == null) return false;

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

		static FocusOutEventNativeDelegate FocusOutEvent_cb_delegate;
		static FocusOutEventNativeDelegate FocusOutEventVMCallback {
			get {
				if (FocusOutEvent_cb_delegate == null)
					FocusOutEvent_cb_delegate = new FocusOutEventNativeDelegate (FocusOutEvent_cb);
				return FocusOutEvent_cb_delegate;
			}
		}

		static void OverrideFocusOutEvent (GLib.GType gtype)
		{
			OverrideFocusOutEvent (gtype, FocusOutEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool FocusOutEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool FocusOutEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnFocusOutEvent (new Gdk.EventFocus(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideFocusOutEvent")]
		protected virtual bool OnFocusOutEvent (Gdk.EventFocus evnt)
		{
			return InternalFocusOutEvent (evnt);
		}

		private bool InternalFocusOutEvent (Gdk.EventFocus evnt)
		{
			FocusOutEventNativeDelegate unmanaged = class_abi.BaseOverride<FocusOutEventNativeDelegate>(this.LookupGType(), "focus_out_event");
			if (unmanaged == null) return false;

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

		static MapEventNativeDelegate MapEvent_cb_delegate;
		static MapEventNativeDelegate MapEventVMCallback {
			get {
				if (MapEvent_cb_delegate == null)
					MapEvent_cb_delegate = new MapEventNativeDelegate (MapEvent_cb);
				return MapEvent_cb_delegate;
			}
		}

		static void OverrideMapEvent (GLib.GType gtype)
		{
			OverrideMapEvent (gtype, MapEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool MapEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool MapEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnMapEvent (Gdk.Event.GetEvent (evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideMapEvent")]
		protected virtual bool OnMapEvent (Gdk.Event evnt)
		{
			return InternalMapEvent (evnt);
		}

		private bool InternalMapEvent (Gdk.Event evnt)
		{
			MapEventNativeDelegate unmanaged = class_abi.BaseOverride<MapEventNativeDelegate>(this.LookupGType(), "map_event");
			if (unmanaged == null) return false;

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

		static UnmapEventNativeDelegate UnmapEvent_cb_delegate;
		static UnmapEventNativeDelegate UnmapEventVMCallback {
			get {
				if (UnmapEvent_cb_delegate == null)
					UnmapEvent_cb_delegate = new UnmapEventNativeDelegate (UnmapEvent_cb);
				return UnmapEvent_cb_delegate;
			}
		}

		static void OverrideUnmapEvent (GLib.GType gtype)
		{
			OverrideUnmapEvent (gtype, UnmapEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool UnmapEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool UnmapEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnUnmapEvent (Gdk.Event.GetEvent (evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideUnmapEvent")]
		protected virtual bool OnUnmapEvent (Gdk.Event evnt)
		{
			return InternalUnmapEvent (evnt);
		}

		private bool InternalUnmapEvent (Gdk.Event evnt)
		{
			UnmapEventNativeDelegate unmanaged = class_abi.BaseOverride<UnmapEventNativeDelegate>(this.LookupGType(), "unmap_event");
			if (unmanaged == null) return false;

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

		static PropertyNotifyEventNativeDelegate PropertyNotifyEvent_cb_delegate;
		static PropertyNotifyEventNativeDelegate PropertyNotifyEventVMCallback {
			get {
				if (PropertyNotifyEvent_cb_delegate == null)
					PropertyNotifyEvent_cb_delegate = new PropertyNotifyEventNativeDelegate (PropertyNotifyEvent_cb);
				return PropertyNotifyEvent_cb_delegate;
			}
		}

		static void OverridePropertyNotifyEvent (GLib.GType gtype)
		{
			OverridePropertyNotifyEvent (gtype, PropertyNotifyEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool PropertyNotifyEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool PropertyNotifyEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnPropertyNotifyEvent (new Gdk.EventProperty(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverridePropertyNotifyEvent")]
		protected virtual bool OnPropertyNotifyEvent (Gdk.EventProperty evnt)
		{
			return InternalPropertyNotifyEvent (evnt);
		}

		private bool InternalPropertyNotifyEvent (Gdk.EventProperty evnt)
		{
			PropertyNotifyEventNativeDelegate unmanaged = class_abi.BaseOverride<PropertyNotifyEventNativeDelegate>(this.LookupGType(), "property_notify_event");
			if (unmanaged == null) return false;

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

		static SelectionClearEventNativeDelegate SelectionClearEvent_cb_delegate;
		static SelectionClearEventNativeDelegate SelectionClearEventVMCallback {
			get {
				if (SelectionClearEvent_cb_delegate == null)
					SelectionClearEvent_cb_delegate = new SelectionClearEventNativeDelegate (SelectionClearEvent_cb);
				return SelectionClearEvent_cb_delegate;
			}
		}

		static void OverrideSelectionClearEvent (GLib.GType gtype)
		{
			OverrideSelectionClearEvent (gtype, SelectionClearEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SelectionClearEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool SelectionClearEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnSelectionClearEvent (new Gdk.EventSelection(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideSelectionClearEvent")]
		protected virtual bool OnSelectionClearEvent (Gdk.EventSelection evnt)
		{
			return InternalSelectionClearEvent (evnt);
		}

		private bool InternalSelectionClearEvent (Gdk.EventSelection evnt)
		{
			SelectionClearEventNativeDelegate unmanaged = class_abi.BaseOverride<SelectionClearEventNativeDelegate>(this.LookupGType(), "selection_clear_event");
			if (unmanaged == null) return false;

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

		static SelectionRequestEventNativeDelegate SelectionRequestEvent_cb_delegate;
		static SelectionRequestEventNativeDelegate SelectionRequestEventVMCallback {
			get {
				if (SelectionRequestEvent_cb_delegate == null)
					SelectionRequestEvent_cb_delegate = new SelectionRequestEventNativeDelegate (SelectionRequestEvent_cb);
				return SelectionRequestEvent_cb_delegate;
			}
		}

		static void OverrideSelectionRequestEvent (GLib.GType gtype)
		{
			OverrideSelectionRequestEvent (gtype, SelectionRequestEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SelectionRequestEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool SelectionRequestEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnSelectionRequestEvent (new Gdk.EventSelection(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideSelectionRequestEvent")]
		protected virtual bool OnSelectionRequestEvent (Gdk.EventSelection evnt)
		{
			return InternalSelectionRequestEvent (evnt);
		}

		private bool InternalSelectionRequestEvent (Gdk.EventSelection evnt)
		{
			SelectionRequestEventNativeDelegate unmanaged = class_abi.BaseOverride<SelectionRequestEventNativeDelegate>(this.LookupGType(), "selection_request_event");
			if (unmanaged == null) return false;

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

		static SelectionNotifyEventNativeDelegate SelectionNotifyEvent_cb_delegate;
		static SelectionNotifyEventNativeDelegate SelectionNotifyEventVMCallback {
			get {
				if (SelectionNotifyEvent_cb_delegate == null)
					SelectionNotifyEvent_cb_delegate = new SelectionNotifyEventNativeDelegate (SelectionNotifyEvent_cb);
				return SelectionNotifyEvent_cb_delegate;
			}
		}

		static void OverrideSelectionNotifyEvent (GLib.GType gtype)
		{
			OverrideSelectionNotifyEvent (gtype, SelectionNotifyEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SelectionNotifyEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool SelectionNotifyEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnSelectionNotifyEvent (new Gdk.EventSelection(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideSelectionNotifyEvent")]
		protected virtual bool OnSelectionNotifyEvent (Gdk.EventSelection evnt)
		{
			return InternalSelectionNotifyEvent (evnt);
		}

		private bool InternalSelectionNotifyEvent (Gdk.EventSelection evnt)
		{
			SelectionNotifyEventNativeDelegate unmanaged = class_abi.BaseOverride<SelectionNotifyEventNativeDelegate>(this.LookupGType(), "selection_notify_event");
			if (unmanaged == null) return false;

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

		static ProximityInEventNativeDelegate ProximityInEvent_cb_delegate;
		static ProximityInEventNativeDelegate ProximityInEventVMCallback {
			get {
				if (ProximityInEvent_cb_delegate == null)
					ProximityInEvent_cb_delegate = new ProximityInEventNativeDelegate (ProximityInEvent_cb);
				return ProximityInEvent_cb_delegate;
			}
		}

		static void OverrideProximityInEvent (GLib.GType gtype)
		{
			OverrideProximityInEvent (gtype, ProximityInEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ProximityInEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool ProximityInEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnProximityInEvent (new Gdk.EventProximity(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideProximityInEvent")]
		protected virtual bool OnProximityInEvent (Gdk.EventProximity evnt)
		{
			return InternalProximityInEvent (evnt);
		}

		private bool InternalProximityInEvent (Gdk.EventProximity evnt)
		{
			ProximityInEventNativeDelegate unmanaged = class_abi.BaseOverride<ProximityInEventNativeDelegate>(this.LookupGType(), "proximity_in_event");
			if (unmanaged == null) return false;

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

		static ProximityOutEventNativeDelegate ProximityOutEvent_cb_delegate;
		static ProximityOutEventNativeDelegate ProximityOutEventVMCallback {
			get {
				if (ProximityOutEvent_cb_delegate == null)
					ProximityOutEvent_cb_delegate = new ProximityOutEventNativeDelegate (ProximityOutEvent_cb);
				return ProximityOutEvent_cb_delegate;
			}
		}

		static void OverrideProximityOutEvent (GLib.GType gtype)
		{
			OverrideProximityOutEvent (gtype, ProximityOutEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ProximityOutEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool ProximityOutEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnProximityOutEvent (new Gdk.EventProximity(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideProximityOutEvent")]
		protected virtual bool OnProximityOutEvent (Gdk.EventProximity evnt)
		{
			return InternalProximityOutEvent (evnt);
		}

		private bool InternalProximityOutEvent (Gdk.EventProximity evnt)
		{
			ProximityOutEventNativeDelegate unmanaged = class_abi.BaseOverride<ProximityOutEventNativeDelegate>(this.LookupGType(), "proximity_out_event");
			if (unmanaged == null) return false;

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

		static VisibilityNotifyEventNativeDelegate VisibilityNotifyEvent_cb_delegate;
		static VisibilityNotifyEventNativeDelegate VisibilityNotifyEventVMCallback {
			get {
				if (VisibilityNotifyEvent_cb_delegate == null)
					VisibilityNotifyEvent_cb_delegate = new VisibilityNotifyEventNativeDelegate (VisibilityNotifyEvent_cb);
				return VisibilityNotifyEvent_cb_delegate;
			}
		}

		static void OverrideVisibilityNotifyEvent (GLib.GType gtype)
		{
			OverrideVisibilityNotifyEvent (gtype, VisibilityNotifyEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool VisibilityNotifyEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool VisibilityNotifyEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnVisibilityNotifyEvent (new Gdk.EventVisibility(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideVisibilityNotifyEvent")]
		protected virtual bool OnVisibilityNotifyEvent (Gdk.EventVisibility evnt)
		{
			return InternalVisibilityNotifyEvent (evnt);
		}

		private bool InternalVisibilityNotifyEvent (Gdk.EventVisibility evnt)
		{
			VisibilityNotifyEventNativeDelegate unmanaged = class_abi.BaseOverride<VisibilityNotifyEventNativeDelegate>(this.LookupGType(), "visibility_notify_event");
			if (unmanaged == null) return false;

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

		static WindowStateEventNativeDelegate WindowStateEvent_cb_delegate;
		static WindowStateEventNativeDelegate WindowStateEventVMCallback {
			get {
				if (WindowStateEvent_cb_delegate == null)
					WindowStateEvent_cb_delegate = new WindowStateEventNativeDelegate (WindowStateEvent_cb);
				return WindowStateEvent_cb_delegate;
			}
		}

		static void OverrideWindowStateEvent (GLib.GType gtype)
		{
			OverrideWindowStateEvent (gtype, WindowStateEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool WindowStateEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool WindowStateEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnWindowStateEvent (new Gdk.EventWindowState(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideWindowStateEvent")]
		protected virtual bool OnWindowStateEvent (Gdk.EventWindowState evnt)
		{
			return InternalWindowStateEvent (evnt);
		}

		private bool InternalWindowStateEvent (Gdk.EventWindowState evnt)
		{
			WindowStateEventNativeDelegate unmanaged = class_abi.BaseOverride<WindowStateEventNativeDelegate>(this.LookupGType(), "window_state_event");
			if (unmanaged == null) return false;

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

		static DamageEventNativeDelegate DamageEvent_cb_delegate;
		static DamageEventNativeDelegate DamageEventVMCallback {
			get {
				if (DamageEvent_cb_delegate == null)
					DamageEvent_cb_delegate = new DamageEventNativeDelegate (DamageEvent_cb);
				return DamageEvent_cb_delegate;
			}
		}

		static void OverrideDamageEvent (GLib.GType gtype)
		{
			OverrideDamageEvent (gtype, DamageEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DamageEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool DamageEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnDamageEvent (new Gdk.EventExpose(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDamageEvent")]
		protected virtual bool OnDamageEvent (Gdk.EventExpose evnt)
		{
			return InternalDamageEvent (evnt);
		}

		private bool InternalDamageEvent (Gdk.EventExpose evnt)
		{
			DamageEventNativeDelegate unmanaged = class_abi.BaseOverride<DamageEventNativeDelegate>(this.LookupGType(), "damage_event");
			if (unmanaged == null) return false;

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

		static GrabBrokenEventNativeDelegate GrabBrokenEvent_cb_delegate;
		static GrabBrokenEventNativeDelegate GrabBrokenEventVMCallback {
			get {
				if (GrabBrokenEvent_cb_delegate == null)
					GrabBrokenEvent_cb_delegate = new GrabBrokenEventNativeDelegate (GrabBrokenEvent_cb);
				return GrabBrokenEvent_cb_delegate;
			}
		}

		static void OverrideGrabBrokenEvent (GLib.GType gtype)
		{
			OverrideGrabBrokenEvent (gtype, GrabBrokenEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GrabBrokenEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool GrabBrokenEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnGrabBrokenEvent (new Gdk.EventGrabBroken(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGrabBrokenEvent")]
		protected virtual bool OnGrabBrokenEvent (Gdk.EventGrabBroken evnt)
		{
			return InternalGrabBrokenEvent (evnt);
		}

		private bool InternalGrabBrokenEvent (Gdk.EventGrabBroken evnt)
		{
			GrabBrokenEventNativeDelegate unmanaged = class_abi.BaseOverride<GrabBrokenEventNativeDelegate>(this.LookupGType(), "grab_broken_event");
			if (unmanaged == null) return false;

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

		static SelectionGetNativeDelegate SelectionGet_cb_delegate;
		static SelectionGetNativeDelegate SelectionGetVMCallback {
			get {
				if (SelectionGet_cb_delegate == null)
					SelectionGet_cb_delegate = new SelectionGetNativeDelegate (SelectionGet_cb);
				return SelectionGet_cb_delegate;
			}
		}

		static void OverrideSelectionGet (GLib.GType gtype)
		{
			OverrideSelectionGet (gtype, SelectionGetVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SelectionGetNativeDelegate (IntPtr inst, IntPtr selection_data, uint info, uint time_);

		static void SelectionGet_cb (IntPtr inst, IntPtr selection_data, uint info, uint time_)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnSelectionGet (selection_data == IntPtr.Zero ? null : (Gtk.SelectionData) GLib.Opaque.GetOpaque (selection_data, typeof (Gtk.SelectionData), false), info, time_);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideSelectionGet")]
		protected virtual void OnSelectionGet (Gtk.SelectionData selection_data, uint info, uint time_)
		{
			InternalSelectionGet (selection_data, info, time_);
		}

		private void InternalSelectionGet (Gtk.SelectionData selection_data, uint info, uint time_)
		{
			SelectionGetNativeDelegate unmanaged = class_abi.BaseOverride<SelectionGetNativeDelegate>(this.LookupGType(), "selection_get");
			if (unmanaged == null) return;

			unmanaged (this.Handle, selection_data == null ? IntPtr.Zero : selection_data.Handle, info, time_);
		}

		static SelectionReceivedNativeDelegate SelectionReceived_cb_delegate;
		static SelectionReceivedNativeDelegate SelectionReceivedVMCallback {
			get {
				if (SelectionReceived_cb_delegate == null)
					SelectionReceived_cb_delegate = new SelectionReceivedNativeDelegate (SelectionReceived_cb);
				return SelectionReceived_cb_delegate;
			}
		}

		static void OverrideSelectionReceived (GLib.GType gtype)
		{
			OverrideSelectionReceived (gtype, SelectionReceivedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SelectionReceivedNativeDelegate (IntPtr inst, IntPtr selection_data, uint time_);

		static void SelectionReceived_cb (IntPtr inst, IntPtr selection_data, uint time_)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnSelectionReceived (selection_data == IntPtr.Zero ? null : (Gtk.SelectionData) GLib.Opaque.GetOpaque (selection_data, typeof (Gtk.SelectionData), false), time_);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideSelectionReceived")]
		protected virtual void OnSelectionReceived (Gtk.SelectionData selection_data, uint time_)
		{
			InternalSelectionReceived (selection_data, time_);
		}

		private void InternalSelectionReceived (Gtk.SelectionData selection_data, uint time_)
		{
			SelectionReceivedNativeDelegate unmanaged = class_abi.BaseOverride<SelectionReceivedNativeDelegate>(this.LookupGType(), "selection_received");
			if (unmanaged == null) return;

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

		static DragBeginNativeDelegate DragBegin_cb_delegate;
		static DragBeginNativeDelegate DragBeginVMCallback {
			get {
				if (DragBegin_cb_delegate == null)
					DragBegin_cb_delegate = new DragBeginNativeDelegate (DragBegin_cb);
				return DragBegin_cb_delegate;
			}
		}

		static void OverrideDragBegin (GLib.GType gtype)
		{
			OverrideDragBegin (gtype, DragBeginVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DragBeginNativeDelegate (IntPtr inst, IntPtr context);

		static void DragBegin_cb (IntPtr inst, IntPtr context)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDragBegin (GLib.Object.GetObject(context) as Gdk.DragContext);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragBegin")]
		protected virtual void OnDragBegin (Gdk.DragContext context)
		{
			InternalDragBegin (context);
		}

		private void InternalDragBegin (Gdk.DragContext context)
		{
			DragBeginNativeDelegate unmanaged = class_abi.BaseOverride<DragBeginNativeDelegate>(this.LookupGType(), "drag_begin");
			if (unmanaged == null) return;

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

		static DragEndNativeDelegate DragEnd_cb_delegate;
		static DragEndNativeDelegate DragEndVMCallback {
			get {
				if (DragEnd_cb_delegate == null)
					DragEnd_cb_delegate = new DragEndNativeDelegate (DragEnd_cb);
				return DragEnd_cb_delegate;
			}
		}

		static void OverrideDragEnd (GLib.GType gtype)
		{
			OverrideDragEnd (gtype, DragEndVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DragEndNativeDelegate (IntPtr inst, IntPtr context);

		static void DragEnd_cb (IntPtr inst, IntPtr context)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDragEnd (GLib.Object.GetObject(context) as Gdk.DragContext);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragEnd")]
		protected virtual void OnDragEnd (Gdk.DragContext context)
		{
			InternalDragEnd (context);
		}

		private void InternalDragEnd (Gdk.DragContext context)
		{
			DragEndNativeDelegate unmanaged = class_abi.BaseOverride<DragEndNativeDelegate>(this.LookupGType(), "drag_end");
			if (unmanaged == null) return;

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

		static DragDataGetNativeDelegate DragDataGet_cb_delegate;
		static DragDataGetNativeDelegate DragDataGetVMCallback {
			get {
				if (DragDataGet_cb_delegate == null)
					DragDataGet_cb_delegate = new DragDataGetNativeDelegate (DragDataGet_cb);
				return DragDataGet_cb_delegate;
			}
		}

		static void OverrideDragDataGet (GLib.GType gtype)
		{
			OverrideDragDataGet (gtype, DragDataGetVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DragDataGetNativeDelegate (IntPtr inst, IntPtr context, IntPtr selection_data, uint info, uint time_);

		static void DragDataGet_cb (IntPtr inst, IntPtr context, IntPtr selection_data, uint info, uint time_)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDragDataGet (GLib.Object.GetObject(context) as Gdk.DragContext, selection_data == IntPtr.Zero ? null : (Gtk.SelectionData) GLib.Opaque.GetOpaque (selection_data, typeof (Gtk.SelectionData), false), info, time_);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragDataGet")]
		protected virtual void OnDragDataGet (Gdk.DragContext context, Gtk.SelectionData selection_data, uint info, uint time_)
		{
			InternalDragDataGet (context, selection_data, info, time_);
		}

		private void InternalDragDataGet (Gdk.DragContext context, Gtk.SelectionData selection_data, uint info, uint time_)
		{
			DragDataGetNativeDelegate unmanaged = class_abi.BaseOverride<DragDataGetNativeDelegate>(this.LookupGType(), "drag_data_get");
			if (unmanaged == null) return;

			unmanaged (this.Handle, context == null ? IntPtr.Zero : context.Handle, selection_data == null ? IntPtr.Zero : selection_data.Handle, info, time_);
		}

		static DragDataDeleteNativeDelegate DragDataDelete_cb_delegate;
		static DragDataDeleteNativeDelegate DragDataDeleteVMCallback {
			get {
				if (DragDataDelete_cb_delegate == null)
					DragDataDelete_cb_delegate = new DragDataDeleteNativeDelegate (DragDataDelete_cb);
				return DragDataDelete_cb_delegate;
			}
		}

		static void OverrideDragDataDelete (GLib.GType gtype)
		{
			OverrideDragDataDelete (gtype, DragDataDeleteVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DragDataDeleteNativeDelegate (IntPtr inst, IntPtr context);

		static void DragDataDelete_cb (IntPtr inst, IntPtr context)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDragDataDelete (GLib.Object.GetObject(context) as Gdk.DragContext);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragDataDelete")]
		protected virtual void OnDragDataDelete (Gdk.DragContext context)
		{
			InternalDragDataDelete (context);
		}

		private void InternalDragDataDelete (Gdk.DragContext context)
		{
			DragDataDeleteNativeDelegate unmanaged = class_abi.BaseOverride<DragDataDeleteNativeDelegate>(this.LookupGType(), "drag_data_delete");
			if (unmanaged == null) return;

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

		static DragLeaveNativeDelegate DragLeave_cb_delegate;
		static DragLeaveNativeDelegate DragLeaveVMCallback {
			get {
				if (DragLeave_cb_delegate == null)
					DragLeave_cb_delegate = new DragLeaveNativeDelegate (DragLeave_cb);
				return DragLeave_cb_delegate;
			}
		}

		static void OverrideDragLeave (GLib.GType gtype)
		{
			OverrideDragLeave (gtype, DragLeaveVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DragLeaveNativeDelegate (IntPtr inst, IntPtr context, uint time_);

		static void DragLeave_cb (IntPtr inst, IntPtr context, uint time_)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDragLeave (GLib.Object.GetObject(context) as Gdk.DragContext, time_);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragLeave")]
		protected virtual void OnDragLeave (Gdk.DragContext context, uint time_)
		{
			InternalDragLeave (context, time_);
		}

		private void InternalDragLeave (Gdk.DragContext context, uint time_)
		{
			DragLeaveNativeDelegate unmanaged = class_abi.BaseOverride<DragLeaveNativeDelegate>(this.LookupGType(), "drag_leave");
			if (unmanaged == null) return;

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

		static DragMotionNativeDelegate DragMotion_cb_delegate;
		static DragMotionNativeDelegate DragMotionVMCallback {
			get {
				if (DragMotion_cb_delegate == null)
					DragMotion_cb_delegate = new DragMotionNativeDelegate (DragMotion_cb);
				return DragMotion_cb_delegate;
			}
		}

		static void OverrideDragMotion (GLib.GType gtype)
		{
			OverrideDragMotion (gtype, DragMotionVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DragMotionNativeDelegate (IntPtr inst, IntPtr context, int x, int y, uint time_);

		static bool DragMotion_cb (IntPtr inst, IntPtr context, int x, int y, uint time_)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnDragMotion (GLib.Object.GetObject(context) as Gdk.DragContext, x, y, time_);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragMotion")]
		protected virtual bool OnDragMotion (Gdk.DragContext context, int x, int y, uint time_)
		{
			return InternalDragMotion (context, x, y, time_);
		}

		private bool InternalDragMotion (Gdk.DragContext context, int x, int y, uint time_)
		{
			DragMotionNativeDelegate unmanaged = class_abi.BaseOverride<DragMotionNativeDelegate>(this.LookupGType(), "drag_motion");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, context == null ? IntPtr.Zero : context.Handle, x, y, time_);
			return __result;
		}

		static DragDropNativeDelegate DragDrop_cb_delegate;
		static DragDropNativeDelegate DragDropVMCallback {
			get {
				if (DragDrop_cb_delegate == null)
					DragDrop_cb_delegate = new DragDropNativeDelegate (DragDrop_cb);
				return DragDrop_cb_delegate;
			}
		}

		static void OverrideDragDrop (GLib.GType gtype)
		{
			OverrideDragDrop (gtype, DragDropVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DragDropNativeDelegate (IntPtr inst, IntPtr context, int x, int y, uint time_);

		static bool DragDrop_cb (IntPtr inst, IntPtr context, int x, int y, uint time_)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnDragDrop (GLib.Object.GetObject(context) as Gdk.DragContext, x, y, time_);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragDrop")]
		protected virtual bool OnDragDrop (Gdk.DragContext context, int x, int y, uint time_)
		{
			return InternalDragDrop (context, x, y, time_);
		}

		private bool InternalDragDrop (Gdk.DragContext context, int x, int y, uint time_)
		{
			DragDropNativeDelegate unmanaged = class_abi.BaseOverride<DragDropNativeDelegate>(this.LookupGType(), "drag_drop");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, context == null ? IntPtr.Zero : context.Handle, x, y, time_);
			return __result;
		}

		static DragDataReceivedNativeDelegate DragDataReceived_cb_delegate;
		static DragDataReceivedNativeDelegate DragDataReceivedVMCallback {
			get {
				if (DragDataReceived_cb_delegate == null)
					DragDataReceived_cb_delegate = new DragDataReceivedNativeDelegate (DragDataReceived_cb);
				return DragDataReceived_cb_delegate;
			}
		}

		static void OverrideDragDataReceived (GLib.GType gtype)
		{
			OverrideDragDataReceived (gtype, DragDataReceivedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DragDataReceivedNativeDelegate (IntPtr inst, IntPtr context, int x, int y, IntPtr selection_data, uint info, uint time_);

		static void DragDataReceived_cb (IntPtr inst, IntPtr context, int x, int y, IntPtr selection_data, uint info, uint time_)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnDragDataReceived (GLib.Object.GetObject(context) as Gdk.DragContext, x, y, selection_data == IntPtr.Zero ? null : (Gtk.SelectionData) GLib.Opaque.GetOpaque (selection_data, typeof (Gtk.SelectionData), false), info, time_);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragDataReceived")]
		protected virtual void OnDragDataReceived (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint info, uint time_)
		{
			InternalDragDataReceived (context, x, y, selection_data, info, time_);
		}

		private void InternalDragDataReceived (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint info, uint time_)
		{
			DragDataReceivedNativeDelegate unmanaged = class_abi.BaseOverride<DragDataReceivedNativeDelegate>(this.LookupGType(), "drag_data_received");
			if (unmanaged == null) return;

			unmanaged (this.Handle, context == null ? IntPtr.Zero : context.Handle, x, y, selection_data == null ? IntPtr.Zero : selection_data.Handle, info, time_);
		}

		static DragFailedNativeDelegate DragFailed_cb_delegate;
		static DragFailedNativeDelegate DragFailedVMCallback {
			get {
				if (DragFailed_cb_delegate == null)
					DragFailed_cb_delegate = new DragFailedNativeDelegate (DragFailed_cb);
				return DragFailed_cb_delegate;
			}
		}

		static void OverrideDragFailed (GLib.GType gtype)
		{
			OverrideDragFailed (gtype, DragFailedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DragFailedNativeDelegate (IntPtr inst, IntPtr context, int result);

		static bool DragFailed_cb (IntPtr inst, IntPtr context, int result)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnDragFailed (GLib.Object.GetObject(context) as Gdk.DragContext, (Gtk.DragResult) result);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideDragFailed")]
		protected virtual bool OnDragFailed (Gdk.DragContext context, Gtk.DragResult result)
		{
			return InternalDragFailed (context, result);
		}

		private bool InternalDragFailed (Gdk.DragContext context, Gtk.DragResult result)
		{
			DragFailedNativeDelegate unmanaged = class_abi.BaseOverride<DragFailedNativeDelegate>(this.LookupGType(), "drag_failed");
			if (unmanaged == null) return false;

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

		static PopupMenuNativeDelegate PopupMenu_cb_delegate;
		static PopupMenuNativeDelegate PopupMenuVMCallback {
			get {
				if (PopupMenu_cb_delegate == null)
					PopupMenu_cb_delegate = new PopupMenuNativeDelegate (PopupMenu_cb);
				return PopupMenu_cb_delegate;
			}
		}

		static void OverridePopupMenu (GLib.GType gtype)
		{
			OverridePopupMenu (gtype, PopupMenuVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverridePopupMenu")]
		protected virtual bool OnPopupMenu ()
		{
			return InternalPopupMenu ();
		}

		private bool InternalPopupMenu ()
		{
			PopupMenuNativeDelegate unmanaged = class_abi.BaseOverride<PopupMenuNativeDelegate>(this.LookupGType(), "popup_menu");
			if (unmanaged == null) return false;

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

		static HelpShownNativeDelegate HelpShown_cb_delegate;
		static HelpShownNativeDelegate HelpShownVMCallback {
			get {
				if (HelpShown_cb_delegate == null)
					HelpShown_cb_delegate = new HelpShownNativeDelegate (HelpShown_cb);
				return HelpShown_cb_delegate;
			}
		}

		static void OverrideHelpShown (GLib.GType gtype)
		{
			OverrideHelpShown (gtype, HelpShownVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool HelpShownNativeDelegate (IntPtr inst, int help_type);

		static bool HelpShown_cb (IntPtr inst, int help_type)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnHelpShown ((Gtk.WidgetHelpType) help_type);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideHelpShown")]
		protected virtual bool OnHelpShown (Gtk.WidgetHelpType help_type)
		{
			return InternalHelpShown (help_type);
		}

		private bool InternalHelpShown (Gtk.WidgetHelpType help_type)
		{
			HelpShownNativeDelegate unmanaged = class_abi.BaseOverride<HelpShownNativeDelegate>(this.LookupGType(), "show_help");
			if (unmanaged == null) return false;

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

		static GetAccessibleNativeDelegate GetAccessible_cb_delegate;
		static GetAccessibleNativeDelegate GetAccessibleVMCallback {
			get {
				if (GetAccessible_cb_delegate == null)
					GetAccessible_cb_delegate = new GetAccessibleNativeDelegate (GetAccessible_cb);
				return GetAccessible_cb_delegate;
			}
		}

		static void OverrideGetAccessible (GLib.GType gtype)
		{
			OverrideGetAccessible (gtype, GetAccessibleVMCallback);
		}

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

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

		static IntPtr GetAccessible_cb (IntPtr inst)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				Atk.Object __result;
				__result = __obj.OnGetAccessible ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGetAccessible")]
		protected virtual Atk.Object OnGetAccessible ()
		{
			return InternalGetAccessible ();
		}

		private Atk.Object InternalGetAccessible ()
		{
			GetAccessibleNativeDelegate unmanaged = class_abi.BaseOverride<GetAccessibleNativeDelegate>(this.LookupGType(), "get_accessible");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return GLib.Object.GetObject(__result) as Atk.Object;
		}

		static ScreenChangedNativeDelegate ScreenChanged_cb_delegate;
		static ScreenChangedNativeDelegate ScreenChangedVMCallback {
			get {
				if (ScreenChanged_cb_delegate == null)
					ScreenChanged_cb_delegate = new ScreenChangedNativeDelegate (ScreenChanged_cb);
				return ScreenChanged_cb_delegate;
			}
		}

		static void OverrideScreenChanged (GLib.GType gtype)
		{
			OverrideScreenChanged (gtype, ScreenChangedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ScreenChangedNativeDelegate (IntPtr inst, IntPtr previous_screen);

		static void ScreenChanged_cb (IntPtr inst, IntPtr previous_screen)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnScreenChanged (GLib.Object.GetObject(previous_screen) as Gdk.Screen);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideScreenChanged")]
		protected virtual void OnScreenChanged (Gdk.Screen previous_screen)
		{
			InternalScreenChanged (previous_screen);
		}

		private void InternalScreenChanged (Gdk.Screen previous_screen)
		{
			ScreenChangedNativeDelegate unmanaged = class_abi.BaseOverride<ScreenChangedNativeDelegate>(this.LookupGType(), "screen_changed");
			if (unmanaged == null) return;

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

		static AccelCanActivateNativeDelegate AccelCanActivate_cb_delegate;
		static AccelCanActivateNativeDelegate AccelCanActivateVMCallback {
			get {
				if (AccelCanActivate_cb_delegate == null)
					AccelCanActivate_cb_delegate = new AccelCanActivateNativeDelegate (AccelCanActivate_cb);
				return AccelCanActivate_cb_delegate;
			}
		}

		static void OverrideAccelCanActivate (GLib.GType gtype)
		{
			OverrideAccelCanActivate (gtype, AccelCanActivateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool AccelCanActivateNativeDelegate (IntPtr inst, uint signal_id);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideAccelCanActivate")]
		protected virtual bool OnAccelCanActivate (uint signal_id)
		{
			return InternalAccelCanActivate (signal_id);
		}

		private bool InternalAccelCanActivate (uint signal_id)
		{
			AccelCanActivateNativeDelegate unmanaged = class_abi.BaseOverride<AccelCanActivateNativeDelegate>(this.LookupGType(), "can_activate_accel");
			if (unmanaged == null) return false;

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

		static CompositedChangedNativeDelegate CompositedChanged_cb_delegate;
		static CompositedChangedNativeDelegate CompositedChangedVMCallback {
			get {
				if (CompositedChanged_cb_delegate == null)
					CompositedChanged_cb_delegate = new CompositedChangedNativeDelegate (CompositedChanged_cb);
				return CompositedChanged_cb_delegate;
			}
		}

		static void OverrideCompositedChanged (GLib.GType gtype)
		{
			OverrideCompositedChanged (gtype, CompositedChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideCompositedChanged")]
		protected virtual void OnCompositedChanged ()
		{
			InternalCompositedChanged ();
		}

		private void InternalCompositedChanged ()
		{
			CompositedChangedNativeDelegate unmanaged = class_abi.BaseOverride<CompositedChangedNativeDelegate>(this.LookupGType(), "composited_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static QueryTooltipNativeDelegate QueryTooltip_cb_delegate;
		static QueryTooltipNativeDelegate QueryTooltipVMCallback {
			get {
				if (QueryTooltip_cb_delegate == null)
					QueryTooltip_cb_delegate = new QueryTooltipNativeDelegate (QueryTooltip_cb);
				return QueryTooltip_cb_delegate;
			}
		}

		static void OverrideQueryTooltip (GLib.GType gtype)
		{
			OverrideQueryTooltip (gtype, QueryTooltipVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool QueryTooltipNativeDelegate (IntPtr inst, int x, int y, bool keyboard_tooltip, IntPtr tooltip);

		static bool QueryTooltip_cb (IntPtr inst, int x, int y, bool keyboard_tooltip, IntPtr tooltip)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnQueryTooltip (x, y, keyboard_tooltip, GLib.Object.GetObject(tooltip) as Gtk.Tooltip);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideQueryTooltip")]
		protected virtual bool OnQueryTooltip (int x, int y, bool keyboard_tooltip, Gtk.Tooltip tooltip)
		{
			return InternalQueryTooltip (x, y, keyboard_tooltip, tooltip);
		}

		private bool InternalQueryTooltip (int x, int y, bool keyboard_tooltip, Gtk.Tooltip tooltip)
		{
			QueryTooltipNativeDelegate unmanaged = class_abi.BaseOverride<QueryTooltipNativeDelegate>(this.LookupGType(), "query_tooltip");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, x, y, keyboard_tooltip, tooltip == null ? IntPtr.Zero : tooltip.Handle);
			return __result;
		}

		static ComputeExpandNativeDelegate ComputeExpand_cb_delegate;
		static ComputeExpandNativeDelegate ComputeExpandVMCallback {
			get {
				if (ComputeExpand_cb_delegate == null)
					ComputeExpand_cb_delegate = new ComputeExpandNativeDelegate (ComputeExpand_cb);
				return ComputeExpand_cb_delegate;
			}
		}

		static void OverrideComputeExpand (GLib.GType gtype)
		{
			OverrideComputeExpand (gtype, ComputeExpandVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ComputeExpandNativeDelegate (IntPtr inst, out bool hexpand_p, out bool vexpand_p);

		static void ComputeExpand_cb (IntPtr inst, out bool hexpand_p, out bool vexpand_p)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnComputeExpand (out hexpand_p, out vexpand_p);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideComputeExpand")]
		protected virtual void OnComputeExpand (out bool hexpand_p, out bool vexpand_p)
		{
			InternalComputeExpand (out hexpand_p, out vexpand_p);
		}

		private void InternalComputeExpand (out bool hexpand_p, out bool vexpand_p)
		{
			ComputeExpandNativeDelegate unmanaged = class_abi.BaseOverride<ComputeExpandNativeDelegate>(this.LookupGType(), "compute_expand");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out hexpand_p, out vexpand_p);
		}

		static AdjustSizeRequestNativeDelegate AdjustSizeRequest_cb_delegate;
		static AdjustSizeRequestNativeDelegate AdjustSizeRequestVMCallback {
			get {
				if (AdjustSizeRequest_cb_delegate == null)
					AdjustSizeRequest_cb_delegate = new AdjustSizeRequestNativeDelegate (AdjustSizeRequest_cb);
				return AdjustSizeRequest_cb_delegate;
			}
		}

		static void OverrideAdjustSizeRequest (GLib.GType gtype)
		{
			OverrideAdjustSizeRequest (gtype, AdjustSizeRequestVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AdjustSizeRequestNativeDelegate (IntPtr inst, int orientation, out int minimum_size, out int natural_size);

		static void AdjustSizeRequest_cb (IntPtr inst, int orientation, out int minimum_size, out int natural_size)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnAdjustSizeRequest ((Gtk.Orientation) orientation, out minimum_size, out natural_size);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideAdjustSizeRequest")]
		protected virtual void OnAdjustSizeRequest (Gtk.Orientation orientation, out int minimum_size, out int natural_size)
		{
			InternalAdjustSizeRequest (orientation, out minimum_size, out natural_size);
		}

		private void InternalAdjustSizeRequest (Gtk.Orientation orientation, out int minimum_size, out int natural_size)
		{
			AdjustSizeRequestNativeDelegate unmanaged = class_abi.BaseOverride<AdjustSizeRequestNativeDelegate>(this.LookupGType(), "adjust_size_request");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, (int) orientation, out minimum_size, out natural_size);
		}

		static AdjustSizeAllocationNativeDelegate AdjustSizeAllocation_cb_delegate;
		static AdjustSizeAllocationNativeDelegate AdjustSizeAllocationVMCallback {
			get {
				if (AdjustSizeAllocation_cb_delegate == null)
					AdjustSizeAllocation_cb_delegate = new AdjustSizeAllocationNativeDelegate (AdjustSizeAllocation_cb);
				return AdjustSizeAllocation_cb_delegate;
			}
		}

		static void OverrideAdjustSizeAllocation (GLib.GType gtype)
		{
			OverrideAdjustSizeAllocation (gtype, AdjustSizeAllocationVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AdjustSizeAllocationNativeDelegate (IntPtr inst, int orientation, out int minimum_size, out int natural_size, out int allocated_pos, out int allocated_size);

		static void AdjustSizeAllocation_cb (IntPtr inst, int orientation, out int minimum_size, out int natural_size, out int allocated_pos, out int allocated_size)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnAdjustSizeAllocation ((Gtk.Orientation) orientation, out minimum_size, out natural_size, out allocated_pos, out allocated_size);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideAdjustSizeAllocation")]
		protected virtual void OnAdjustSizeAllocation (Gtk.Orientation orientation, out int minimum_size, out int natural_size, out int allocated_pos, out int allocated_size)
		{
			InternalAdjustSizeAllocation (orientation, out minimum_size, out natural_size, out allocated_pos, out allocated_size);
		}

		private void InternalAdjustSizeAllocation (Gtk.Orientation orientation, out int minimum_size, out int natural_size, out int allocated_pos, out int allocated_size)
		{
			AdjustSizeAllocationNativeDelegate unmanaged = class_abi.BaseOverride<AdjustSizeAllocationNativeDelegate>(this.LookupGType(), "adjust_size_allocation");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, (int) orientation, out minimum_size, out natural_size, out allocated_pos, out allocated_size);
		}

		static StyleUpdatedNativeDelegate StyleUpdated_cb_delegate;
		static StyleUpdatedNativeDelegate StyleUpdatedVMCallback {
			get {
				if (StyleUpdated_cb_delegate == null)
					StyleUpdated_cb_delegate = new StyleUpdatedNativeDelegate (StyleUpdated_cb);
				return StyleUpdated_cb_delegate;
			}
		}

		static void OverrideStyleUpdated (GLib.GType gtype)
		{
			OverrideStyleUpdated (gtype, StyleUpdatedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideStyleUpdated")]
		protected virtual void OnStyleUpdated ()
		{
			InternalStyleUpdated ();
		}

		private void InternalStyleUpdated ()
		{
			StyleUpdatedNativeDelegate unmanaged = class_abi.BaseOverride<StyleUpdatedNativeDelegate>(this.LookupGType(), "style_updated");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static TouchEventNativeDelegate TouchEvent_cb_delegate;
		static TouchEventNativeDelegate TouchEventVMCallback {
			get {
				if (TouchEvent_cb_delegate == null)
					TouchEvent_cb_delegate = new TouchEventNativeDelegate (TouchEvent_cb);
				return TouchEvent_cb_delegate;
			}
		}

		static void OverrideTouchEvent (GLib.GType gtype)
		{
			OverrideTouchEvent (gtype, TouchEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool TouchEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool TouchEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				bool __result;
				__result = __obj.OnTouchEvent (Gdk.Event.GetEvent (evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideTouchEvent")]
		protected virtual bool OnTouchEvent (Gdk.Event evnt)
		{
			return InternalTouchEvent (evnt);
		}

		private bool InternalTouchEvent (Gdk.Event evnt)
		{
			TouchEventNativeDelegate unmanaged = class_abi.BaseOverride<TouchEventNativeDelegate>(this.LookupGType(), "touch_event");
			if (unmanaged == null) return false;

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

		static GetPreferredHeightAndBaselineForWidthNativeDelegate GetPreferredHeightAndBaselineForWidth_cb_delegate;
		static GetPreferredHeightAndBaselineForWidthNativeDelegate GetPreferredHeightAndBaselineForWidthVMCallback {
			get {
				if (GetPreferredHeightAndBaselineForWidth_cb_delegate == null)
					GetPreferredHeightAndBaselineForWidth_cb_delegate = new GetPreferredHeightAndBaselineForWidthNativeDelegate (GetPreferredHeightAndBaselineForWidth_cb);
				return GetPreferredHeightAndBaselineForWidth_cb_delegate;
			}
		}

		static void OverrideGetPreferredHeightAndBaselineForWidth (GLib.GType gtype)
		{
			OverrideGetPreferredHeightAndBaselineForWidth (gtype, GetPreferredHeightAndBaselineForWidthVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetPreferredHeightAndBaselineForWidthNativeDelegate (IntPtr inst, int width, out int minimum_height, out int natural_height, out int minimum_baseline, out int natural_baseline);

		static void GetPreferredHeightAndBaselineForWidth_cb (IntPtr inst, int width, out int minimum_height, out int natural_height, out int minimum_baseline, out int natural_baseline)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnGetPreferredHeightAndBaselineForWidth (width, out minimum_height, out natural_height, out minimum_baseline, out natural_baseline);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideGetPreferredHeightAndBaselineForWidth")]
		protected virtual void OnGetPreferredHeightAndBaselineForWidth (int width, out int minimum_height, out int natural_height, out int minimum_baseline, out int natural_baseline)
		{
			InternalGetPreferredHeightAndBaselineForWidth (width, out minimum_height, out natural_height, out minimum_baseline, out natural_baseline);
		}

		private void InternalGetPreferredHeightAndBaselineForWidth (int width, out int minimum_height, out int natural_height, out int minimum_baseline, out int natural_baseline)
		{
			GetPreferredHeightAndBaselineForWidthNativeDelegate unmanaged = class_abi.BaseOverride<GetPreferredHeightAndBaselineForWidthNativeDelegate>(this.LookupGType(), "get_preferred_height_and_baseline_for_width");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, width, out minimum_height, out natural_height, out minimum_baseline, out natural_baseline);
		}

		static AdjustBaselineRequestNativeDelegate AdjustBaselineRequest_cb_delegate;
		static AdjustBaselineRequestNativeDelegate AdjustBaselineRequestVMCallback {
			get {
				if (AdjustBaselineRequest_cb_delegate == null)
					AdjustBaselineRequest_cb_delegate = new AdjustBaselineRequestNativeDelegate (AdjustBaselineRequest_cb);
				return AdjustBaselineRequest_cb_delegate;
			}
		}

		static void OverrideAdjustBaselineRequest (GLib.GType gtype)
		{
			OverrideAdjustBaselineRequest (gtype, AdjustBaselineRequestVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AdjustBaselineRequestNativeDelegate (IntPtr inst, out int minimum_baseline, out int natural_baseline);

		static void AdjustBaselineRequest_cb (IntPtr inst, out int minimum_baseline, out int natural_baseline)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnAdjustBaselineRequest (out minimum_baseline, out natural_baseline);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideAdjustBaselineRequest")]
		protected virtual void OnAdjustBaselineRequest (out int minimum_baseline, out int natural_baseline)
		{
			InternalAdjustBaselineRequest (out minimum_baseline, out natural_baseline);
		}

		private void InternalAdjustBaselineRequest (out int minimum_baseline, out int natural_baseline)
		{
			AdjustBaselineRequestNativeDelegate unmanaged = class_abi.BaseOverride<AdjustBaselineRequestNativeDelegate>(this.LookupGType(), "adjust_baseline_request");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out minimum_baseline, out natural_baseline);
		}

		static AdjustBaselineAllocationNativeDelegate AdjustBaselineAllocation_cb_delegate;
		static AdjustBaselineAllocationNativeDelegate AdjustBaselineAllocationVMCallback {
			get {
				if (AdjustBaselineAllocation_cb_delegate == null)
					AdjustBaselineAllocation_cb_delegate = new AdjustBaselineAllocationNativeDelegate (AdjustBaselineAllocation_cb);
				return AdjustBaselineAllocation_cb_delegate;
			}
		}

		static void OverrideAdjustBaselineAllocation (GLib.GType gtype)
		{
			OverrideAdjustBaselineAllocation (gtype, AdjustBaselineAllocationVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AdjustBaselineAllocationNativeDelegate (IntPtr inst, out int baseline);

		static void AdjustBaselineAllocation_cb (IntPtr inst, out int baseline)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnAdjustBaselineAllocation (out baseline);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideAdjustBaselineAllocation")]
		protected virtual void OnAdjustBaselineAllocation (out int baseline)
		{
			InternalAdjustBaselineAllocation (out baseline);
		}

		private void InternalAdjustBaselineAllocation (out int baseline)
		{
			AdjustBaselineAllocationNativeDelegate unmanaged = class_abi.BaseOverride<AdjustBaselineAllocationNativeDelegate>(this.LookupGType(), "adjust_baseline_allocation");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out baseline);
		}

		static QueueDrawRegionNativeDelegate QueueDrawRegion_cb_delegate;
		static QueueDrawRegionNativeDelegate QueueDrawRegionVMCallback {
			get {
				if (QueueDrawRegion_cb_delegate == null)
					QueueDrawRegion_cb_delegate = new QueueDrawRegionNativeDelegate (QueueDrawRegion_cb);
				return QueueDrawRegion_cb_delegate;
			}
		}

		static void OverrideQueueDrawRegion (GLib.GType gtype)
		{
			OverrideQueueDrawRegion (gtype, QueueDrawRegionVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void QueueDrawRegionNativeDelegate (IntPtr inst, IntPtr region);

		static void QueueDrawRegion_cb (IntPtr inst, IntPtr region)
		{
			try {
				Widget __obj = GLib.Object.GetObject (inst, false) as Widget;
				__obj.OnQueueDrawRegion (new Cairo.Region(region));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Widget), ConnectionMethod="OverrideQueueDrawRegion")]
		protected virtual void OnQueueDrawRegion (Cairo.Region region)
		{
			InternalQueueDrawRegion (region);
		}

		private void InternalQueueDrawRegion (Cairo.Region region)
		{
			QueueDrawRegionNativeDelegate unmanaged = class_abi.BaseOverride<QueueDrawRegionNativeDelegate>(this.LookupGType(), "queue_draw_region");
			if (unmanaged == null) return;

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


		// 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("activate_signal"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( uint ) // activate_signal
							, null
							, "dispatch_child_properties_changed"
							, (long) Marshal.OffsetOf<GtkWidget_activate_signalAlign>("activate_signal")
							, 0
							),
						new GLib.AbiField("dispatch_child_properties_changed"
							, -1
							, (uint) sizeof( IntPtr ) // dispatch_child_properties_changed
							, "activate_signal"
							, "destroy"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("destroy"
							, -1
							, (uint) sizeof( IntPtr ) // destroy
							, "dispatch_child_properties_changed"
							, "show"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("show"
							, -1
							, (uint) sizeof( IntPtr ) // show
							, "destroy"
							, "show_all"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("show_all"
							, -1
							, (uint) sizeof( IntPtr ) // show_all
							, "show"
							, "hide"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("hide"
							, -1
							, (uint) sizeof( IntPtr ) // hide
							, "show_all"
							, "map"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("map"
							, -1
							, (uint) sizeof( IntPtr ) // map
							, "hide"
							, "unmap"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("unmap"
							, -1
							, (uint) sizeof( IntPtr ) // unmap
							, "map"
							, "realize"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("realize"
							, -1
							, (uint) sizeof( IntPtr ) // realize
							, "unmap"
							, "unrealize"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("unrealize"
							, -1
							, (uint) sizeof( IntPtr ) // unrealize
							, "realize"
							, "size_allocate"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("size_allocate"
							, -1
							, (uint) sizeof( IntPtr ) // size_allocate
							, "unrealize"
							, "state_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("state_changed"
							, -1
							, (uint) sizeof( IntPtr ) // state_changed
							, "size_allocate"
							, "state_flags_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("state_flags_changed"
							, -1
							, (uint) sizeof( IntPtr ) // state_flags_changed
							, "state_changed"
							, "parent_set"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("parent_set"
							, -1
							, (uint) sizeof( IntPtr ) // parent_set
							, "state_flags_changed"
							, "hierarchy_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("hierarchy_changed"
							, -1
							, (uint) sizeof( IntPtr ) // hierarchy_changed
							, "parent_set"
							, "style_set"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("style_set"
							, -1
							, (uint) sizeof( IntPtr ) // style_set
							, "hierarchy_changed"
							, "direction_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("direction_changed"
							, -1
							, (uint) sizeof( IntPtr ) // direction_changed
							, "style_set"
							, "grab_notify"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("grab_notify"
							, -1
							, (uint) sizeof( IntPtr ) // grab_notify
							, "direction_changed"
							, "child_notify"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("child_notify"
							, -1
							, (uint) sizeof( IntPtr ) // child_notify
							, "grab_notify"
							, "draw"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw"
							, -1
							, (uint) sizeof( IntPtr ) // draw
							, "child_notify"
							, "get_request_mode"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_request_mode"
							, -1
							, (uint) sizeof( IntPtr ) // get_request_mode
							, "draw"
							, "get_preferred_height"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_preferred_height"
							, -1
							, (uint) sizeof( IntPtr ) // get_preferred_height
							, "get_request_mode"
							, "get_preferred_width_for_height"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_preferred_width_for_height"
							, -1
							, (uint) sizeof( IntPtr ) // get_preferred_width_for_height
							, "get_preferred_height"
							, "get_preferred_width"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_preferred_width"
							, -1
							, (uint) sizeof( IntPtr ) // get_preferred_width
							, "get_preferred_width_for_height"
							, "get_preferred_height_for_width"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_preferred_height_for_width"
							, -1
							, (uint) sizeof( IntPtr ) // get_preferred_height_for_width
							, "get_preferred_width"
							, "mnemonic_activate"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("mnemonic_activate"
							, -1
							, (uint) sizeof( IntPtr ) // mnemonic_activate
							, "get_preferred_height_for_width"
							, "grab_focus"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("grab_focus"
							, -1
							, (uint) sizeof( IntPtr ) // grab_focus
							, "mnemonic_activate"
							, "focus"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("focus"
							, -1
							, (uint) sizeof( IntPtr ) // focus
							, "grab_focus"
							, "move_focus"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_focus"
							, -1
							, (uint) sizeof( IntPtr ) // move_focus
							, "focus"
							, "keynav_failed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("keynav_failed"
							, -1
							, (uint) sizeof( IntPtr ) // keynav_failed
							, "move_focus"
							, "event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("event"
							, -1
							, (uint) sizeof( IntPtr ) // event
							, "keynav_failed"
							, "button_press_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("button_press_event"
							, -1
							, (uint) sizeof( IntPtr ) // button_press_event
							, "event"
							, "button_release_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("button_release_event"
							, -1
							, (uint) sizeof( IntPtr ) // button_release_event
							, "button_press_event"
							, "scroll_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("scroll_event"
							, -1
							, (uint) sizeof( IntPtr ) // scroll_event
							, "button_release_event"
							, "motion_notify_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("motion_notify_event"
							, -1
							, (uint) sizeof( IntPtr ) // motion_notify_event
							, "scroll_event"
							, "delete_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("delete_event"
							, -1
							, (uint) sizeof( IntPtr ) // delete_event
							, "motion_notify_event"
							, "destroy_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("destroy_event"
							, -1
							, (uint) sizeof( IntPtr ) // destroy_event
							, "delete_event"
							, "key_press_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("key_press_event"
							, -1
							, (uint) sizeof( IntPtr ) // key_press_event
							, "destroy_event"
							, "key_release_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("key_release_event"
							, -1
							, (uint) sizeof( IntPtr ) // key_release_event
							, "key_press_event"
							, "enter_notify_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("enter_notify_event"
							, -1
							, (uint) sizeof( IntPtr ) // enter_notify_event
							, "key_release_event"
							, "leave_notify_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("leave_notify_event"
							, -1
							, (uint) sizeof( IntPtr ) // leave_notify_event
							, "enter_notify_event"
							, "configure_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("configure_event"
							, -1
							, (uint) sizeof( IntPtr ) // configure_event
							, "leave_notify_event"
							, "focus_in_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("focus_in_event"
							, -1
							, (uint) sizeof( IntPtr ) // focus_in_event
							, "configure_event"
							, "focus_out_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("focus_out_event"
							, -1
							, (uint) sizeof( IntPtr ) // focus_out_event
							, "focus_in_event"
							, "map_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("map_event"
							, -1
							, (uint) sizeof( IntPtr ) // map_event
							, "focus_out_event"
							, "unmap_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("unmap_event"
							, -1
							, (uint) sizeof( IntPtr ) // unmap_event
							, "map_event"
							, "property_notify_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("property_notify_event"
							, -1
							, (uint) sizeof( IntPtr ) // property_notify_event
							, "unmap_event"
							, "selection_clear_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("selection_clear_event"
							, -1
							, (uint) sizeof( IntPtr ) // selection_clear_event
							, "property_notify_event"
							, "selection_request_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("selection_request_event"
							, -1
							, (uint) sizeof( IntPtr ) // selection_request_event
							, "selection_clear_event"
							, "selection_notify_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("selection_notify_event"
							, -1
							, (uint) sizeof( IntPtr ) // selection_notify_event
							, "selection_request_event"
							, "proximity_in_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("proximity_in_event"
							, -1
							, (uint) sizeof( IntPtr ) // proximity_in_event
							, "selection_notify_event"
							, "proximity_out_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("proximity_out_event"
							, -1
							, (uint) sizeof( IntPtr ) // proximity_out_event
							, "proximity_in_event"
							, "visibility_notify_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("visibility_notify_event"
							, -1
							, (uint) sizeof( IntPtr ) // visibility_notify_event
							, "proximity_out_event"
							, "window_state_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("window_state_event"
							, -1
							, (uint) sizeof( IntPtr ) // window_state_event
							, "visibility_notify_event"
							, "damage_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("damage_event"
							, -1
							, (uint) sizeof( IntPtr ) // damage_event
							, "window_state_event"
							, "grab_broken_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("grab_broken_event"
							, -1
							, (uint) sizeof( IntPtr ) // grab_broken_event
							, "damage_event"
							, "selection_get"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("selection_get"
							, -1
							, (uint) sizeof( IntPtr ) // selection_get
							, "grab_broken_event"
							, "selection_received"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("selection_received"
							, -1
							, (uint) sizeof( IntPtr ) // selection_received
							, "selection_get"
							, "drag_begin"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_begin"
							, -1
							, (uint) sizeof( IntPtr ) // drag_begin
							, "selection_received"
							, "drag_end"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_end"
							, -1
							, (uint) sizeof( IntPtr ) // drag_end
							, "drag_begin"
							, "drag_data_get"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_data_get"
							, -1
							, (uint) sizeof( IntPtr ) // drag_data_get
							, "drag_end"
							, "drag_data_delete"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_data_delete"
							, -1
							, (uint) sizeof( IntPtr ) // drag_data_delete
							, "drag_data_get"
							, "drag_leave"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_leave"
							, -1
							, (uint) sizeof( IntPtr ) // drag_leave
							, "drag_data_delete"
							, "drag_motion"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_motion"
							, -1
							, (uint) sizeof( IntPtr ) // drag_motion
							, "drag_leave"
							, "drag_drop"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_drop"
							, -1
							, (uint) sizeof( IntPtr ) // drag_drop
							, "drag_motion"
							, "drag_data_received"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_data_received"
							, -1
							, (uint) sizeof( IntPtr ) // drag_data_received
							, "drag_drop"
							, "drag_failed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("drag_failed"
							, -1
							, (uint) sizeof( IntPtr ) // drag_failed
							, "drag_data_received"
							, "popup_menu"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("popup_menu"
							, -1
							, (uint) sizeof( IntPtr ) // popup_menu
							, "drag_failed"
							, "show_help"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("show_help"
							, -1
							, (uint) sizeof( IntPtr ) // show_help
							, "popup_menu"
							, "get_accessible"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_accessible"
							, -1
							, (uint) sizeof( IntPtr ) // get_accessible
							, "show_help"
							, "screen_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("screen_changed"
							, -1
							, (uint) sizeof( IntPtr ) // screen_changed
							, "get_accessible"
							, "can_activate_accel"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("can_activate_accel"
							, -1
							, (uint) sizeof( IntPtr ) // can_activate_accel
							, "screen_changed"
							, "composited_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("composited_changed"
							, -1
							, (uint) sizeof( IntPtr ) // composited_changed
							, "can_activate_accel"
							, "query_tooltip"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("query_tooltip"
							, -1
							, (uint) sizeof( IntPtr ) // query_tooltip
							, "composited_changed"
							, "compute_expand"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("compute_expand"
							, -1
							, (uint) sizeof( IntPtr ) // compute_expand
							, "query_tooltip"
							, "adjust_size_request"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("adjust_size_request"
							, -1
							, (uint) sizeof( IntPtr ) // adjust_size_request
							, "compute_expand"
							, "adjust_size_allocation"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("adjust_size_allocation"
							, -1
							, (uint) sizeof( IntPtr ) // adjust_size_allocation
							, "adjust_size_request"
							, "style_updated"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("style_updated"
							, -1
							, (uint) sizeof( IntPtr ) // style_updated
							, "adjust_size_allocation"
							, "touch_event"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("touch_event"
							, -1
							, (uint) sizeof( IntPtr ) // touch_event
							, "style_updated"
							, "get_preferred_height_and_baseline_for_width"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_preferred_height_and_baseline_for_width"
							, -1
							, (uint) sizeof( IntPtr ) // get_preferred_height_and_baseline_for_width
							, "touch_event"
							, "adjust_baseline_request"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("adjust_baseline_request"
							, -1
							, (uint) sizeof( IntPtr ) // adjust_baseline_request
							, "get_preferred_height_and_baseline_for_width"
							, "adjust_baseline_allocation"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("adjust_baseline_allocation"
							, -1
							, (uint) sizeof( IntPtr ) // adjust_baseline_allocation
							, "adjust_baseline_request"
							, "queue_draw_region"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("queue_draw_region"
							, -1
							, (uint) sizeof( IntPtr ) // queue_draw_region
							, "adjust_baseline_allocation"
							, "priv"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("priv"
							, -1
							, (uint) sizeof( IntPtr ) // priv
							, "queue_draw_region"
							, "_gtk_reserved6"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved6"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved6
							, "priv"
							, "_gtk_reserved7"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved7"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved7
							, "_gtk_reserved6"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkWidget_activate_signalAlign
		{
			sbyte f1;
			private uint activate_signal;
		}


		// End of the ABI representation.

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

		public bool Activate() {
			bool raw_ret = gtk_widget_activate(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_add_accelerator(IntPtr raw, IntPtr accel_signal, IntPtr accel_group, uint accel_key, int accel_mods, int accel_flags);
		static d_gtk_widget_add_accelerator gtk_widget_add_accelerator = FuncLoader.LoadFunction<d_gtk_widget_add_accelerator>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_add_accelerator"));

		public void AddAccelerator(string accel_signal, Gtk.AccelGroup accel_group, uint accel_key, Gdk.ModifierType accel_mods, Gtk.AccelFlags accel_flags) {
			IntPtr native_accel_signal = GLib.Marshaller.StringToPtrGStrdup (accel_signal);
			gtk_widget_add_accelerator(Handle, native_accel_signal, accel_group == null ? IntPtr.Zero : accel_group.Handle, accel_key, (int) accel_mods, (int) accel_flags);
			GLib.Marshaller.Free (native_accel_signal);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_add_device_events(IntPtr raw, IntPtr device, int events);
		static d_gtk_widget_add_device_events gtk_widget_add_device_events = FuncLoader.LoadFunction<d_gtk_widget_add_device_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_add_device_events"));

		public void AddDeviceEvents(Gdk.Device device, Gdk.EventMask events) {
			gtk_widget_add_device_events(Handle, device == null ? IntPtr.Zero : device.Handle, (int) events);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_add_events(IntPtr raw, int events);
		static d_gtk_widget_add_events gtk_widget_add_events = FuncLoader.LoadFunction<d_gtk_widget_add_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_add_events"));

		public void AddEvents(int events) {
			gtk_widget_add_events(Handle, events);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_add_mnemonic_label(IntPtr raw, IntPtr label);
		static d_gtk_widget_add_mnemonic_label gtk_widget_add_mnemonic_label = FuncLoader.LoadFunction<d_gtk_widget_add_mnemonic_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_add_mnemonic_label"));

		public void AddMnemonicLabel(Gtk.Widget label) {
			gtk_widget_add_mnemonic_label(Handle, label == null ? IntPtr.Zero : label.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_gtk_widget_add_tick_callback(IntPtr raw, GtkSharp.TickCallbackNative cb, IntPtr user_data, GLib.DestroyNotify notify);
		static d_gtk_widget_add_tick_callback gtk_widget_add_tick_callback = FuncLoader.LoadFunction<d_gtk_widget_add_tick_callback>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_add_tick_callback"));

		public uint AddTickCallback(Gtk.TickCallback cb) {
			GtkSharp.TickCallbackWrapper cb_wrapper = new GtkSharp.TickCallbackWrapper (cb);
			IntPtr user_data;
			GLib.DestroyNotify notify;
			if (cb == null) {
				user_data = IntPtr.Zero;
				notify = null;
			} else {
				user_data = (IntPtr) GCHandle.Alloc (cb_wrapper);
				notify = GLib.DestroyHelper.NotifyHandler;
			}
			uint raw_ret = gtk_widget_add_tick_callback(Handle, cb_wrapper.NativeDelegate, user_data, notify);
			uint ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_can_activate_accel(IntPtr raw, uint signal_id);
		static d_gtk_widget_can_activate_accel gtk_widget_can_activate_accel = FuncLoader.LoadFunction<d_gtk_widget_can_activate_accel>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_can_activate_accel"));

		public bool CanActivateAccel(uint signal_id) {
			bool raw_ret = gtk_widget_can_activate_accel(Handle, signal_id);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_child_focus(IntPtr raw, int direction);
		static d_gtk_widget_child_focus gtk_widget_child_focus = FuncLoader.LoadFunction<d_gtk_widget_child_focus>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_child_focus"));

		public bool ChildFocus(Gtk.DirectionType direction) {
			bool raw_ret = gtk_widget_child_focus(Handle, (int) direction);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_child_notify(IntPtr raw, IntPtr child_property);
		static d_gtk_widget_child_notify gtk_widget_child_notify = FuncLoader.LoadFunction<d_gtk_widget_child_notify>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_child_notify"));

		public void ChildNotify(string child_property) {
			IntPtr native_child_property = GLib.Marshaller.StringToPtrGStrdup (child_property);
			gtk_widget_child_notify(Handle, native_child_property);
			GLib.Marshaller.Free (native_child_property);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_class_path(IntPtr raw, out uint path_length, out IntPtr path, out IntPtr path_reversed);
		static d_gtk_widget_class_path gtk_widget_class_path = FuncLoader.LoadFunction<d_gtk_widget_class_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_class_path"));

		[Obsolete]
		public void ClassPath(out uint path_length, out string path, out string path_reversed) {
			IntPtr native_path;
			IntPtr native_path_reversed;
			gtk_widget_class_path(Handle, out path_length, out native_path, out native_path_reversed);
			path = GLib.Marshaller.PtrToStringGFree(native_path);
			path_reversed = GLib.Marshaller.PtrToStringGFree(native_path_reversed);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_compute_expand(IntPtr raw, int orientation);
		static d_gtk_widget_compute_expand gtk_widget_compute_expand = FuncLoader.LoadFunction<d_gtk_widget_compute_expand>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_compute_expand"));

		public bool ComputeExpand(Gtk.Orientation orientation) {
			bool raw_ret = gtk_widget_compute_expand(Handle, (int) orientation);
			bool ret = raw_ret;
			return ret;
		}

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

		public Pango.Context CreatePangoContext() {
			IntPtr raw_ret = gtk_widget_create_pango_context(Handle);
			Pango.Context ret = GLib.Object.GetObject(raw_ret) as Pango.Context;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_create_pango_layout(IntPtr raw, IntPtr text);
		static d_gtk_widget_create_pango_layout gtk_widget_create_pango_layout = FuncLoader.LoadFunction<d_gtk_widget_create_pango_layout>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_create_pango_layout"));

		public Pango.Layout CreatePangoLayout(string text) {
			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
			IntPtr raw_ret = gtk_widget_create_pango_layout(Handle, native_text);
			Pango.Layout ret = GLib.Object.GetObject(raw_ret, true) as Pango.Layout;
			GLib.Marshaller.Free (native_text);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_device_is_shadowed(IntPtr raw, IntPtr device);
		static d_gtk_widget_device_is_shadowed gtk_widget_device_is_shadowed = FuncLoader.LoadFunction<d_gtk_widget_device_is_shadowed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_device_is_shadowed"));

		public bool DeviceIsShadowed(Gdk.Device device) {
			bool raw_ret = gtk_widget_device_is_shadowed(Handle, device == null ? IntPtr.Zero : device.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_draw(IntPtr raw, IntPtr cr);
		static d_gtk_widget_draw gtk_widget_draw = FuncLoader.LoadFunction<d_gtk_widget_draw>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_draw"));

		public void Draw(Cairo.Context cr) {
			gtk_widget_draw(Handle, cr == null ? IntPtr.Zero : cr.Handle);
		}

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

		[Obsolete]
		public void EnsureStyle() {
			gtk_widget_ensure_style(Handle);
		}

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

		public void ErrorBell() {
			gtk_widget_error_bell(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_event(IntPtr raw, IntPtr evnt);
		static d_gtk_widget_event gtk_widget_event = FuncLoader.LoadFunction<d_gtk_widget_event>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_event"));

		public bool ProcessEvent(Gdk.Event evnt) {
			bool raw_ret = gtk_widget_event(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void FreezeChildNotify() {
			gtk_widget_freeze_child_notify(Handle);
		}

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

		public Atk.Object Accessible { 
			get {
				IntPtr raw_ret = gtk_widget_get_accessible(Handle);
				Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_get_action_group(IntPtr raw, IntPtr prefix);
		static d_gtk_widget_get_action_group gtk_widget_get_action_group = FuncLoader.LoadFunction<d_gtk_widget_get_action_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_action_group"));

		public GLib.IActionGroup GetActionGroup(string prefix) {
			IntPtr native_prefix = GLib.Marshaller.StringToPtrGStrdup (prefix);
			IntPtr raw_ret = gtk_widget_get_action_group(Handle, native_prefix);
			GLib.IActionGroup ret = GLib.ActionGroupAdapter.GetObject (raw_ret, false);
			GLib.Marshaller.Free (native_prefix);
			return ret;
		}

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

		public int AllocatedBaseline { 
			get {
				int raw_ret = gtk_widget_get_allocated_baseline(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

		public int AllocatedHeight { 
			get {
				int raw_ret = gtk_widget_get_allocated_height(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_allocated_size(IntPtr raw, IntPtr allocation, out int baseline);
		static d_gtk_widget_get_allocated_size gtk_widget_get_allocated_size = FuncLoader.LoadFunction<d_gtk_widget_get_allocated_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_allocated_size"));

		public void GetAllocatedSize(out Gdk.Rectangle allocation, out int baseline) {
			IntPtr native_allocation = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
			gtk_widget_get_allocated_size(Handle, native_allocation, out baseline);
			allocation = (Gdk.Rectangle) Marshal.PtrToStructure (native_allocation, typeof (Gdk.Rectangle));
			Marshal.FreeHGlobal (native_allocation);
		}

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

		public int AllocatedWidth { 
			get {
				int raw_ret = gtk_widget_get_allocated_width(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_allocation(IntPtr raw, IntPtr allocation);
		static d_gtk_widget_get_allocation gtk_widget_get_allocation = FuncLoader.LoadFunction<d_gtk_widget_get_allocation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_allocation"));

		public Gdk.Rectangle Allocation { 
			get {
				Gdk.Rectangle allocation;
				IntPtr native_allocation = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
				gtk_widget_get_allocation(Handle, native_allocation);
				allocation = (Gdk.Rectangle) Marshal.PtrToStructure (native_allocation, typeof (Gdk.Rectangle));
				Marshal.FreeHGlobal (native_allocation);
				return allocation;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_get_ancestor(IntPtr raw, IntPtr widget_type);
		static d_gtk_widget_get_ancestor gtk_widget_get_ancestor = FuncLoader.LoadFunction<d_gtk_widget_get_ancestor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_ancestor"));

		public Gtk.Widget GetAncestor(GLib.GType widget_type) {
			IntPtr raw_ret = gtk_widget_get_ancestor(Handle, widget_type.Val);
			Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_child_requisition(IntPtr raw, IntPtr requisition);
		static d_gtk_widget_get_child_requisition gtk_widget_get_child_requisition = FuncLoader.LoadFunction<d_gtk_widget_get_child_requisition>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_child_requisition"));

		[Obsolete]
		public Gtk.Requisition ChildRequisition { 
			get {
				Gtk.Requisition requisition;
				IntPtr native_requisition = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.Requisition>());
				gtk_widget_get_child_requisition(Handle, native_requisition);
				requisition = Gtk.Requisition.New (native_requisition);
				Marshal.FreeHGlobal (native_requisition);
				return requisition;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_child_visible(IntPtr raw, bool is_visible);
		static d_gtk_widget_set_child_visible gtk_widget_set_child_visible = FuncLoader.LoadFunction<d_gtk_widget_set_child_visible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_child_visible"));

		public bool ChildVisible { 
			get {
				bool raw_ret = gtk_widget_get_child_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_widget_set_child_visible(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_clip(IntPtr raw, IntPtr clip);
		static d_gtk_widget_get_clip gtk_widget_get_clip = FuncLoader.LoadFunction<d_gtk_widget_get_clip>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_clip"));

		public Gdk.Rectangle Clip { 
			get {
				Gdk.Rectangle clip;
				IntPtr native_clip = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
				gtk_widget_get_clip(Handle, native_clip);
				clip = (Gdk.Rectangle) Marshal.PtrToStructure (native_clip, typeof (Gdk.Rectangle));
				Marshal.FreeHGlobal (native_clip);
				return clip;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_get_clipboard(IntPtr raw, IntPtr selection);
		static d_gtk_widget_get_clipboard gtk_widget_get_clipboard = FuncLoader.LoadFunction<d_gtk_widget_get_clipboard>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_clipboard"));

		public Gtk.Clipboard GetClipboard(Gdk.Atom selection) {
			IntPtr raw_ret = gtk_widget_get_clipboard(Handle, selection == null ? IntPtr.Zero : selection.Handle);
			Gtk.Clipboard ret = GLib.Object.GetObject(raw_ret) as Gtk.Clipboard;
			return ret;
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_composite_name(IntPtr raw, IntPtr name);
		static d_gtk_widget_set_composite_name gtk_widget_set_composite_name = FuncLoader.LoadFunction<d_gtk_widget_set_composite_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_composite_name"));

		[Obsolete]
		public string CompositeName { 
			get {
				IntPtr raw_ret = gtk_widget_get_composite_name(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_widget_set_composite_name(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_widget_get_default_direction();
		static d_gtk_widget_get_default_direction gtk_widget_get_default_direction = FuncLoader.LoadFunction<d_gtk_widget_get_default_direction>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_default_direction"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_default_direction(int dir);
		static d_gtk_widget_set_default_direction gtk_widget_set_default_direction = FuncLoader.LoadFunction<d_gtk_widget_set_default_direction>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_default_direction"));

		public static Gtk.TextDirection DefaultDirection { 
			get {
				int raw_ret = gtk_widget_get_default_direction();
				Gtk.TextDirection ret = (Gtk.TextDirection) raw_ret;
				return ret;
			}
			set {
				gtk_widget_set_default_direction((int) value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_get_default_style();
		static d_gtk_widget_get_default_style gtk_widget_get_default_style = FuncLoader.LoadFunction<d_gtk_widget_get_default_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_default_style"));

		[Obsolete]
		public static Gtk.Style DefaultStyle { 
			get {
				IntPtr raw_ret = gtk_widget_get_default_style();
				Gtk.Style ret = GLib.Object.GetObject(raw_ret) as Gtk.Style;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_get_device_enabled(IntPtr raw, IntPtr device);
		static d_gtk_widget_get_device_enabled gtk_widget_get_device_enabled = FuncLoader.LoadFunction<d_gtk_widget_get_device_enabled>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_device_enabled"));

		public bool GetDeviceEnabled(Gdk.Device device) {
			bool raw_ret = gtk_widget_get_device_enabled(Handle, device == null ? IntPtr.Zero : device.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_widget_get_device_events(IntPtr raw, IntPtr device);
		static d_gtk_widget_get_device_events gtk_widget_get_device_events = FuncLoader.LoadFunction<d_gtk_widget_get_device_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_device_events"));

		public Gdk.EventMask GetDeviceEvents(Gdk.Device device) {
			int raw_ret = gtk_widget_get_device_events(Handle, device == null ? IntPtr.Zero : device.Handle);
			Gdk.EventMask ret = (Gdk.EventMask) raw_ret;
			return ret;
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_direction(IntPtr raw, int dir);
		static d_gtk_widget_set_direction gtk_widget_set_direction = FuncLoader.LoadFunction<d_gtk_widget_set_direction>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_direction"));

		public Gtk.TextDirection Direction { 
			get {
				int raw_ret = gtk_widget_get_direction(Handle);
				Gtk.TextDirection ret = (Gtk.TextDirection) raw_ret;
				return ret;
			}
			set {
				gtk_widget_set_direction(Handle, (int) value);
			}
		}

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

		public Gdk.Display Display { 
			get {
				IntPtr raw_ret = gtk_widget_get_display(Handle);
				Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_font_map(IntPtr raw, IntPtr font_map);
		static d_gtk_widget_set_font_map gtk_widget_set_font_map = FuncLoader.LoadFunction<d_gtk_widget_set_font_map>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_font_map"));

		public Pango.FontMap FontMap { 
			get {
				IntPtr raw_ret = gtk_widget_get_font_map(Handle);
				Pango.FontMap ret = GLib.Object.GetObject(raw_ret) as Pango.FontMap;
				return ret;
			}
			set {
				gtk_widget_set_font_map(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_font_options(IntPtr raw, IntPtr options);
		static d_gtk_widget_set_font_options gtk_widget_set_font_options = FuncLoader.LoadFunction<d_gtk_widget_set_font_options>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_font_options"));

		public Cairo.FontOptions FontOptions { 
			get {
				IntPtr raw_ret = gtk_widget_get_font_options(Handle);
				Cairo.FontOptions ret = new Cairo.FontOptions(raw_ret);
				return ret;
			}
			set {
				gtk_widget_set_font_options(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public Gdk.FrameClock FrameClock { 
			get {
				IntPtr raw_ret = gtk_widget_get_frame_clock(Handle);
				Gdk.FrameClock ret = GLib.Object.GetObject(raw_ret) as Gdk.FrameClock;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_has_window(IntPtr raw, bool has_window);
		static d_gtk_widget_set_has_window gtk_widget_set_has_window = FuncLoader.LoadFunction<d_gtk_widget_set_has_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_has_window"));

		public bool HasWindow { 
			get {
				bool raw_ret = gtk_widget_get_has_window(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_widget_set_has_window(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_mapped(IntPtr raw, bool mapped);
		static d_gtk_widget_set_mapped gtk_widget_set_mapped = FuncLoader.LoadFunction<d_gtk_widget_set_mapped>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_mapped"));

		public bool IsMapped { 
			get {
				bool raw_ret = gtk_widget_get_mapped(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_widget_set_mapped(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_widget_get_modifier_mask(IntPtr raw, int intent);
		static d_gtk_widget_get_modifier_mask gtk_widget_get_modifier_mask = FuncLoader.LoadFunction<d_gtk_widget_get_modifier_mask>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_modifier_mask"));

		public Gdk.ModifierType GetModifierMask(Gdk.ModifierIntent intent) {
			int raw_ret = gtk_widget_get_modifier_mask(Handle, (int) intent);
			Gdk.ModifierType ret = (Gdk.ModifierType) raw_ret;
			return ret;
		}

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

		[Obsolete]
		public Gtk.RcStyle ModifierStyle { 
			get {
				IntPtr raw_ret = gtk_widget_get_modifier_style(Handle);
				Gtk.RcStyle ret = GLib.Object.GetObject(raw_ret) as Gtk.RcStyle;
				return ret;
			}
		}

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

		public Pango.Context PangoContext { 
			get {
				IntPtr raw_ret = gtk_widget_get_pango_context(Handle);
				Pango.Context ret = GLib.Object.GetObject(raw_ret) as Pango.Context;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_parent_window(IntPtr raw, IntPtr parent_window);
		static d_gtk_widget_set_parent_window gtk_widget_set_parent_window = FuncLoader.LoadFunction<d_gtk_widget_set_parent_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_parent_window"));

		public Gdk.Window ParentWindow { 
			get {
				IntPtr raw_ret = gtk_widget_get_parent_window(Handle);
				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
				return ret;
			}
			set {
				gtk_widget_set_parent_window(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public Gtk.WidgetPath WidgetPath { 
			get {
				IntPtr raw_ret = gtk_widget_get_path(Handle);
				Gtk.WidgetPath ret = raw_ret == IntPtr.Zero ? null : (Gtk.WidgetPath) GLib.Opaque.GetOpaque (raw_ret, typeof (Gtk.WidgetPath), false);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_pointer(IntPtr raw, out int x, out int y);
		static d_gtk_widget_get_pointer gtk_widget_get_pointer = FuncLoader.LoadFunction<d_gtk_widget_get_pointer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_pointer"));

		[Obsolete]
		public void GetPointer(out int x, out int y) {
			gtk_widget_get_pointer(Handle, out x, out y);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_preferred_height(IntPtr raw, out int minimum_height, out int natural_height);
		static d_gtk_widget_get_preferred_height gtk_widget_get_preferred_height = FuncLoader.LoadFunction<d_gtk_widget_get_preferred_height>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_preferred_height"));

		public void GetPreferredHeight(out int minimum_height, out int natural_height) {
			gtk_widget_get_preferred_height(Handle, out minimum_height, out natural_height);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_preferred_height_and_baseline_for_width(IntPtr raw, int width, out int minimum_height, out int natural_height, out int minimum_baseline, out int natural_baseline);
		static d_gtk_widget_get_preferred_height_and_baseline_for_width gtk_widget_get_preferred_height_and_baseline_for_width = FuncLoader.LoadFunction<d_gtk_widget_get_preferred_height_and_baseline_for_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_preferred_height_and_baseline_for_width"));

		public void GetPreferredHeightAndBaselineForWidth(int width, out int minimum_height, out int natural_height, out int minimum_baseline, out int natural_baseline) {
			gtk_widget_get_preferred_height_and_baseline_for_width(Handle, width, out minimum_height, out natural_height, out minimum_baseline, out natural_baseline);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_preferred_height_for_width(IntPtr raw, int width, out int minimum_height, out int natural_height);
		static d_gtk_widget_get_preferred_height_for_width gtk_widget_get_preferred_height_for_width = FuncLoader.LoadFunction<d_gtk_widget_get_preferred_height_for_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_preferred_height_for_width"));

		public void GetPreferredHeightForWidth(int width, out int minimum_height, out int natural_height) {
			gtk_widget_get_preferred_height_for_width(Handle, width, out minimum_height, out natural_height);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_preferred_size(IntPtr raw, IntPtr minimum_size, IntPtr natural_size);
		static d_gtk_widget_get_preferred_size gtk_widget_get_preferred_size = FuncLoader.LoadFunction<d_gtk_widget_get_preferred_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_preferred_size"));

		public void GetPreferredSize(out Gtk.Requisition minimum_size, out Gtk.Requisition natural_size) {
			IntPtr native_minimum_size = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.Requisition>());
			IntPtr native_natural_size = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.Requisition>());
			gtk_widget_get_preferred_size(Handle, native_minimum_size, native_natural_size);
			minimum_size = Gtk.Requisition.New (native_minimum_size);
			Marshal.FreeHGlobal (native_minimum_size);
			natural_size = Gtk.Requisition.New (native_natural_size);
			Marshal.FreeHGlobal (native_natural_size);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_preferred_width(IntPtr raw, out int minimum_width, out int natural_width);
		static d_gtk_widget_get_preferred_width gtk_widget_get_preferred_width = FuncLoader.LoadFunction<d_gtk_widget_get_preferred_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_preferred_width"));

		public void GetPreferredWidth(out int minimum_width, out int natural_width) {
			gtk_widget_get_preferred_width(Handle, out minimum_width, out natural_width);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_preferred_width_for_height(IntPtr raw, int height, out int minimum_width, out int natural_width);
		static d_gtk_widget_get_preferred_width_for_height gtk_widget_get_preferred_width_for_height = FuncLoader.LoadFunction<d_gtk_widget_get_preferred_width_for_height>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_preferred_width_for_height"));

		public void GetPreferredWidthForHeight(int height, out int minimum_width, out int natural_width) {
			gtk_widget_get_preferred_width_for_height(Handle, height, out minimum_width, out natural_width);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_realized(IntPtr raw, bool realized);
		static d_gtk_widget_set_realized gtk_widget_set_realized = FuncLoader.LoadFunction<d_gtk_widget_set_realized>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_realized"));

		public bool IsRealized { 
			get {
				bool raw_ret = gtk_widget_get_realized(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_widget_set_realized(Handle, value);
			}
		}

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

		public Gtk.SizeRequestMode RequestMode { 
			get {
				int raw_ret = gtk_widget_get_request_mode(Handle);
				Gtk.SizeRequestMode ret = (Gtk.SizeRequestMode) raw_ret;
				return ret;
			}
		}

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

		[Obsolete]
		public Gdk.Window RootWindow { 
			get {
				IntPtr raw_ret = gtk_widget_get_root_window(Handle);
				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
				return ret;
			}
		}

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

		public Gdk.Screen Screen { 
			get {
				IntPtr raw_ret = gtk_widget_get_screen(Handle);
				Gdk.Screen ret = GLib.Object.GetObject(raw_ret) as Gdk.Screen;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_get_size_request(IntPtr raw, out int width, out int height);
		static d_gtk_widget_get_size_request gtk_widget_get_size_request = FuncLoader.LoadFunction<d_gtk_widget_get_size_request>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_size_request"));

		public void GetSizeRequest(out int width, out int height) {
			gtk_widget_get_size_request(Handle, out width, out height);
		}

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

		[Obsolete]
		public Gtk.StateType State { 
			get {
				int raw_ret = gtk_widget_get_state(Handle);
				Gtk.StateType ret = (Gtk.StateType) raw_ret;
				return ret;
			}
		}

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

		public Gtk.StateFlags StateFlags { 
			get {
				int raw_ret = gtk_widget_get_state_flags(Handle);
				Gtk.StateFlags ret = (Gtk.StateFlags) raw_ret;
				return ret;
			}
		}

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

		public Gtk.StyleContext StyleContext { 
			get {
				IntPtr raw_ret = gtk_widget_get_style_context(Handle);
				Gtk.StyleContext ret = GLib.Object.GetObject(raw_ret) as Gtk.StyleContext;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_support_multidevice(IntPtr raw, bool support_multidevice);
		static d_gtk_widget_set_support_multidevice gtk_widget_set_support_multidevice = FuncLoader.LoadFunction<d_gtk_widget_set_support_multidevice>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_support_multidevice"));

		public bool SupportMultidevice { 
			get {
				bool raw_ret = gtk_widget_get_support_multidevice(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_widget_set_support_multidevice(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_get_template_child(IntPtr raw, IntPtr widget_type, IntPtr name);
		static d_gtk_widget_get_template_child gtk_widget_get_template_child = FuncLoader.LoadFunction<d_gtk_widget_get_template_child>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_template_child"));

		public GLib.Object GetTemplateChild(GLib.GType widget_type, string name) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr raw_ret = gtk_widget_get_template_child(Handle, widget_type.Val, native_name);
			GLib.Object ret = GLib.Object.GetObject (raw_ret);
			GLib.Marshaller.Free (native_name);
			return ret;
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_tooltip_window(IntPtr raw, IntPtr custom_window);
		static d_gtk_widget_set_tooltip_window gtk_widget_set_tooltip_window = FuncLoader.LoadFunction<d_gtk_widget_set_tooltip_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_tooltip_window"));

		public Gtk.Window TooltipWindow { 
			get {
				IntPtr raw_ret = gtk_widget_get_tooltip_window(Handle);
				Gtk.Window ret = GLib.Object.GetObject(raw_ret) as Gtk.Window;
				return ret;
			}
			set {
				gtk_widget_set_tooltip_window(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public Gtk.Widget Toplevel { 
			get {
				IntPtr raw_ret = gtk_widget_get_toplevel(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_get_type();
		static d_gtk_widget_get_type gtk_widget_get_type = FuncLoader.LoadFunction<d_gtk_widget_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_get_type"));

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

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

		public Gtk.Align ValignWithBaseline { 
			get {
				int raw_ret = gtk_widget_get_valign_with_baseline(Handle);
				Gtk.Align ret = (Gtk.Align) raw_ret;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_visual(IntPtr raw, IntPtr visual);
		static d_gtk_widget_set_visual gtk_widget_set_visual = FuncLoader.LoadFunction<d_gtk_widget_set_visual>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_visual"));

		public Gdk.Visual Visual { 
			get {
				IntPtr raw_ret = gtk_widget_get_visual(Handle);
				Gdk.Visual ret = GLib.Object.GetObject(raw_ret) as Gdk.Visual;
				return ret;
			}
			set {
				gtk_widget_set_visual(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public void GrabDefault() {
			gtk_widget_grab_default(Handle);
		}

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

		public void GrabFocus() {
			gtk_widget_grab_focus(Handle);
		}

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

		public bool HasGrab { 
			get {
				bool raw_ret = gtk_widget_has_grab(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		[Obsolete]
		public bool HasRcStyle { 
			get {
				bool raw_ret = gtk_widget_has_rc_style(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool HasScreen { 
			get {
				bool raw_ret = gtk_widget_has_screen(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool HasVisibleFocus { 
			get {
				bool raw_ret = gtk_widget_has_visible_focus(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public void Hide() {
			gtk_widget_hide(Handle);
		}

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

		public bool HideOnDelete() {
			bool raw_ret = gtk_widget_hide_on_delete(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool InDestruction() {
			bool raw_ret = gtk_widget_in_destruction(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_input_shape_combine_region(IntPtr raw, IntPtr region);
		static d_gtk_widget_input_shape_combine_region gtk_widget_input_shape_combine_region = FuncLoader.LoadFunction<d_gtk_widget_input_shape_combine_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_input_shape_combine_region"));

		public void InputShapeCombineRegion(Cairo.Region region) {
			gtk_widget_input_shape_combine_region(Handle, region == null ? IntPtr.Zero : region.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_insert_action_group(IntPtr raw, IntPtr name, IntPtr group);
		static d_gtk_widget_insert_action_group gtk_widget_insert_action_group = FuncLoader.LoadFunction<d_gtk_widget_insert_action_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_insert_action_group"));

		public void InsertActionGroup(string name, GLib.IActionGroup group) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			gtk_widget_insert_action_group(Handle, native_name, group == null ? IntPtr.Zero : ((group is GLib.Object) ? (group as GLib.Object).Handle : (group as GLib.ActionGroupAdapter).Handle));
			GLib.Marshaller.Free (native_name);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_intersect(IntPtr raw, IntPtr area, IntPtr intersection);
		static d_gtk_widget_intersect gtk_widget_intersect = FuncLoader.LoadFunction<d_gtk_widget_intersect>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_intersect"));

		public bool Intersect(Gdk.Rectangle area, out Gdk.Rectangle intersection) {
			IntPtr native_area = GLib.Marshaller.StructureToPtrAlloc (area);
			IntPtr native_intersection = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
			bool raw_ret = gtk_widget_intersect(Handle, native_area, native_intersection);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_area);
			intersection = (Gdk.Rectangle) Marshal.PtrToStructure (native_intersection, typeof (Gdk.Rectangle));
			Marshal.FreeHGlobal (native_intersection);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_is_ancestor(IntPtr raw, IntPtr ancestor);
		static d_gtk_widget_is_ancestor gtk_widget_is_ancestor = FuncLoader.LoadFunction<d_gtk_widget_is_ancestor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_is_ancestor"));

		public bool IsAncestor(Gtk.Widget ancestor) {
			bool raw_ret = gtk_widget_is_ancestor(Handle, ancestor == null ? IntPtr.Zero : ancestor.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		[Obsolete]
		public bool IsComposited { 
			get {
				bool raw_ret = gtk_widget_is_composited(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsDrawable { 
			get {
				bool raw_ret = gtk_widget_is_drawable(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsSensitive { 
			get {
				bool raw_ret = gtk_widget_is_sensitive(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsToplevel { 
			get {
				bool raw_ret = gtk_widget_is_toplevel(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsVisible { 
			get {
				bool raw_ret = gtk_widget_is_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_keynav_failed(IntPtr raw, int direction);
		static d_gtk_widget_keynav_failed gtk_widget_keynav_failed = FuncLoader.LoadFunction<d_gtk_widget_keynav_failed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_keynav_failed"));

		public bool KeynavFailed(Gtk.DirectionType direction) {
			bool raw_ret = gtk_widget_keynav_failed(Handle, (int) direction);
			bool ret = raw_ret;
			return ret;
		}

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

		public string[] ListActionPrefixes() {
			IntPtr raw_ret = gtk_widget_list_action_prefixes(Handle);
			string[] ret = GLib.Marshaller.NullTermPtrToStringArray (raw_ret, false);
			return ret;
		}

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

		public void Map() {
			gtk_widget_map(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_mnemonic_activate(IntPtr raw, bool group_cycling);
		static d_gtk_widget_mnemonic_activate gtk_widget_mnemonic_activate = FuncLoader.LoadFunction<d_gtk_widget_mnemonic_activate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_mnemonic_activate"));

		public bool MnemonicActivate(bool group_cycling) {
			bool raw_ret = gtk_widget_mnemonic_activate(Handle, group_cycling);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_modify_bg(IntPtr raw, int state, IntPtr color);
		static d_gtk_widget_modify_bg gtk_widget_modify_bg = FuncLoader.LoadFunction<d_gtk_widget_modify_bg>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_modify_bg"));

		[Obsolete]
		public void ModifyBg(Gtk.StateType state, Gdk.Color color) {
			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
			gtk_widget_modify_bg(Handle, (int) state, native_color);
			Marshal.FreeHGlobal (native_color);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_modify_fg(IntPtr raw, int state, IntPtr color);
		static d_gtk_widget_modify_fg gtk_widget_modify_fg = FuncLoader.LoadFunction<d_gtk_widget_modify_fg>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_modify_fg"));

		[Obsolete]
		public void ModifyFg(Gtk.StateType state, Gdk.Color color) {
			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
			gtk_widget_modify_fg(Handle, (int) state, native_color);
			Marshal.FreeHGlobal (native_color);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_modify_font(IntPtr raw, IntPtr font_desc);
		static d_gtk_widget_modify_font gtk_widget_modify_font = FuncLoader.LoadFunction<d_gtk_widget_modify_font>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_modify_font"));

		[Obsolete]
		public void ModifyFont(Pango.FontDescription font_desc) {
			gtk_widget_modify_font(Handle, font_desc == null ? IntPtr.Zero : font_desc.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_modify_style(IntPtr raw, IntPtr style);
		static d_gtk_widget_modify_style gtk_widget_modify_style = FuncLoader.LoadFunction<d_gtk_widget_modify_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_modify_style"));

		[Obsolete]
		public void ModifyStyle(Gtk.RcStyle style) {
			gtk_widget_modify_style(Handle, style == null ? IntPtr.Zero : style.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_override_background_color(IntPtr raw, int state, IntPtr color);
		static d_gtk_widget_override_background_color gtk_widget_override_background_color = FuncLoader.LoadFunction<d_gtk_widget_override_background_color>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_override_background_color"));

		[Obsolete]
		public void OverrideBackgroundColor(Gtk.StateFlags state, Gdk.RGBA color) {
			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
			gtk_widget_override_background_color(Handle, (int) state, native_color);
			Marshal.FreeHGlobal (native_color);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_override_color(IntPtr raw, int state, IntPtr color);
		static d_gtk_widget_override_color gtk_widget_override_color = FuncLoader.LoadFunction<d_gtk_widget_override_color>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_override_color"));

		[Obsolete]
		public void OverrideColor(Gtk.StateFlags state, Gdk.RGBA color) {
			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
			gtk_widget_override_color(Handle, (int) state, native_color);
			Marshal.FreeHGlobal (native_color);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_override_cursor(IntPtr raw, IntPtr cursor, IntPtr secondary_cursor);
		static d_gtk_widget_override_cursor gtk_widget_override_cursor = FuncLoader.LoadFunction<d_gtk_widget_override_cursor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_override_cursor"));

		[Obsolete]
		public void OverrideCursor(Gdk.RGBA cursor, Gdk.RGBA secondary_cursor) {
			IntPtr native_cursor = GLib.Marshaller.StructureToPtrAlloc (cursor);
			IntPtr native_secondary_cursor = GLib.Marshaller.StructureToPtrAlloc (secondary_cursor);
			gtk_widget_override_cursor(Handle, native_cursor, native_secondary_cursor);
			Marshal.FreeHGlobal (native_cursor);
			Marshal.FreeHGlobal (native_secondary_cursor);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_override_font(IntPtr raw, IntPtr font_desc);
		static d_gtk_widget_override_font gtk_widget_override_font = FuncLoader.LoadFunction<d_gtk_widget_override_font>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_override_font"));

		[Obsolete]
		public void OverrideFont(Pango.FontDescription font_desc) {
			gtk_widget_override_font(Handle, font_desc == null ? IntPtr.Zero : font_desc.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_override_symbolic_color(IntPtr raw, IntPtr name, IntPtr color);
		static d_gtk_widget_override_symbolic_color gtk_widget_override_symbolic_color = FuncLoader.LoadFunction<d_gtk_widget_override_symbolic_color>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_override_symbolic_color"));

		[Obsolete]
		public void OverrideSymbolicColor(string name, Gdk.RGBA color) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
			gtk_widget_override_symbolic_color(Handle, native_name, native_color);
			GLib.Marshaller.Free (native_name);
			Marshal.FreeHGlobal (native_color);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_path(IntPtr raw, out uint path_length, out IntPtr path, out IntPtr path_reversed);
		static d_gtk_widget_path gtk_widget_path = FuncLoader.LoadFunction<d_gtk_widget_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_path"));

		[Obsolete]
		public void Path(out uint path_length, out string path, out string path_reversed) {
			IntPtr native_path;
			IntPtr native_path_reversed;
			gtk_widget_path(Handle, out path_length, out native_path, out native_path_reversed);
			path = GLib.Marshaller.PtrToStringGFree(native_path);
			path_reversed = GLib.Marshaller.PtrToStringGFree(native_path_reversed);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_pop_composite_child();
		static d_gtk_widget_pop_composite_child gtk_widget_pop_composite_child = FuncLoader.LoadFunction<d_gtk_widget_pop_composite_child>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_pop_composite_child"));

		[Obsolete]
		public static void PopCompositeChild() {
			gtk_widget_pop_composite_child();
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_push_composite_child();
		static d_gtk_widget_push_composite_child gtk_widget_push_composite_child = FuncLoader.LoadFunction<d_gtk_widget_push_composite_child>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_push_composite_child"));

		[Obsolete]
		public static void PushCompositeChild() {
			gtk_widget_push_composite_child();
		}

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

		public void QueueAllocate() {
			gtk_widget_queue_allocate(Handle);
		}

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

		public void QueueComputeExpand() {
			gtk_widget_queue_compute_expand(Handle);
		}

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

		public void QueueDraw() {
			gtk_widget_queue_draw(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_queue_draw_area(IntPtr raw, int x, int y, int width, int height);
		static d_gtk_widget_queue_draw_area gtk_widget_queue_draw_area = FuncLoader.LoadFunction<d_gtk_widget_queue_draw_area>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_queue_draw_area"));

		public void QueueDrawArea(int x, int y, int width, int height) {
			gtk_widget_queue_draw_area(Handle, x, y, width, height);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_queue_draw_region(IntPtr raw, IntPtr region);
		static d_gtk_widget_queue_draw_region gtk_widget_queue_draw_region = FuncLoader.LoadFunction<d_gtk_widget_queue_draw_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_queue_draw_region"));

		public void QueueDrawRegion(Cairo.Region region) {
			gtk_widget_queue_draw_region(Handle, region == null ? IntPtr.Zero : region.Handle);
		}

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

		public void QueueResize() {
			gtk_widget_queue_resize(Handle);
		}

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

		public void QueueResizeNoRedraw() {
			gtk_widget_queue_resize_no_redraw(Handle);
		}

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

		public void Realize() {
			gtk_widget_realize(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_region_intersect(IntPtr raw, IntPtr region);
		static d_gtk_widget_region_intersect gtk_widget_region_intersect = FuncLoader.LoadFunction<d_gtk_widget_region_intersect>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_region_intersect"));

		[Obsolete]
		public Cairo.Region RegionIntersect(Cairo.Region region) {
			IntPtr raw_ret = gtk_widget_region_intersect(Handle, region == null ? IntPtr.Zero : region.Handle);
			Cairo.Region ret = new Cairo.Region(raw_ret);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_register_window(IntPtr raw, IntPtr window);
		static d_gtk_widget_register_window gtk_widget_register_window = FuncLoader.LoadFunction<d_gtk_widget_register_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_register_window"));

		public void RegisterWindow(Gdk.Window window) {
			gtk_widget_register_window(Handle, window == null ? IntPtr.Zero : window.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_remove_accelerator(IntPtr raw, IntPtr accel_group, uint accel_key, int accel_mods);
		static d_gtk_widget_remove_accelerator gtk_widget_remove_accelerator = FuncLoader.LoadFunction<d_gtk_widget_remove_accelerator>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_remove_accelerator"));

		public bool RemoveAccelerator(Gtk.AccelGroup accel_group, uint accel_key, Gdk.ModifierType accel_mods) {
			bool raw_ret = gtk_widget_remove_accelerator(Handle, accel_group == null ? IntPtr.Zero : accel_group.Handle, accel_key, (int) accel_mods);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_remove_mnemonic_label(IntPtr raw, IntPtr label);
		static d_gtk_widget_remove_mnemonic_label gtk_widget_remove_mnemonic_label = FuncLoader.LoadFunction<d_gtk_widget_remove_mnemonic_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_remove_mnemonic_label"));

		public void RemoveMnemonicLabel(Gtk.Widget label) {
			gtk_widget_remove_mnemonic_label(Handle, label == null ? IntPtr.Zero : label.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_remove_tick_callback(IntPtr raw, uint id);
		static d_gtk_widget_remove_tick_callback gtk_widget_remove_tick_callback = FuncLoader.LoadFunction<d_gtk_widget_remove_tick_callback>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_remove_tick_callback"));

		public void RemoveTickCallback(uint id) {
			gtk_widget_remove_tick_callback(Handle, id);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_render_icon(IntPtr raw, IntPtr stock_id, int size, IntPtr detail);
		static d_gtk_widget_render_icon gtk_widget_render_icon = FuncLoader.LoadFunction<d_gtk_widget_render_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_render_icon"));

		[Obsolete]
		public Gdk.Pixbuf RenderIcon(string stock_id, Gtk.IconSize size, string detail) {
			IntPtr native_stock_id = GLib.Marshaller.StringToPtrGStrdup (stock_id);
			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			IntPtr raw_ret = gtk_widget_render_icon(Handle, native_stock_id, (int) size, native_detail);
			Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
			GLib.Marshaller.Free (native_stock_id);
			GLib.Marshaller.Free (native_detail);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_widget_render_icon_pixbuf(IntPtr raw, IntPtr stock_id, int size);
		static d_gtk_widget_render_icon_pixbuf gtk_widget_render_icon_pixbuf = FuncLoader.LoadFunction<d_gtk_widget_render_icon_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_render_icon_pixbuf"));

		[Obsolete]
		public Gdk.Pixbuf RenderIconPixbuf(string stock_id, Gtk.IconSize size) {
			IntPtr native_stock_id = GLib.Marshaller.StringToPtrGStrdup (stock_id);
			IntPtr raw_ret = gtk_widget_render_icon_pixbuf(Handle, native_stock_id, (int) size);
			Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
			GLib.Marshaller.Free (native_stock_id);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_reparent(IntPtr raw, IntPtr new_parent);
		static d_gtk_widget_reparent gtk_widget_reparent = FuncLoader.LoadFunction<d_gtk_widget_reparent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_reparent"));

		[Obsolete]
		public void Reparent(Gtk.Widget new_parent) {
			gtk_widget_reparent(Handle, new_parent == null ? IntPtr.Zero : new_parent.Handle);
		}

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

		[Obsolete]
		public void ResetRcStyles() {
			gtk_widget_reset_rc_styles(Handle);
		}

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

		public void ResetStyle() {
			gtk_widget_reset_style(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_widget_send_expose(IntPtr raw, IntPtr evnt);
		static d_gtk_widget_send_expose gtk_widget_send_expose = FuncLoader.LoadFunction<d_gtk_widget_send_expose>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_send_expose"));

		[Obsolete]
		public int SendExpose(Gdk.Event evnt) {
			int raw_ret = gtk_widget_send_expose(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			int ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_send_focus_change(IntPtr raw, IntPtr evnt);
		static d_gtk_widget_send_focus_change gtk_widget_send_focus_change = FuncLoader.LoadFunction<d_gtk_widget_send_focus_change>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_send_focus_change"));

		public bool SendFocusChange(Gdk.Event evnt) {
			bool raw_ret = gtk_widget_send_focus_change(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_accel_path(IntPtr raw, IntPtr accel_path, IntPtr accel_group);
		static d_gtk_widget_set_accel_path gtk_widget_set_accel_path = FuncLoader.LoadFunction<d_gtk_widget_set_accel_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_accel_path"));

		public void SetAccelPath(string accel_path, Gtk.AccelGroup accel_group) {
			IntPtr native_accel_path = GLib.Marshaller.StringToPtrGStrdup (accel_path);
			gtk_widget_set_accel_path(Handle, native_accel_path, accel_group == null ? IntPtr.Zero : accel_group.Handle);
			GLib.Marshaller.Free (native_accel_path);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_allocation(IntPtr raw, IntPtr allocation);
		static d_gtk_widget_set_allocation gtk_widget_set_allocation = FuncLoader.LoadFunction<d_gtk_widget_set_allocation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_allocation"));

		public void SetAllocation(Gdk.Rectangle allocation) {
			IntPtr native_allocation = GLib.Marshaller.StructureToPtrAlloc (allocation);
			gtk_widget_set_allocation(Handle, native_allocation);
			Marshal.FreeHGlobal (native_allocation);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_clip(IntPtr raw, IntPtr clip);
		static d_gtk_widget_set_clip gtk_widget_set_clip = FuncLoader.LoadFunction<d_gtk_widget_set_clip>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_clip"));

		public void SetClip(Gdk.Rectangle clip) {
			IntPtr native_clip = GLib.Marshaller.StructureToPtrAlloc (clip);
			gtk_widget_set_clip(Handle, native_clip);
			Marshal.FreeHGlobal (native_clip);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_device_enabled(IntPtr raw, IntPtr device, bool enabled);
		static d_gtk_widget_set_device_enabled gtk_widget_set_device_enabled = FuncLoader.LoadFunction<d_gtk_widget_set_device_enabled>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_device_enabled"));

		public void SetDeviceEnabled(Gdk.Device device, bool enabled) {
			gtk_widget_set_device_enabled(Handle, device == null ? IntPtr.Zero : device.Handle, enabled);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_device_events(IntPtr raw, IntPtr device, int events);
		static d_gtk_widget_set_device_events gtk_widget_set_device_events = FuncLoader.LoadFunction<d_gtk_widget_set_device_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_device_events"));

		public void SetDeviceEvents(Gdk.Device device, Gdk.EventMask events) {
			gtk_widget_set_device_events(Handle, device == null ? IntPtr.Zero : device.Handle, (int) events);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_redraw_on_allocate(IntPtr raw, bool redraw_on_allocate);
		static d_gtk_widget_set_redraw_on_allocate gtk_widget_set_redraw_on_allocate = FuncLoader.LoadFunction<d_gtk_widget_set_redraw_on_allocate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_redraw_on_allocate"));

		public bool RedrawOnAllocate { 
			set {
				gtk_widget_set_redraw_on_allocate(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_size_request(IntPtr raw, int width, int height);
		static d_gtk_widget_set_size_request gtk_widget_set_size_request = FuncLoader.LoadFunction<d_gtk_widget_set_size_request>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_size_request"));

		public void SetSizeRequest(int width, int height) {
			gtk_widget_set_size_request(Handle, width, height);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_set_state_flags(IntPtr raw, int flags, bool clear);
		static d_gtk_widget_set_state_flags gtk_widget_set_state_flags = FuncLoader.LoadFunction<d_gtk_widget_set_state_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_set_state_flags"));

		public void SetStateFlags(Gtk.StateFlags flags, bool clear) {
			gtk_widget_set_state_flags(Handle, (int) flags, clear);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_shape_combine_region(IntPtr raw, IntPtr region);
		static d_gtk_widget_shape_combine_region gtk_widget_shape_combine_region = FuncLoader.LoadFunction<d_gtk_widget_shape_combine_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_shape_combine_region"));

		public void ShapeCombineRegion(Cairo.Region region) {
			gtk_widget_shape_combine_region(Handle, region == null ? IntPtr.Zero : region.Handle);
		}

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

		public void Show() {
			gtk_widget_show(Handle);
		}

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

		public void ShowAll() {
			gtk_widget_show_all(Handle);
		}

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

		public void ShowNow() {
			gtk_widget_show_now(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_size_allocate(IntPtr raw, IntPtr allocation);
		static d_gtk_widget_size_allocate gtk_widget_size_allocate = FuncLoader.LoadFunction<d_gtk_widget_size_allocate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_size_allocate"));

		public void SizeAllocate(Gdk.Rectangle allocation) {
			IntPtr native_allocation = GLib.Marshaller.StructureToPtrAlloc (allocation);
			gtk_widget_size_allocate(Handle, native_allocation);
			Marshal.FreeHGlobal (native_allocation);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_size_allocate_with_baseline(IntPtr raw, IntPtr allocation, int baseline);
		static d_gtk_widget_size_allocate_with_baseline gtk_widget_size_allocate_with_baseline = FuncLoader.LoadFunction<d_gtk_widget_size_allocate_with_baseline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_size_allocate_with_baseline"));

		public void SizeAllocateWithBaseline(Gdk.Rectangle allocation, int baseline) {
			IntPtr native_allocation = GLib.Marshaller.StructureToPtrAlloc (allocation);
			gtk_widget_size_allocate_with_baseline(Handle, native_allocation, baseline);
			Marshal.FreeHGlobal (native_allocation);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_size_request(IntPtr raw, IntPtr requisition);
		static d_gtk_widget_size_request gtk_widget_size_request = FuncLoader.LoadFunction<d_gtk_widget_size_request>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_size_request"));

		[Obsolete]
		public Gtk.Requisition SizeRequest() {
			Gtk.Requisition requisition;
			IntPtr native_requisition = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.Requisition>());
			gtk_widget_size_request(Handle, native_requisition);
			requisition = Gtk.Requisition.New (native_requisition);
			Marshal.FreeHGlobal (native_requisition);
			return requisition;
		}

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

		[Obsolete]
		public void StyleAttach() {
			gtk_widget_style_attach(Handle);
		}

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

		public void ThawChildNotify() {
			gtk_widget_thaw_child_notify(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_widget_translate_coordinates(IntPtr raw, IntPtr dest_widget, int src_x, int src_y, out int dest_x, out int dest_y);
		static d_gtk_widget_translate_coordinates gtk_widget_translate_coordinates = FuncLoader.LoadFunction<d_gtk_widget_translate_coordinates>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_translate_coordinates"));

		public bool TranslateCoordinates(Gtk.Widget dest_widget, int src_x, int src_y, out int dest_x, out int dest_y) {
			bool raw_ret = gtk_widget_translate_coordinates(Handle, dest_widget == null ? IntPtr.Zero : dest_widget.Handle, src_x, src_y, out dest_x, out dest_y);
			bool ret = raw_ret;
			return ret;
		}

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

		public void TriggerTooltipQuery() {
			gtk_widget_trigger_tooltip_query(Handle);
		}

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

		public void Unmap() {
			gtk_widget_unmap(Handle);
		}

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

		public void Unparent() {
			gtk_widget_unparent(Handle);
		}

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

		public void Unrealize() {
			gtk_widget_unrealize(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_unregister_window(IntPtr raw, IntPtr window);
		static d_gtk_widget_unregister_window gtk_widget_unregister_window = FuncLoader.LoadFunction<d_gtk_widget_unregister_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_unregister_window"));

		public void UnregisterWindow(Gdk.Window window) {
			gtk_widget_unregister_window(Handle, window == null ? IntPtr.Zero : window.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_widget_unset_state_flags(IntPtr raw, int flags);
		static d_gtk_widget_unset_state_flags gtk_widget_unset_state_flags = FuncLoader.LoadFunction<d_gtk_widget_unset_state_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_widget_unset_state_flags"));

		public void UnsetStateFlags(Gtk.StateFlags flags) {
			gtk_widget_unset_state_flags(Handle, (int) flags);
		}

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

		public Atk.Object RefAccessible() {
			IntPtr raw_ret = atk_implementor_ref_accessible(Handle);
			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
			return ret;
		}


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

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
