no more submodule

GtkSharp/Source/Libs/GdkSharp/Generated/GLib/GLibSharp.AsyncReadyCallbackNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GLibSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void AsyncReadyCallbackNative(IntPtr source_object, IntPtr res, IntPtr user_data);
+
+	internal class AsyncReadyCallbackInvoker {
+
+		AsyncReadyCallbackNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~AsyncReadyCallbackInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal AsyncReadyCallbackInvoker (AsyncReadyCallbackNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal AsyncReadyCallbackInvoker (AsyncReadyCallbackNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal AsyncReadyCallbackInvoker (AsyncReadyCallbackNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GLib.AsyncReadyCallback Handler {
+			get {
+				return new GLib.AsyncReadyCallback(InvokeNative);
+			}
+		}
+
+		void InvokeNative (GLib.Object source_object, GLib.IAsyncResult res)
+		{
+			native_cb (source_object == null ? IntPtr.Zero : source_object.Handle, res == null ? IntPtr.Zero : ((res is GLib.Object) ? (res as GLib.Object).Handle : (res as GLib.AsyncResultAdapter).Handle), __data);
+		}
+	}
+
+	internal class AsyncReadyCallbackWrapper {
+
+		public void NativeCallback (IntPtr source_object, IntPtr res, IntPtr user_data)
+		{
+			try {
+				managed (GLib.Object.GetObject (source_object), GLib.AsyncResultAdapter.GetObject (res, false));
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal AsyncReadyCallbackNative NativeDelegate;
+		GLib.AsyncReadyCallback managed;
+
+		public AsyncReadyCallbackWrapper (GLib.AsyncReadyCallback managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new AsyncReadyCallbackNative (NativeCallback);
+		}
+
+		public static GLib.AsyncReadyCallback GetManagedDelegate (AsyncReadyCallbackNative native)
+		{
+			if (native == null)
+				return null;
+			AsyncReadyCallbackWrapper wrapper = (AsyncReadyCallbackWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/GLib/GLibSharp.GSourceFuncNative.cs

@@ -0,0 +1,94 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GLibSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate bool GSourceFuncNative(IntPtr data);
+
+	internal class GSourceFuncInvoker {
+
+		GSourceFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~GSourceFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal GSourceFuncInvoker (GSourceFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal GSourceFuncInvoker (GSourceFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal GSourceFuncInvoker (GSourceFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GLib.GSourceFunc Handler {
+			get {
+				return new GLib.GSourceFunc(InvokeNative);
+			}
+		}
+
+		bool InvokeNative ()
+		{
+			bool __result = native_cb (__data);
+			return __result;
+		}
+	}
+
+	internal class GSourceFuncWrapper {
+
+		public bool NativeCallback (IntPtr data)
+		{
+			try {
+				bool __ret = managed ();
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+				return false;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal GSourceFuncNative NativeDelegate;
+		GLib.GSourceFunc managed;
+
+		public GSourceFuncWrapper (GLib.GSourceFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new GSourceFuncNative (NativeCallback);
+		}
+
+		public static GLib.GSourceFunc GetManagedDelegate (GSourceFuncNative native)
+		{
+			if (native == null)
+				return null;
+			GSourceFuncWrapper wrapper = (GSourceFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ActionChangedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void ActionChangedHandler(object o, ActionChangedArgs args);
+
+	public class ActionChangedArgs : GLib.SignalArgs {
+		public Gdk.DragAction Action{
+			get {
+				return (Gdk.DragAction) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/AnchorHints.cs

@@ -0,0 +1,37 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (Gdk.AnchorHintsGType))]
+	public enum AnchorHints {
+
+		FlipX = 1 << 0,
+		FlipY = 1 << 1,
+		SlideX = 1 << 2,
+		SlideY = 1 << 3,
+		ResizeX = 1 << 4,
+		ResizeY = 1 << 5,
+		Flip = FlipX | FlipY,
+		Slide = SlideX | SlideY,
+		Resize = ResizeX | ResizeY,
+	}
+
+	internal class AnchorHintsGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_anchor_hints_get_type();
+		static d_gdk_anchor_hints_get_type gdk_anchor_hints_get_type = FuncLoader.LoadFunction<d_gdk_anchor_hints_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_anchor_hints_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_anchor_hints_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/AppLaunchContext.cs

@@ -0,0 +1,115 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class AppLaunchContext : GLib.AppLaunchContext {
+
+		public AppLaunchContext (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_app_launch_context_new();
+		static d_gdk_app_launch_context_new gdk_app_launch_context_new = FuncLoader.LoadFunction<d_gdk_app_launch_context_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_new"));
+
+		[Obsolete]
+		public AppLaunchContext () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (AppLaunchContext)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gdk_app_launch_context_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_app_launch_context_set_display(IntPtr raw, IntPtr display);
+		static d_gdk_app_launch_context_set_display gdk_app_launch_context_set_display = FuncLoader.LoadFunction<d_gdk_app_launch_context_set_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_set_display"));
+
+		[Obsolete]
+		[GLib.Property ("display")]
+		public Gdk.Display Display {
+			get {
+				GLib.Value val = GetProperty ("display");
+				Gdk.Display ret = (Gdk.Display) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				gdk_app_launch_context_set_display(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_app_launch_context_get_type();
+		static d_gdk_app_launch_context_get_type gdk_app_launch_context_get_type = FuncLoader.LoadFunction<d_gdk_app_launch_context_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_app_launch_context_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_app_launch_context_set_desktop(IntPtr raw, int desktop);
+		static d_gdk_app_launch_context_set_desktop gdk_app_launch_context_set_desktop = FuncLoader.LoadFunction<d_gdk_app_launch_context_set_desktop>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_set_desktop"));
+
+		public int Desktop { 
+			set {
+				gdk_app_launch_context_set_desktop(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_app_launch_context_set_icon(IntPtr raw, IntPtr icon);
+		static d_gdk_app_launch_context_set_icon gdk_app_launch_context_set_icon = FuncLoader.LoadFunction<d_gdk_app_launch_context_set_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_set_icon"));
+
+		public GLib.IIcon Icon { 
+			set {
+				gdk_app_launch_context_set_icon(Handle, value == null ? IntPtr.Zero : ((value is GLib.Object) ? (value as GLib.Object).Handle : (value as GLib.IconAdapter).Handle));
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_app_launch_context_set_icon_name(IntPtr raw, IntPtr icon_name);
+		static d_gdk_app_launch_context_set_icon_name gdk_app_launch_context_set_icon_name = FuncLoader.LoadFunction<d_gdk_app_launch_context_set_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_set_icon_name"));
+
+		public string IconName { 
+			set {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gdk_app_launch_context_set_icon_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_app_launch_context_set_screen(IntPtr raw, IntPtr screen);
+		static d_gdk_app_launch_context_set_screen gdk_app_launch_context_set_screen = FuncLoader.LoadFunction<d_gdk_app_launch_context_set_screen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_set_screen"));
+
+		public Gdk.Screen Screen { 
+			set {
+				gdk_app_launch_context_set_screen(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_app_launch_context_set_timestamp(IntPtr raw, uint timestamp);
+		static d_gdk_app_launch_context_set_timestamp gdk_app_launch_context_set_timestamp = FuncLoader.LoadFunction<d_gdk_app_launch_context_set_timestamp>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_app_launch_context_set_timestamp"));
+
+		public uint Timestamp { 
+			set {
+				gdk_app_launch_context_set_timestamp(Handle, value);
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/AreaUpdatedHandler.cs

@@ -0,0 +1,36 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void AreaUpdatedHandler(object o, AreaUpdatedArgs args);
+
+	public class AreaUpdatedArgs : GLib.SignalArgs {
+		public int X{
+			get {
+				return (int) Args [0];
+			}
+		}
+
+		public int Y{
+			get {
+				return (int) Args [1];
+			}
+		}
+
+		public int Width{
+			get {
+				return (int) Args [2];
+			}
+		}
+
+		public int Height{
+			get {
+				return (int) Args [3];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ArgContext.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ArgContext : GLib.Opaque {
+
+		public ArgContext(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ArgDesc.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ArgDesc : GLib.Opaque {
+
+		public ArgDesc(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Atom.cs

@@ -0,0 +1,58 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Atom : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_atom_intern(IntPtr atom_name, bool only_if_exists);
+		static d_gdk_atom_intern gdk_atom_intern = FuncLoader.LoadFunction<d_gdk_atom_intern>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_atom_intern"));
+
+		public static Gdk.Atom Intern(string atom_name, bool only_if_exists) {
+			IntPtr native_atom_name = GLib.Marshaller.StringToPtrGStrdup (atom_name);
+			IntPtr raw_ret = gdk_atom_intern(native_atom_name, only_if_exists);
+			Gdk.Atom ret = raw_ret == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (raw_ret, typeof (Gdk.Atom), false);
+			GLib.Marshaller.Free (native_atom_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_atom_name(IntPtr raw);
+		static d_gdk_atom_name gdk_atom_name = FuncLoader.LoadFunction<d_gdk_atom_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_atom_name"));
+
+		public string Name { 
+			get {
+				IntPtr raw_ret = gdk_atom_name(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		public Atom(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/AxisFlags.cs

@@ -0,0 +1,37 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (Gdk.AxisFlagsGType))]
+	public enum AxisFlags {
+
+		X = AxisUse.X,
+		Y = AxisUse.Y,
+		Pressure = AxisUse.Pressure,
+		Xtilt = AxisUse.Xtilt,
+		Ytilt = AxisUse.Ytilt,
+		Wheel = AxisUse.Wheel,
+		Distance = AxisUse.Distance,
+		Rotation = AxisUse.Rotation,
+		Slider = AxisUse.Slider,
+	}
+
+	internal class AxisFlagsGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_axis_flags_get_type();
+		static d_gdk_axis_flags_get_type gdk_axis_flags_get_type = FuncLoader.LoadFunction<d_gdk_axis_flags_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_axis_flags_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_axis_flags_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/AxisInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AxisInfo : GLib.Opaque {
+
+		public AxisInfo(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/AxisUse.cs

@@ -0,0 +1,38 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.AxisUseGType))]
+	public enum AxisUse {
+
+		Ignore,
+		X,
+		Y,
+		Pressure,
+		Xtilt,
+		Ytilt,
+		Wheel,
+		Distance,
+		Rotation,
+		Slider,
+		Last,
+	}
+
+	internal class AxisUseGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_axis_use_get_type();
+		static d_gdk_axis_use_get_type gdk_axis_use_get_type = FuncLoader.LoadFunction<d_gdk_axis_use_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_axis_use_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_axis_use_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Backend.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Backend : GLib.Opaque {
+
+		public Backend(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ByteOrder.cs

@@ -0,0 +1,29 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.ByteOrderGType))]
+	public enum ByteOrder {
+
+		LsbFirst,
+		MsbFirst,
+	}
+
+	internal class ByteOrderGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_byte_order_get_type();
+		static d_gdk_byte_order_get_type gdk_byte_order_get_type = FuncLoader.LoadFunction<d_gdk_byte_order_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_byte_order_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_byte_order_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/CairoHelper.cs

@@ -0,0 +1,131 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoHelper {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cairo_create(IntPtr window);
+		static d_gdk_cairo_create gdk_cairo_create = FuncLoader.LoadFunction<d_gdk_cairo_create>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_create"));
+
+		[Obsolete]
+		public static Cairo.Context Create(Gdk.Window window) {
+			IntPtr raw_ret = gdk_cairo_create(window == null ? IntPtr.Zero : window.Handle);
+			Cairo.Context ret = new Cairo.Context (raw_ret, true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_cairo_draw_from_gl(IntPtr cr, IntPtr window, int source, int source_type, int buffer_scale, int x, int y, int width, int height);
+		static d_gdk_cairo_draw_from_gl gdk_cairo_draw_from_gl = FuncLoader.LoadFunction<d_gdk_cairo_draw_from_gl>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_draw_from_gl"));
+
+		public static void DrawFromGl(Cairo.Context cr, Gdk.Window window, int source, int source_type, int buffer_scale, int x, int y, int width, int height) {
+			gdk_cairo_draw_from_gl(cr == null ? IntPtr.Zero : cr.Handle, window == null ? IntPtr.Zero : window.Handle, source, source_type, buffer_scale, x, y, width, height);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_cairo_get_clip_rectangle(IntPtr cr, IntPtr rect);
+		static d_gdk_cairo_get_clip_rectangle gdk_cairo_get_clip_rectangle = FuncLoader.LoadFunction<d_gdk_cairo_get_clip_rectangle>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_get_clip_rectangle"));
+
+		public static bool GetClipRectangle(Cairo.Context cr, out Gdk.Rectangle rect) {
+			IntPtr native_rect = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
+			bool raw_ret = gdk_cairo_get_clip_rectangle(cr == null ? IntPtr.Zero : cr.Handle, native_rect);
+			bool ret = raw_ret;
+			rect = (Gdk.Rectangle) Marshal.PtrToStructure (native_rect, typeof (Gdk.Rectangle));
+			Marshal.FreeHGlobal (native_rect);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cairo_get_drawing_context(IntPtr cr);
+		static d_gdk_cairo_get_drawing_context gdk_cairo_get_drawing_context = FuncLoader.LoadFunction<d_gdk_cairo_get_drawing_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_get_drawing_context"));
+
+		public static Gdk.DrawingContext GetDrawingContext(Cairo.Context cr) {
+			IntPtr raw_ret = gdk_cairo_get_drawing_context(cr == null ? IntPtr.Zero : cr.Handle);
+			Gdk.DrawingContext ret = GLib.Object.GetObject(raw_ret) as Gdk.DrawingContext;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_cairo_rectangle(IntPtr cr, IntPtr rectangle);
+		static d_gdk_cairo_rectangle gdk_cairo_rectangle = FuncLoader.LoadFunction<d_gdk_cairo_rectangle>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_rectangle"));
+
+		public static void Rectangle(Cairo.Context cr, Gdk.Rectangle rectangle) {
+			IntPtr native_rectangle = GLib.Marshaller.StructureToPtrAlloc (rectangle);
+			gdk_cairo_rectangle(cr == null ? IntPtr.Zero : cr.Handle, native_rectangle);
+			Marshal.FreeHGlobal (native_rectangle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_cairo_region(IntPtr cr, IntPtr region);
+		static d_gdk_cairo_region gdk_cairo_region = FuncLoader.LoadFunction<d_gdk_cairo_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_region"));
+
+		public static void Region(Cairo.Context cr, Cairo.Region region) {
+			gdk_cairo_region(cr == null ? IntPtr.Zero : cr.Handle, region == null ? IntPtr.Zero : region.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cairo_region_create_from_surface(IntPtr surface);
+		static d_gdk_cairo_region_create_from_surface gdk_cairo_region_create_from_surface = FuncLoader.LoadFunction<d_gdk_cairo_region_create_from_surface>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_region_create_from_surface"));
+
+		public static Cairo.Region RegionCreateFromSurface(Cairo.Surface surface) {
+			IntPtr raw_ret = gdk_cairo_region_create_from_surface(surface.Handle);
+			Cairo.Region ret = new Cairo.Region(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_cairo_set_source_color(IntPtr cr, IntPtr color);
+		static d_gdk_cairo_set_source_color gdk_cairo_set_source_color = FuncLoader.LoadFunction<d_gdk_cairo_set_source_color>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_set_source_color"));
+
+		[Obsolete]
+		public static void SetSourceColor(Cairo.Context cr, Gdk.Color color) {
+			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
+			gdk_cairo_set_source_color(cr == null ? IntPtr.Zero : cr.Handle, native_color);
+			Marshal.FreeHGlobal (native_color);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_cairo_set_source_pixbuf(IntPtr cr, IntPtr pixbuf, double pixbuf_x, double pixbuf_y);
+		static d_gdk_cairo_set_source_pixbuf gdk_cairo_set_source_pixbuf = FuncLoader.LoadFunction<d_gdk_cairo_set_source_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_set_source_pixbuf"));
+
+		public static void SetSourcePixbuf(Cairo.Context cr, Gdk.Pixbuf pixbuf, double pixbuf_x, double pixbuf_y) {
+			gdk_cairo_set_source_pixbuf(cr == null ? IntPtr.Zero : cr.Handle, pixbuf == null ? IntPtr.Zero : pixbuf.Handle, pixbuf_x, pixbuf_y);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_cairo_set_source_rgba(IntPtr cr, IntPtr rgba);
+		static d_gdk_cairo_set_source_rgba gdk_cairo_set_source_rgba = FuncLoader.LoadFunction<d_gdk_cairo_set_source_rgba>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_set_source_rgba"));
+
+		public static void SetSourceRgba(Cairo.Context cr, Gdk.RGBA rgba) {
+			IntPtr native_rgba = GLib.Marshaller.StructureToPtrAlloc (rgba);
+			gdk_cairo_set_source_rgba(cr == null ? IntPtr.Zero : cr.Handle, native_rgba);
+			Marshal.FreeHGlobal (native_rgba);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_cairo_set_source_window(IntPtr cr, IntPtr window, double x, double y);
+		static d_gdk_cairo_set_source_window gdk_cairo_set_source_window = FuncLoader.LoadFunction<d_gdk_cairo_set_source_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_set_source_window"));
+
+		public static void SetSourceWindow(Cairo.Context cr, Gdk.Window window, double x, double y) {
+			gdk_cairo_set_source_window(cr == null ? IntPtr.Zero : cr.Handle, window == null ? IntPtr.Zero : window.Handle, x, y);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cairo_surface_create_from_pixbuf(IntPtr pixbuf, int scale, IntPtr for_window);
+		static d_gdk_cairo_surface_create_from_pixbuf gdk_cairo_surface_create_from_pixbuf = FuncLoader.LoadFunction<d_gdk_cairo_surface_create_from_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cairo_surface_create_from_pixbuf"));
+
+		public static Cairo.Surface SurfaceCreateFromPixbuf(Gdk.Pixbuf pixbuf, int scale, Gdk.Window for_window) {
+			IntPtr raw_ret = gdk_cairo_surface_create_from_pixbuf(pixbuf == null ? IntPtr.Zero : pixbuf.Handle, scale, for_window == null ? IntPtr.Zero : for_window.Handle);
+			Cairo.Surface ret = Cairo.Surface.Lookup (raw_ret, true);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/CancelHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void CancelHandler(object o, CancelArgs args);
+
+	public class CancelArgs : GLib.SignalArgs {
+		public Gdk.DragCancelReason Reason{
+			get {
+				return (Gdk.DragCancelReason) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ClientFilter.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ClientFilter : GLib.Opaque {
+
+		public ClientFilter(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ClosedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void ClosedHandler(object o, ClosedArgs args);
+
+	public class ClosedArgs : GLib.SignalArgs {
+		public bool IsError{
+			get {
+				return (bool) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Color.cs

@@ -0,0 +1,103 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct Color : IEquatable<Color> {
+
+		public uint Pixel;
+		public ushort Red;
+		public ushort Green;
+		public ushort Blue;
+
+		public static Gdk.Color Zero = new Gdk.Color ();
+
+		public static Gdk.Color New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.Color.Zero;
+			return (Gdk.Color) Marshal.PtrToStructure (raw, typeof (Gdk.Color));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_color_equal(IntPtr raw, IntPtr colorb);
+		static d_gdk_color_equal gdk_color_equal = FuncLoader.LoadFunction<d_gdk_color_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_color_equal"));
+
+		[Obsolete]
+		public bool Equal(Gdk.Color colorb) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Gdk.Color>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr native_colorb = GLib.Marshaller.StructureToPtrAlloc (colorb);
+			bool raw_ret = gdk_color_equal(this_as_native, native_colorb);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			Marshal.FreeHGlobal (native_colorb);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_color_get_type();
+		static d_gdk_color_get_type gdk_color_get_type = FuncLoader.LoadFunction<d_gdk_color_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_color_get_type"));
+
+		[Obsolete]
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_color_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_color_parse(IntPtr spec, IntPtr color);
+		static d_gdk_color_parse gdk_color_parse = FuncLoader.LoadFunction<d_gdk_color_parse>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_color_parse"));
+
+		[Obsolete]
+		public static bool Parse(string spec, ref Gdk.Color color) {
+			IntPtr native_spec = GLib.Marshaller.StringToPtrGStrdup (spec);
+			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
+			bool raw_ret = gdk_color_parse(native_spec, native_color);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_spec);
+			color = Gdk.Color.New (native_color);
+			Marshal.FreeHGlobal (native_color);
+			return ret;
+		}
+
+		static void ReadNative (IntPtr native, ref Gdk.Color target)
+		{
+			target = New (native);
+		}
+
+		public bool Equals (Color other)
+		{
+			return true && Pixel.Equals (other.Pixel) && Red.Equals (other.Red) && Green.Equals (other.Green) && Blue.Equals (other.Blue);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is Color && Equals ((Color) other);
+		}
+
+		public static explicit operator GLib.Value (Gdk.Color boxed)
+		{
+			GLib.Value val = GLib.Value.Empty;
+			val.Init (Gdk.Color.GType);
+			val.Val = boxed;
+			return val;
+		}
+
+		public static explicit operator Gdk.Color (GLib.Value val)
+		{
+			return (Gdk.Color) val.Val;
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Colorspace.cs

@@ -0,0 +1,28 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.ColorspaceGType))]
+	public enum Colorspace {
+
+		Rgb,
+	}
+
+	internal class ColorspaceGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_colorspace_get_type();
+		static d_gdk_colorspace_get_type gdk_colorspace_get_type = FuncLoader.LoadFunction<d_gdk_colorspace_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_colorspace_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_colorspace_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/CreateSurfaceHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void CreateSurfaceHandler(object o, CreateSurfaceArgs args);
+
+	public class CreateSurfaceArgs : GLib.SignalArgs {
+		public int Width{
+			get {
+				return (int) Args [0];
+			}
+		}
+
+		public int Height{
+			get {
+				return (int) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/CrossingMode.cs

@@ -0,0 +1,36 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.CrossingModeGType))]
+	public enum CrossingMode {
+
+		Normal,
+		Grab,
+		Ungrab,
+		GtkGrab,
+		GtkUngrab,
+		StateChanged,
+		TouchBegin,
+		TouchEnd,
+		DeviceSwitch,
+	}
+
+	internal class CrossingModeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_crossing_mode_get_type();
+		static d_gdk_crossing_mode_get_type gdk_crossing_mode_get_type = FuncLoader.LoadFunction<d_gdk_crossing_mode_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_crossing_mode_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_crossing_mode_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Cursor.cs

@@ -0,0 +1,270 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Cursor : GLib.Object {
+
+		public Cursor (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_new(int cursor_type);
+		static d_gdk_cursor_new gdk_cursor_new = FuncLoader.LoadFunction<d_gdk_cursor_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_new"));
+
+		[Obsolete]
+		public Cursor (Gdk.CursorType cursor_type) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Cursor)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				names.Add ("cursor_type");
+				vals.Add (new GLib.Value (cursor_type));
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gdk_cursor_new((int) cursor_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_new_for_display(IntPtr display, int cursor_type);
+		static d_gdk_cursor_new_for_display gdk_cursor_new_for_display = FuncLoader.LoadFunction<d_gdk_cursor_new_for_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_new_for_display"));
+
+		public Cursor (Gdk.Display display, Gdk.CursorType cursor_type) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Cursor)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (display != null) {
+					names.Add ("display");
+					vals.Add (new GLib.Value (display));
+				}
+				names.Add ("cursor_type");
+				vals.Add (new GLib.Value (cursor_type));
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gdk_cursor_new_for_display(display == null ? IntPtr.Zero : display.Handle, (int) cursor_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_new_from_name(IntPtr display, IntPtr name);
+		static d_gdk_cursor_new_from_name gdk_cursor_new_from_name = FuncLoader.LoadFunction<d_gdk_cursor_new_from_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_new_from_name"));
+
+		public Cursor (Gdk.Display display, string name) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Cursor)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (display != null) {
+					names.Add ("display");
+					vals.Add (new GLib.Value (display));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			Raw = gdk_cursor_new_from_name(display == null ? IntPtr.Zero : display.Handle, native_name);
+			GLib.Marshaller.Free (native_name);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_new_from_pixbuf(IntPtr display, IntPtr pixbuf, int x, int y);
+		static d_gdk_cursor_new_from_pixbuf gdk_cursor_new_from_pixbuf = FuncLoader.LoadFunction<d_gdk_cursor_new_from_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_new_from_pixbuf"));
+
+		public Cursor (Gdk.Display display, Gdk.Pixbuf pixbuf, int x, int y) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Cursor)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (display != null) {
+					names.Add ("display");
+					vals.Add (new GLib.Value (display));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gdk_cursor_new_from_pixbuf(display == null ? IntPtr.Zero : display.Handle, pixbuf == null ? IntPtr.Zero : pixbuf.Handle, x, y);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_new_from_surface(IntPtr display, IntPtr surface, double x, double y);
+		static d_gdk_cursor_new_from_surface gdk_cursor_new_from_surface = FuncLoader.LoadFunction<d_gdk_cursor_new_from_surface>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_new_from_surface"));
+
+		public Cursor (Gdk.Display display, Cairo.Surface surface, double x, double y) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Cursor)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (display != null) {
+					names.Add ("display");
+					vals.Add (new GLib.Value (display));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gdk_cursor_new_from_surface(display == null ? IntPtr.Zero : display.Handle, surface.Handle, x, y);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_cursor_get_cursor_type(IntPtr raw);
+		static d_gdk_cursor_get_cursor_type gdk_cursor_get_cursor_type = FuncLoader.LoadFunction<d_gdk_cursor_get_cursor_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_get_cursor_type"));
+
+		[GLib.Property ("cursor-type")]
+		public Gdk.CursorType CursorType {
+			get  {
+				int raw_ret = gdk_cursor_get_cursor_type(Handle);
+				Gdk.CursorType ret = (Gdk.CursorType) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_get_display(IntPtr raw);
+		static d_gdk_cursor_get_display gdk_cursor_get_display = FuncLoader.LoadFunction<d_gdk_cursor_get_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_get_display"));
+
+		[GLib.Property ("display")]
+		public Gdk.Display Display {
+			get  {
+				IntPtr raw_ret = gdk_cursor_get_display(Handle);
+				Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
+				return ret;
+			}
+		}
+
+		static GetSurfaceNativeDelegate GetSurface_cb_delegate;
+		static GetSurfaceNativeDelegate GetSurfaceVMCallback {
+			get {
+				if (GetSurface_cb_delegate == null)
+					GetSurface_cb_delegate = new GetSurfaceNativeDelegate (GetSurface_cb);
+				return GetSurface_cb_delegate;
+			}
+		}
+
+		static void OverrideGetSurface (GLib.GType gtype)
+		{
+			OverrideGetSurface (gtype, GetSurfaceVMCallback);
+		}
+
+		static void OverrideGetSurface (GLib.GType gtype, GetSurfaceNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_surface"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetSurfaceNativeDelegate (IntPtr inst, out double x_hot, out double y_hot);
+
+		static IntPtr GetSurface_cb (IntPtr inst, out double x_hot, out double y_hot)
+		{
+			try {
+				Cursor __obj = GLib.Object.GetObject (inst, false) as Cursor;
+				Cairo.Surface __result;
+				__result = __obj.OnGetSurface (out x_hot, out y_hot);
+				return __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Cursor), ConnectionMethod="OverrideGetSurface")]
+		protected virtual Cairo.Surface OnGetSurface (out double x_hot, out double y_hot)
+		{
+			return InternalGetSurface (out x_hot, out y_hot);
+		}
+
+		private Cairo.Surface InternalGetSurface (out double x_hot, out double y_hot)
+		{
+			GetSurfaceNativeDelegate unmanaged = class_abi.BaseOverride<GetSurfaceNativeDelegate>(this.LookupGType(), "get_surface");
+			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
+
+			IntPtr __result = unmanaged (this.Handle, out x_hot, out y_hot);
+			return Cairo.Surface.Lookup (__result, true);
+		}
+
+
+		// 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("get_surface"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // get_surface
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_get_image(IntPtr raw);
+		static d_gdk_cursor_get_image gdk_cursor_get_image = FuncLoader.LoadFunction<d_gdk_cursor_get_image>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_get_image"));
+
+		public Gdk.Pixbuf Image { 
+			get {
+				IntPtr raw_ret = gdk_cursor_get_image(Handle);
+				Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_get_surface(IntPtr raw, out double x_hot, out double y_hot);
+		static d_gdk_cursor_get_surface gdk_cursor_get_surface = FuncLoader.LoadFunction<d_gdk_cursor_get_surface>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_get_surface"));
+
+		public Cairo.Surface GetSurface(out double x_hot, out double y_hot) {
+			IntPtr raw_ret = gdk_cursor_get_surface(Handle, out x_hot, out y_hot);
+			Cairo.Surface ret = Cairo.Surface.Lookup (raw_ret, true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_get_type();
+		static d_gdk_cursor_get_type gdk_cursor_get_type = FuncLoader.LoadFunction<d_gdk_cursor_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_cursor_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/CursorType.cs

@@ -0,0 +1,107 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.CursorTypeGType))]
+	public enum CursorType {
+
+		XCursor,
+		Arrow = 2,
+		BasedArrowDown = 4,
+		BasedArrowUp = 6,
+		Boat = 8,
+		Bogosity = 10,
+		BottomLeftCorner = 12,
+		BottomRightCorner = 14,
+		BottomSide = 16,
+		BottomTee = 18,
+		BoxSpiral = 20,
+		CenterPtr = 22,
+		Circle = 24,
+		Clock = 26,
+		CoffeeMug = 28,
+		Cross = 30,
+		CrossReverse = 32,
+		Crosshair = 34,
+		DiamondCross = 36,
+		Dot = 38,
+		Dotbox = 40,
+		DoubleArrow = 42,
+		DraftLarge = 44,
+		DraftSmall = 46,
+		DrapedBox = 48,
+		Exchange = 50,
+		Fleur = 52,
+		Gobbler = 54,
+		Gumby = 56,
+		Hand1 = 58,
+		Hand2 = 60,
+		Heart = 62,
+		Icon = 64,
+		IronCross = 66,
+		LeftPtr = 68,
+		LeftSide = 70,
+		LeftTee = 72,
+		Leftbutton = 74,
+		LlAngle = 76,
+		LrAngle = 78,
+		Man = 80,
+		Middlebutton = 82,
+		Mouse = 84,
+		Pencil = 86,
+		Pirate = 88,
+		Plus = 90,
+		QuestionArrow = 92,
+		RightPtr = 94,
+		RightSide = 96,
+		RightTee = 98,
+		Rightbutton = 100,
+		RtlLogo = 102,
+		Sailboat = 104,
+		SbDownArrow = 106,
+		SbHDoubleArrow = 108,
+		SbLeftArrow = 110,
+		SbRightArrow = 112,
+		SbUpArrow = 114,
+		SbVDoubleArrow = 116,
+		Shuttle = 118,
+		Sizing = 120,
+		Spider = 122,
+		Spraycan = 124,
+		Star = 126,
+		Target = 128,
+		Tcross = 130,
+		TopLeftArrow = 132,
+		TopLeftCorner = 134,
+		TopRightCorner = 136,
+		TopSide = 138,
+		TopTee = 140,
+		Trek = 142,
+		UlAngle = 144,
+		Umbrella = 146,
+		UrAngle = 148,
+		Watch = 150,
+		Xterm = 152,
+		LastCursor,
+		BlankCursor = -2,
+		CursorIsPixmap = -1,
+	}
+
+	internal class CursorTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_cursor_type_get_type();
+		static d_gdk_cursor_type_get_type gdk_cursor_type_get_type = FuncLoader.LoadFunction<d_gdk_cursor_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_cursor_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_cursor_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DeviceAddedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void DeviceAddedHandler(object o, DeviceAddedArgs args);
+
+	public class DeviceAddedArgs : GLib.SignalArgs {
+		public Gdk.Device Device{
+			get {
+				return (Gdk.Device) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DeviceChangedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void DeviceChangedHandler(object o, DeviceChangedArgs args);
+
+	public class DeviceChangedArgs : GLib.SignalArgs {
+		public Gdk.Device Device{
+			get {
+				return (Gdk.Device) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DeviceManager.cs

@@ -0,0 +1,429 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class DeviceManager : GLib.Object {
+
+		public DeviceManager (IntPtr raw) : base(raw) {}
+
+		protected DeviceManager() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_manager_get_display(IntPtr raw);
+		static d_gdk_device_manager_get_display gdk_device_manager_get_display = FuncLoader.LoadFunction<d_gdk_device_manager_get_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_manager_get_display"));
+
+		[GLib.Property ("display")]
+		public Gdk.Display Display {
+			get  {
+				IntPtr raw_ret = gdk_device_manager_get_display(Handle);
+				Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
+				return ret;
+			}
+		}
+
+		[GLib.Signal("device-added")]
+		public event Gdk.DeviceAddedHandler DeviceAdded {
+			add {
+				this.AddSignalHandler ("device-added", value, typeof (Gdk.DeviceAddedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("device-added", value);
+			}
+		}
+
+		[GLib.Signal("device-removed")]
+		public event Gdk.DeviceRemovedHandler DeviceRemoved {
+			add {
+				this.AddSignalHandler ("device-removed", value, typeof (Gdk.DeviceRemovedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("device-removed", value);
+			}
+		}
+
+		[GLib.Signal("device-changed")]
+		public event Gdk.DeviceChangedHandler DeviceChanged {
+			add {
+				this.AddSignalHandler ("device-changed", value, typeof (Gdk.DeviceChangedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("device-changed", value);
+			}
+		}
+
+		static DeviceAddedNativeDelegate DeviceAdded_cb_delegate;
+		static DeviceAddedNativeDelegate DeviceAddedVMCallback {
+			get {
+				if (DeviceAdded_cb_delegate == null)
+					DeviceAdded_cb_delegate = new DeviceAddedNativeDelegate (DeviceAdded_cb);
+				return DeviceAdded_cb_delegate;
+			}
+		}
+
+		static void OverrideDeviceAdded (GLib.GType gtype)
+		{
+			OverrideDeviceAdded (gtype, DeviceAddedVMCallback);
+		}
+
+		static void OverrideDeviceAdded (GLib.GType gtype, DeviceAddedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("device_added"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void DeviceAddedNativeDelegate (IntPtr inst, IntPtr device);
+
+		static void DeviceAdded_cb (IntPtr inst, IntPtr device)
+		{
+			try {
+				DeviceManager __obj = GLib.Object.GetObject (inst, false) as DeviceManager;
+				__obj.OnDeviceAdded (GLib.Object.GetObject(device) as Gdk.Device);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.DeviceManager), ConnectionMethod="OverrideDeviceAdded")]
+		protected virtual void OnDeviceAdded (Gdk.Device device)
+		{
+			InternalDeviceAdded (device);
+		}
+
+		private void InternalDeviceAdded (Gdk.Device device)
+		{
+			DeviceAddedNativeDelegate unmanaged = class_abi.BaseOverride<DeviceAddedNativeDelegate>(this.LookupGType(), "device_added");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, device == null ? IntPtr.Zero : device.Handle);
+		}
+
+		static DeviceRemovedNativeDelegate DeviceRemoved_cb_delegate;
+		static DeviceRemovedNativeDelegate DeviceRemovedVMCallback {
+			get {
+				if (DeviceRemoved_cb_delegate == null)
+					DeviceRemoved_cb_delegate = new DeviceRemovedNativeDelegate (DeviceRemoved_cb);
+				return DeviceRemoved_cb_delegate;
+			}
+		}
+
+		static void OverrideDeviceRemoved (GLib.GType gtype)
+		{
+			OverrideDeviceRemoved (gtype, DeviceRemovedVMCallback);
+		}
+
+		static void OverrideDeviceRemoved (GLib.GType gtype, DeviceRemovedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("device_removed"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void DeviceRemovedNativeDelegate (IntPtr inst, IntPtr device);
+
+		static void DeviceRemoved_cb (IntPtr inst, IntPtr device)
+		{
+			try {
+				DeviceManager __obj = GLib.Object.GetObject (inst, false) as DeviceManager;
+				__obj.OnDeviceRemoved (GLib.Object.GetObject(device) as Gdk.Device);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.DeviceManager), ConnectionMethod="OverrideDeviceRemoved")]
+		protected virtual void OnDeviceRemoved (Gdk.Device device)
+		{
+			InternalDeviceRemoved (device);
+		}
+
+		private void InternalDeviceRemoved (Gdk.Device device)
+		{
+			DeviceRemovedNativeDelegate unmanaged = class_abi.BaseOverride<DeviceRemovedNativeDelegate>(this.LookupGType(), "device_removed");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, device == null ? IntPtr.Zero : device.Handle);
+		}
+
+		static DeviceChangedNativeDelegate DeviceChanged_cb_delegate;
+		static DeviceChangedNativeDelegate DeviceChangedVMCallback {
+			get {
+				if (DeviceChanged_cb_delegate == null)
+					DeviceChanged_cb_delegate = new DeviceChangedNativeDelegate (DeviceChanged_cb);
+				return DeviceChanged_cb_delegate;
+			}
+		}
+
+		static void OverrideDeviceChanged (GLib.GType gtype)
+		{
+			OverrideDeviceChanged (gtype, DeviceChangedVMCallback);
+		}
+
+		static void OverrideDeviceChanged (GLib.GType gtype, DeviceChangedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("device_changed"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void DeviceChangedNativeDelegate (IntPtr inst, IntPtr device);
+
+		static void DeviceChanged_cb (IntPtr inst, IntPtr device)
+		{
+			try {
+				DeviceManager __obj = GLib.Object.GetObject (inst, false) as DeviceManager;
+				__obj.OnDeviceChanged (GLib.Object.GetObject(device) as Gdk.Device);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.DeviceManager), ConnectionMethod="OverrideDeviceChanged")]
+		protected virtual void OnDeviceChanged (Gdk.Device device)
+		{
+			InternalDeviceChanged (device);
+		}
+
+		private void InternalDeviceChanged (Gdk.Device device)
+		{
+			DeviceChangedNativeDelegate unmanaged = class_abi.BaseOverride<DeviceChangedNativeDelegate>(this.LookupGType(), "device_changed");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, device == null ? IntPtr.Zero : device.Handle);
+		}
+
+		static ListDevicesNativeDelegate ListDevices_cb_delegate;
+		static ListDevicesNativeDelegate ListDevicesVMCallback {
+			get {
+				if (ListDevices_cb_delegate == null)
+					ListDevices_cb_delegate = new ListDevicesNativeDelegate (ListDevices_cb);
+				return ListDevices_cb_delegate;
+			}
+		}
+
+		static void OverrideListDevices (GLib.GType gtype)
+		{
+			OverrideListDevices (gtype, ListDevicesVMCallback);
+		}
+
+		static void OverrideListDevices (GLib.GType gtype, ListDevicesNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("list_devices"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr ListDevicesNativeDelegate (IntPtr inst, int type);
+
+		static IntPtr ListDevices_cb (IntPtr inst, int type)
+		{
+			try {
+				DeviceManager __obj = GLib.Object.GetObject (inst, false) as DeviceManager;
+				Gdk.Device[] __result;
+				__result = __obj.OnListDevices ((Gdk.DeviceType) type);
+				return new GLib.List(__result, typeof (Gdk.Device), true, false) == null ? IntPtr.Zero : new GLib.List(__result, typeof (Gdk.Device), true, false).Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.DeviceManager), ConnectionMethod="OverrideListDevices")]
+		protected virtual Gdk.Device[] OnListDevices (Gdk.DeviceType type)
+		{
+			return InternalListDevices (type);
+		}
+
+		private Gdk.Device[] InternalListDevices (Gdk.DeviceType type)
+		{
+			ListDevicesNativeDelegate unmanaged = class_abi.BaseOverride<ListDevicesNativeDelegate>(this.LookupGType(), "list_devices");
+			if (unmanaged == null) return null;
+
+			IntPtr __result = unmanaged (this.Handle, (int) type);
+			return GLib.Marshaller.ListPtrToArray<Gdk.Device, Gdk.Device> (__result, true, false);
+		}
+
+		static GetClientPointerNativeDelegate GetClientPointer_cb_delegate;
+		static GetClientPointerNativeDelegate GetClientPointerVMCallback {
+			get {
+				if (GetClientPointer_cb_delegate == null)
+					GetClientPointer_cb_delegate = new GetClientPointerNativeDelegate (GetClientPointer_cb);
+				return GetClientPointer_cb_delegate;
+			}
+		}
+
+		static void OverrideGetClientPointer (GLib.GType gtype)
+		{
+			OverrideGetClientPointer (gtype, GetClientPointerVMCallback);
+		}
+
+		static void OverrideGetClientPointer (GLib.GType gtype, GetClientPointerNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_client_pointer"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetClientPointerNativeDelegate (IntPtr inst);
+
+		static IntPtr GetClientPointer_cb (IntPtr inst)
+		{
+			try {
+				DeviceManager __obj = GLib.Object.GetObject (inst, false) as DeviceManager;
+				Gdk.Device __result;
+				__result = __obj.OnGetClientPointer ();
+				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(Gdk.DeviceManager), ConnectionMethod="OverrideGetClientPointer")]
+		protected virtual Gdk.Device OnGetClientPointer ()
+		{
+			return InternalGetClientPointer ();
+		}
+
+		private Gdk.Device InternalGetClientPointer ()
+		{
+			GetClientPointerNativeDelegate unmanaged = class_abi.BaseOverride<GetClientPointerNativeDelegate>(this.LookupGType(), "get_client_pointer");
+			if (unmanaged == null) return null;
+
+			IntPtr __result = unmanaged (this.Handle);
+			return GLib.Object.GetObject(__result) as Gdk.Device;
+		}
+
+
+		// 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("device_added"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // device_added
+							, null
+							, "device_removed"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("device_removed"
+							, -1
+							, (uint) sizeof( IntPtr ) // device_removed
+							, "device_added"
+							, "device_changed"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("device_changed"
+							, -1
+							, (uint) sizeof( IntPtr ) // device_changed
+							, "device_removed"
+							, "list_devices"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("list_devices"
+							, -1
+							, (uint) sizeof( IntPtr ) // list_devices
+							, "device_changed"
+							, "get_client_pointer"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_client_pointer"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_client_pointer
+							, "list_devices"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_manager_get_client_pointer(IntPtr raw);
+		static d_gdk_device_manager_get_client_pointer gdk_device_manager_get_client_pointer = FuncLoader.LoadFunction<d_gdk_device_manager_get_client_pointer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_manager_get_client_pointer"));
+
+		[Obsolete]
+		public Gdk.Device ClientPointer { 
+			get {
+				IntPtr raw_ret = gdk_device_manager_get_client_pointer(Handle);
+				Gdk.Device ret = GLib.Object.GetObject(raw_ret) as Gdk.Device;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_manager_get_type();
+		static d_gdk_device_manager_get_type gdk_device_manager_get_type = FuncLoader.LoadFunction<d_gdk_device_manager_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_manager_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_device_manager_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_manager_list_devices(IntPtr raw, int type);
+		static d_gdk_device_manager_list_devices gdk_device_manager_list_devices = FuncLoader.LoadFunction<d_gdk_device_manager_list_devices>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_manager_list_devices"));
+
+		[Obsolete]
+		public Gdk.Device[] ListDevices(Gdk.DeviceType type) {
+			IntPtr raw_ret = gdk_device_manager_list_devices(Handle, (int) type);
+			Gdk.Device[] ret = GLib.Marshaller.ListPtrToArray<Gdk.Device, Gdk.Device> (raw_ret, true, false);
+			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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DevicePadAdapter.cs

@@ -0,0 +1,233 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class DevicePadAdapter : GLib.GInterfaceAdapter, Gdk.IDevicePad {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct GdkDevicePadInterface {
+			public GetNGroupsNativeDelegate GetNGroups;
+			public GetGroupNModesNativeDelegate GetGroupNModes;
+			public GetNFeaturesNativeDelegate GetNFeatures;
+			public GetFeatureGroupNativeDelegate GetFeatureGroup;
+		}
+
+		static GdkDevicePadInterface iface;
+
+		static DevicePadAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (DevicePadAdapter));
+			iface.GetNGroups = new GetNGroupsNativeDelegate (GetNGroups_cb);
+			iface.GetGroupNModes = new GetGroupNModesNativeDelegate (GetGroupNModes_cb);
+			iface.GetNFeatures = new GetNFeaturesNativeDelegate (GetNFeatures_cb);
+			iface.GetFeatureGroup = new GetFeatureGroupNativeDelegate (GetFeatureGroup_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetNGroupsNativeDelegate (IntPtr inst);
+
+		static int GetNGroups_cb (IntPtr inst)
+		{
+			try {
+				IDevicePadImplementor __obj = GLib.Object.GetObject (inst, false) as IDevicePadImplementor;
+				int __result;
+				__result = __obj.NGroups;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetGroupNModesNativeDelegate (IntPtr inst, int group);
+
+		static int GetGroupNModes_cb (IntPtr inst, int group)
+		{
+			try {
+				IDevicePadImplementor __obj = GLib.Object.GetObject (inst, false) as IDevicePadImplementor;
+				int __result;
+				__result = __obj.GetGroupNModes (group);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetNFeaturesNativeDelegate (IntPtr inst, int feature);
+
+		static int GetNFeatures_cb (IntPtr inst, int feature)
+		{
+			try {
+				IDevicePadImplementor __obj = GLib.Object.GetObject (inst, false) as IDevicePadImplementor;
+				int __result;
+				__result = __obj.GetNFeatures ((Gdk.DevicePadFeature) feature);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetFeatureGroupNativeDelegate (IntPtr inst, int feature, int idx);
+
+		static int GetFeatureGroup_cb (IntPtr inst, int feature, int idx)
+		{
+			try {
+				IDevicePadImplementor __obj = GLib.Object.GetObject (inst, false) as IDevicePadImplementor;
+				int __result;
+				__result = __obj.GetFeatureGroup ((Gdk.DevicePadFeature) feature, idx);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		static int class_offset = 2 * IntPtr.Size;
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
+			GdkDevicePadInterface native_iface = (GdkDevicePadInterface) Marshal.PtrToStructure (ifaceptr, typeof (GdkDevicePadInterface));
+			native_iface.GetNGroups = iface.GetNGroups;
+			native_iface.GetGroupNModes = iface.GetGroupNModes;
+			native_iface.GetNFeatures = iface.GetNFeatures;
+			native_iface.GetFeatureGroup = iface.GetFeatureGroup;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public DevicePadAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public DevicePadAdapter (IDevicePadImplementor implementor)
+		{
+			if (implementor == null)
+				throw new ArgumentNullException ("implementor");
+			else if (!(implementor is GLib.Object))
+				throw new ArgumentException ("implementor must be a subclass of GLib.Object");
+			this.implementor = implementor as GLib.Object;
+		}
+
+		public DevicePadAdapter (IntPtr handle)
+		{
+			if (!_gtype.IsInstance (handle))
+				throw new ArgumentException ("The gobject doesn't implement the GInterface of this adapter", "handle");
+			implementor = GLib.Object.GetObject (handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_pad_get_type();
+		static d_gdk_device_pad_get_type gdk_device_pad_get_type = FuncLoader.LoadFunction<d_gdk_device_pad_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_pad_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (gdk_device_pad_get_type ());
+
+		public static GLib.GType GType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override GLib.GType GInterfaceGType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override IntPtr Handle {
+			get {
+				return implementor.Handle;
+			}
+		}
+
+		public IntPtr OwnedHandle {
+			get {
+				return implementor.OwnedHandle;
+			}
+		}
+
+		public static IDevicePad GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IDevicePad GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IDevicePadImplementor)
+				return new DevicePadAdapter (obj as IDevicePadImplementor);
+			else if (obj as IDevicePad == null)
+				return new DevicePadAdapter (obj.Handle);
+			else
+				return obj as IDevicePad;
+		}
+
+		public IDevicePadImplementor Implementor {
+			get {
+				return implementor as IDevicePadImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_device_pad_get_feature_group(IntPtr raw, int feature, int feature_idx);
+		static d_gdk_device_pad_get_feature_group gdk_device_pad_get_feature_group = FuncLoader.LoadFunction<d_gdk_device_pad_get_feature_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_pad_get_feature_group"));
+
+		public int GetFeatureGroup(Gdk.DevicePadFeature feature, int feature_idx) {
+			int raw_ret = gdk_device_pad_get_feature_group(Handle, (int) feature, feature_idx);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_device_pad_get_group_n_modes(IntPtr raw, int group_idx);
+		static d_gdk_device_pad_get_group_n_modes gdk_device_pad_get_group_n_modes = FuncLoader.LoadFunction<d_gdk_device_pad_get_group_n_modes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_pad_get_group_n_modes"));
+
+		public int GetGroupNModes(int group_idx) {
+			int raw_ret = gdk_device_pad_get_group_n_modes(Handle, group_idx);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_device_pad_get_n_features(IntPtr raw, int feature);
+		static d_gdk_device_pad_get_n_features gdk_device_pad_get_n_features = FuncLoader.LoadFunction<d_gdk_device_pad_get_n_features>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_pad_get_n_features"));
+
+		public int GetNFeatures(Gdk.DevicePadFeature feature) {
+			int raw_ret = gdk_device_pad_get_n_features(Handle, (int) feature);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_device_pad_get_n_groups(IntPtr raw);
+		static d_gdk_device_pad_get_n_groups gdk_device_pad_get_n_groups = FuncLoader.LoadFunction<d_gdk_device_pad_get_n_groups>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_pad_get_n_groups"));
+
+		public int NGroups { 
+			get {
+				int raw_ret = gdk_device_pad_get_n_groups(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DevicePadFeature.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.DevicePadFeatureGType))]
+	public enum DevicePadFeature {
+
+		Button,
+		Ring,
+		Strip,
+	}
+
+	internal class DevicePadFeatureGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_pad_feature_get_type();
+		static d_gdk_device_pad_feature_get_type gdk_device_pad_feature_get_type = FuncLoader.LoadFunction<d_gdk_device_pad_feature_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_pad_feature_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_device_pad_feature_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DeviceRemovedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void DeviceRemovedHandler(object o, DeviceRemovedArgs args);
+
+	public class DeviceRemovedArgs : GLib.SignalArgs {
+		public Gdk.Device Device{
+			get {
+				return (Gdk.Device) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DeviceTool.cs

@@ -0,0 +1,115 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class DeviceTool : GLib.Object {
+
+		public DeviceTool (IntPtr raw) : base(raw) {}
+
+		protected DeviceTool() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate ulong d_gdk_device_tool_get_serial(IntPtr raw);
+		static d_gdk_device_tool_get_serial gdk_device_tool_get_serial = FuncLoader.LoadFunction<d_gdk_device_tool_get_serial>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_tool_get_serial"));
+
+		[GLib.Property ("serial")]
+		public ulong Serial {
+			get  {
+				ulong raw_ret = gdk_device_tool_get_serial(Handle);
+				ulong ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_device_tool_get_tool_type(IntPtr raw);
+		static d_gdk_device_tool_get_tool_type gdk_device_tool_get_tool_type = FuncLoader.LoadFunction<d_gdk_device_tool_get_tool_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_tool_get_tool_type"));
+
+		[GLib.Property ("tool-type")]
+		public Gdk.DeviceToolType ToolType {
+			get  {
+				int raw_ret = gdk_device_tool_get_tool_type(Handle);
+				Gdk.DeviceToolType ret = (Gdk.DeviceToolType) raw_ret;
+				return ret;
+			}
+		}
+
+		[GLib.Property ("axes")]
+		public Gdk.AxisFlags Axes {
+			get {
+				GLib.Value val = GetProperty ("axes");
+				Gdk.AxisFlags ret = (Gdk.AxisFlags) (Enum) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate ulong d_gdk_device_tool_get_hardware_id(IntPtr raw);
+		static d_gdk_device_tool_get_hardware_id gdk_device_tool_get_hardware_id = FuncLoader.LoadFunction<d_gdk_device_tool_get_hardware_id>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_tool_get_hardware_id"));
+
+		[GLib.Property ("hardware-id")]
+		public ulong HardwareId {
+			get  {
+				ulong raw_ret = gdk_device_tool_get_hardware_id(Handle);
+				ulong ret = raw_ret;
+				return ret;
+			}
+		}
+
+
+		// 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 (GLib.Object.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_tool_get_type();
+		static d_gdk_device_tool_get_type gdk_device_tool_get_type = FuncLoader.LoadFunction<d_gdk_device_tool_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_tool_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_device_tool_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DeviceToolType.cs

@@ -0,0 +1,35 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.DeviceToolTypeGType))]
+	public enum DeviceToolType {
+
+		Unknown,
+		Pen,
+		Eraser,
+		Brush,
+		Pencil,
+		Airbrush,
+		Mouse,
+		Lens,
+	}
+
+	internal class DeviceToolTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_tool_type_get_type();
+		static d_gdk_device_tool_type_get_type gdk_device_tool_type_get_type = FuncLoader.LoadFunction<d_gdk_device_tool_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_tool_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_device_tool_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DeviceType.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.DeviceTypeGType))]
+	public enum DeviceType {
+
+		Master,
+		Slave,
+		Floating,
+	}
+
+	internal class DeviceTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_device_type_get_type();
+		static d_gdk_device_type_get_type gdk_device_type_get_type = FuncLoader.LoadFunction<d_gdk_device_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_device_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DisplayManager.cs

@@ -0,0 +1,176 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class DisplayManager : GLib.Object {
+
+		public DisplayManager (IntPtr raw) : base(raw) {}
+
+		protected DisplayManager() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_display_manager_get_default_display(IntPtr raw);
+		static d_gdk_display_manager_get_default_display gdk_display_manager_get_default_display = FuncLoader.LoadFunction<d_gdk_display_manager_get_default_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_manager_get_default_display"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_display_manager_set_default_display(IntPtr raw, IntPtr display);
+		static d_gdk_display_manager_set_default_display gdk_display_manager_set_default_display = FuncLoader.LoadFunction<d_gdk_display_manager_set_default_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_manager_set_default_display"));
+
+		[GLib.Property ("default-display")]
+		public Gdk.Display DefaultDisplay {
+			get  {
+				IntPtr raw_ret = gdk_display_manager_get_default_display(Handle);
+				Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
+				return ret;
+			}
+			set  {
+				gdk_display_manager_set_default_display(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[GLib.Signal("display-opened")]
+		public event Gdk.DisplayOpenedHandler DisplayOpened {
+			add {
+				this.AddSignalHandler ("display-opened", value, typeof (Gdk.DisplayOpenedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("display-opened", value);
+			}
+		}
+
+		static DisplayOpenedNativeDelegate DisplayOpened_cb_delegate;
+		static DisplayOpenedNativeDelegate DisplayOpenedVMCallback {
+			get {
+				if (DisplayOpened_cb_delegate == null)
+					DisplayOpened_cb_delegate = new DisplayOpenedNativeDelegate (DisplayOpened_cb);
+				return DisplayOpened_cb_delegate;
+			}
+		}
+
+		static void OverrideDisplayOpened (GLib.GType gtype)
+		{
+			OverrideDisplayOpened (gtype, DisplayOpenedVMCallback);
+		}
+
+		static void OverrideDisplayOpened (GLib.GType gtype, DisplayOpenedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("display_opened"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void DisplayOpenedNativeDelegate (IntPtr inst, IntPtr display);
+
+		static void DisplayOpened_cb (IntPtr inst, IntPtr display)
+		{
+			try {
+				DisplayManager __obj = GLib.Object.GetObject (inst, false) as DisplayManager;
+				__obj.OnDisplayOpened (GLib.Object.GetObject(display) as Gdk.Display);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.DisplayManager), ConnectionMethod="OverrideDisplayOpened")]
+		protected virtual void OnDisplayOpened (Gdk.Display display)
+		{
+			InternalDisplayOpened (display);
+		}
+
+		private void InternalDisplayOpened (Gdk.Display display)
+		{
+			DisplayOpenedNativeDelegate unmanaged = class_abi.BaseOverride<DisplayOpenedNativeDelegate>(this.LookupGType(), "display_opened");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, display == null ? IntPtr.Zero : display.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("display_opened"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // display_opened
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_display_manager_get();
+		static d_gdk_display_manager_get gdk_display_manager_get = FuncLoader.LoadFunction<d_gdk_display_manager_get>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_manager_get"));
+
+		public static Gdk.DisplayManager Get() {
+			IntPtr raw_ret = gdk_display_manager_get();
+			Gdk.DisplayManager ret = GLib.Object.GetObject(raw_ret) as Gdk.DisplayManager;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_display_manager_get_type();
+		static d_gdk_display_manager_get_type gdk_display_manager_get_type = FuncLoader.LoadFunction<d_gdk_display_manager_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_manager_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_display_manager_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_display_manager_open_display(IntPtr raw, IntPtr name);
+		static d_gdk_display_manager_open_display gdk_display_manager_open_display = FuncLoader.LoadFunction<d_gdk_display_manager_open_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_manager_open_display"));
+
+		public Gdk.Display OpenDisplay(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			IntPtr raw_ret = gdk_display_manager_open_display(Handle, native_name);
+			Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
+			GLib.Marshaller.Free (native_name);
+			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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DisplayOpenedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void DisplayOpenedHandler(object o, DisplayOpenedArgs args);
+
+	public class DisplayOpenedArgs : GLib.SignalArgs {
+		public Gdk.Display Display{
+			get {
+				return (Gdk.Display) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Drag.cs

@@ -0,0 +1,108 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Drag {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_drag_abort(IntPtr context, uint time_);
+		static d_gdk_drag_abort gdk_drag_abort = FuncLoader.LoadFunction<d_gdk_drag_abort>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_abort"));
+
+		public static void Abort(Gdk.DragContext context, uint time_) {
+			gdk_drag_abort(context == null ? IntPtr.Zero : context.Handle, time_);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drag_begin_for_device(IntPtr window, IntPtr device, IntPtr targets);
+		static d_gdk_drag_begin_for_device gdk_drag_begin_for_device = FuncLoader.LoadFunction<d_gdk_drag_begin_for_device>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_begin_for_device"));
+
+		public static Gdk.DragContext BeginForDevice(Gdk.Window window, Gdk.Device device, GLib.List targets) {
+			IntPtr raw_ret = gdk_drag_begin_for_device(window == null ? IntPtr.Zero : window.Handle, device == null ? IntPtr.Zero : device.Handle, targets == null ? IntPtr.Zero : targets.Handle);
+			Gdk.DragContext ret = GLib.Object.GetObject(raw_ret) as Gdk.DragContext;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drag_begin_from_point(IntPtr window, IntPtr device, IntPtr targets, int x_root, int y_root);
+		static d_gdk_drag_begin_from_point gdk_drag_begin_from_point = FuncLoader.LoadFunction<d_gdk_drag_begin_from_point>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_begin_from_point"));
+
+		public static Gdk.DragContext BeginFromPoint(Gdk.Window window, Gdk.Device device, GLib.List targets, int x_root, int y_root) {
+			IntPtr raw_ret = gdk_drag_begin_from_point(window == null ? IntPtr.Zero : window.Handle, device == null ? IntPtr.Zero : device.Handle, targets == null ? IntPtr.Zero : targets.Handle, x_root, y_root);
+			Gdk.DragContext ret = GLib.Object.GetObject(raw_ret) as Gdk.DragContext;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_drag_drop(IntPtr context, uint time_);
+		static d_gdk_drag_drop gdk_drag_drop = FuncLoader.LoadFunction<d_gdk_drag_drop>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_drop"));
+
+		public static void Drop(Gdk.DragContext context, uint time_) {
+			gdk_drag_drop(context == null ? IntPtr.Zero : context.Handle, time_);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_drag_drop_done(IntPtr context, bool success);
+		static d_gdk_drag_drop_done gdk_drag_drop_done = FuncLoader.LoadFunction<d_gdk_drag_drop_done>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_drop_done"));
+
+		public static void DropDone(Gdk.DragContext context, bool success) {
+			gdk_drag_drop_done(context == null ? IntPtr.Zero : context.Handle, success);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_drag_drop_succeeded(IntPtr context);
+		static d_gdk_drag_drop_succeeded gdk_drag_drop_succeeded = FuncLoader.LoadFunction<d_gdk_drag_drop_succeeded>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_drop_succeeded"));
+
+		public static bool DropSucceeded(Gdk.DragContext context) {
+			bool raw_ret = gdk_drag_drop_succeeded(context == null ? IntPtr.Zero : context.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_drag_find_window_for_screen(IntPtr context, IntPtr drag_window, IntPtr screen, int x_root, int y_root, out IntPtr dest_window, out int protocol);
+		static d_gdk_drag_find_window_for_screen gdk_drag_find_window_for_screen = FuncLoader.LoadFunction<d_gdk_drag_find_window_for_screen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_find_window_for_screen"));
+
+		public static void FindWindowForScreen(Gdk.DragContext context, Gdk.Window drag_window, Gdk.Screen screen, int x_root, int y_root, out Gdk.Window dest_window, out Gdk.DragProtocol protocol) {
+			IntPtr native_dest_window;
+			int native_protocol;
+			gdk_drag_find_window_for_screen(context == null ? IntPtr.Zero : context.Handle, drag_window == null ? IntPtr.Zero : drag_window.Handle, screen == null ? IntPtr.Zero : screen.Handle, x_root, y_root, out native_dest_window, out native_protocol);
+			dest_window = GLib.Object.GetObject(native_dest_window) as Gdk.Window;
+			protocol = (Gdk.DragProtocol) native_protocol;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drag_get_selection(IntPtr context);
+		static d_gdk_drag_get_selection gdk_drag_get_selection = FuncLoader.LoadFunction<d_gdk_drag_get_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_get_selection"));
+
+		public static Gdk.Atom GetSelection(Gdk.DragContext context) {
+			IntPtr raw_ret = gdk_drag_get_selection(context == null ? IntPtr.Zero : context.Handle);
+			Gdk.Atom ret = raw_ret == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (raw_ret, typeof (Gdk.Atom), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_drag_motion(IntPtr context, IntPtr dest_window, int protocol, int x_root, int y_root, int suggested_action, int possible_actions, uint time_);
+		static d_gdk_drag_motion gdk_drag_motion = FuncLoader.LoadFunction<d_gdk_drag_motion>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_motion"));
+
+		public static bool Motion(Gdk.DragContext context, Gdk.Window dest_window, Gdk.DragProtocol protocol, int x_root, int y_root, Gdk.DragAction suggested_action, Gdk.DragAction possible_actions, uint time_) {
+			bool raw_ret = gdk_drag_motion(context == null ? IntPtr.Zero : context.Handle, dest_window == null ? IntPtr.Zero : dest_window.Handle, (int) protocol, x_root, y_root, (int) suggested_action, (int) possible_actions, time_);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_drag_status(IntPtr context, int action, uint time_);
+		static d_gdk_drag_status gdk_drag_status = FuncLoader.LoadFunction<d_gdk_drag_status>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_status"));
+
+		public static void Status(Gdk.DragContext context, Gdk.DragAction action, uint time_) {
+			gdk_drag_status(context == null ? IntPtr.Zero : context.Handle, (int) action, time_);
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DragAction.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (Gdk.DragActionGType))]
+	public enum DragAction {
+
+		Default = 1 << 0,
+		Copy = 1 << 1,
+		Move = 1 << 2,
+		Link = 1 << 3,
+		Private = 1 << 4,
+		Ask = 1 << 5,
+	}
+
+	internal class DragActionGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drag_action_get_type();
+		static d_gdk_drag_action_get_type gdk_drag_action_get_type = FuncLoader.LoadFunction<d_gdk_drag_action_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_action_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_drag_action_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DragCancelReason.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.DragCancelReasonGType))]
+	public enum DragCancelReason {
+
+		NoTarget,
+		UserCancelled,
+		Error,
+	}
+
+	internal class DragCancelReasonGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drag_cancel_reason_get_type();
+		static d_gdk_drag_cancel_reason_get_type gdk_drag_cancel_reason_get_type = FuncLoader.LoadFunction<d_gdk_drag_cancel_reason_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_cancel_reason_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_drag_cancel_reason_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DragProtocol.cs

@@ -0,0 +1,35 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.DragProtocolGType))]
+	public enum DragProtocol {
+
+		None,
+		Motif,
+		Xdnd,
+		Rootwin,
+		Win32Dropfiles,
+		Ole2,
+		Local,
+		Wayland,
+	}
+
+	internal class DragProtocolGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drag_protocol_get_type();
+		static d_gdk_drag_protocol_get_type gdk_drag_protocol_get_type = FuncLoader.LoadFunction<d_gdk_drag_protocol_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drag_protocol_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_drag_protocol_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DrawingContext.cs

@@ -0,0 +1,115 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class DrawingContext : GLib.Object {
+
+		public DrawingContext (IntPtr raw) : base(raw) {}
+
+		protected DrawingContext() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drawing_context_get_window(IntPtr raw);
+		static d_gdk_drawing_context_get_window gdk_drawing_context_get_window = FuncLoader.LoadFunction<d_gdk_drawing_context_get_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drawing_context_get_window"));
+
+		[GLib.Property ("window")]
+		public Gdk.Window Window {
+			get  {
+				IntPtr raw_ret = gdk_drawing_context_get_window(Handle);
+				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
+				return ret;
+			}
+		}
+
+
+		// 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 (GLib.Object.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drawing_context_get_cairo_context(IntPtr raw);
+		static d_gdk_drawing_context_get_cairo_context gdk_drawing_context_get_cairo_context = FuncLoader.LoadFunction<d_gdk_drawing_context_get_cairo_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drawing_context_get_cairo_context"));
+
+		public Cairo.Context CairoContext { 
+			get {
+				IntPtr raw_ret = gdk_drawing_context_get_cairo_context(Handle);
+				Cairo.Context ret = new Cairo.Context (raw_ret, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drawing_context_get_clip(IntPtr raw);
+		static d_gdk_drawing_context_get_clip gdk_drawing_context_get_clip = FuncLoader.LoadFunction<d_gdk_drawing_context_get_clip>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drawing_context_get_clip"));
+
+		public Cairo.Region Clip { 
+			get {
+				IntPtr raw_ret = gdk_drawing_context_get_clip(Handle);
+				Cairo.Region ret = new Cairo.Region(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_drawing_context_get_type();
+		static d_gdk_drawing_context_get_type gdk_drawing_context_get_type = FuncLoader.LoadFunction<d_gdk_drawing_context_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drawing_context_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_drawing_context_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_drawing_context_is_valid(IntPtr raw);
+		static d_gdk_drawing_context_is_valid gdk_drawing_context_is_valid = FuncLoader.LoadFunction<d_gdk_drawing_context_is_valid>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drawing_context_is_valid"));
+
+		public bool IsValid { 
+			get {
+				bool raw_ret = gdk_drawing_context_is_valid(Handle);
+				bool ret = raw_ret;
+				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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Drop.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Drop {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_drop_finish(IntPtr context, bool success, uint time_);
+		static d_gdk_drop_finish gdk_drop_finish = FuncLoader.LoadFunction<d_gdk_drop_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drop_finish"));
+
+		public static void Finish(Gdk.DragContext context, bool success, uint time_) {
+			gdk_drop_finish(context == null ? IntPtr.Zero : context.Handle, success, time_);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_drop_reply(IntPtr context, bool accepted, uint time_);
+		static d_gdk_drop_reply gdk_drop_reply = FuncLoader.LoadFunction<d_gdk_drop_reply>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_drop_reply"));
+
+		public static void Reply(Gdk.DragContext context, bool accepted, uint time_) {
+			gdk_drop_reply(context == null ? IntPtr.Zero : context.Handle, accepted, time_);
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/DropPerformedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void DropPerformedHandler(object o, DropPerformedArgs args);
+
+	public class DropPerformedArgs : GLib.SignalArgs {
+		public uint Time{
+			get {
+				return (uint) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Error.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Error {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_error_trap_pop_ignored();
+		static d_gdk_error_trap_pop_ignored gdk_error_trap_pop_ignored = FuncLoader.LoadFunction<d_gdk_error_trap_pop_ignored>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_error_trap_pop_ignored"));
+
+		public static void TrapPopIgnored() {
+			gdk_error_trap_pop_ignored();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_error_trap_push();
+		static d_gdk_error_trap_push gdk_error_trap_push = FuncLoader.LoadFunction<d_gdk_error_trap_push>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_error_trap_push"));
+
+		public static void TrapPush() {
+			gdk_error_trap_push();
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventFilter.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EventFilter : GLib.Opaque {
+
+		public EventFilter(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void EventFunc(Gdk.Event evnt);
+
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventHelper.cs

@@ -0,0 +1,374 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EventHelper {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_copy(IntPtr evnt);
+		static d_gdk_event_copy gdk_event_copy = FuncLoader.LoadFunction<d_gdk_event_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_copy"));
+
+		public static Gdk.Event Copy(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_copy(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.Event ret = Gdk.Event.GetEvent (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_free(IntPtr evnt);
+		static d_gdk_event_free gdk_event_free = FuncLoader.LoadFunction<d_gdk_event_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_free"));
+
+		public static void Free(Gdk.Event evnt) {
+			gdk_event_free(evnt == null ? IntPtr.Zero : evnt.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get();
+		static d_gdk_event_get gdk_event_get = FuncLoader.LoadFunction<d_gdk_event_get>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get"));
+
+		public static Gdk.Event Get() {
+			IntPtr raw_ret = gdk_event_get();
+			Gdk.Event ret = Gdk.Event.GetEvent (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_axis(IntPtr evnt, int axis_use, out double value);
+		static d_gdk_event_get_axis gdk_event_get_axis = FuncLoader.LoadFunction<d_gdk_event_get_axis>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_axis"));
+
+		public static bool GetAxis(Gdk.Event evnt, Gdk.AxisUse axis_use, out double value) {
+			bool raw_ret = gdk_event_get_axis(evnt == null ? IntPtr.Zero : evnt.Handle, (int) axis_use, out value);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_button(IntPtr evnt, out uint button);
+		static d_gdk_event_get_button gdk_event_get_button = FuncLoader.LoadFunction<d_gdk_event_get_button>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_button"));
+
+		public static bool GetButton(Gdk.Event evnt, out uint button) {
+			bool raw_ret = gdk_event_get_button(evnt == null ? IntPtr.Zero : evnt.Handle, out button);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_click_count(IntPtr evnt, out uint click_count);
+		static d_gdk_event_get_click_count gdk_event_get_click_count = FuncLoader.LoadFunction<d_gdk_event_get_click_count>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_click_count"));
+
+		public static bool GetClickCount(Gdk.Event evnt, out uint click_count) {
+			bool raw_ret = gdk_event_get_click_count(evnt == null ? IntPtr.Zero : evnt.Handle, out click_count);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_coords(IntPtr evnt, out double x_win, out double y_win);
+		static d_gdk_event_get_coords gdk_event_get_coords = FuncLoader.LoadFunction<d_gdk_event_get_coords>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_coords"));
+
+		public static bool GetCoords(Gdk.Event evnt, out double x_win, out double y_win) {
+			bool raw_ret = gdk_event_get_coords(evnt == null ? IntPtr.Zero : evnt.Handle, out x_win, out y_win);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_device(IntPtr evnt);
+		static d_gdk_event_get_device gdk_event_get_device = FuncLoader.LoadFunction<d_gdk_event_get_device>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_device"));
+
+		public static Gdk.Device GetDevice(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_get_device(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.Device ret = GLib.Object.GetObject(raw_ret) as Gdk.Device;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_device_tool(IntPtr evnt);
+		static d_gdk_event_get_device_tool gdk_event_get_device_tool = FuncLoader.LoadFunction<d_gdk_event_get_device_tool>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_device_tool"));
+
+		public static Gdk.DeviceTool GetDeviceTool(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_get_device_tool(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.DeviceTool ret = GLib.Object.GetObject(raw_ret) as Gdk.DeviceTool;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_event_sequence(IntPtr evnt);
+		static d_gdk_event_get_event_sequence gdk_event_get_event_sequence = FuncLoader.LoadFunction<d_gdk_event_get_event_sequence>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_event_sequence"));
+
+		public static Gdk.EventSequence GetEventSequence(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_get_event_sequence(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.EventSequence ret = raw_ret == IntPtr.Zero ? null : (Gdk.EventSequence) GLib.Opaque.GetOpaque (raw_ret, typeof (Gdk.EventSequence), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_event_get_event_type(IntPtr evnt);
+		static d_gdk_event_get_event_type gdk_event_get_event_type = FuncLoader.LoadFunction<d_gdk_event_get_event_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_event_type"));
+
+		public static Gdk.EventType GetEventType(Gdk.Event evnt) {
+			int raw_ret = gdk_event_get_event_type(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.EventType ret = (Gdk.EventType) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_keycode(IntPtr evnt, out ushort keycode);
+		static d_gdk_event_get_keycode gdk_event_get_keycode = FuncLoader.LoadFunction<d_gdk_event_get_keycode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_keycode"));
+
+		public static bool GetKeycode(Gdk.Event evnt, out ushort keycode) {
+			bool raw_ret = gdk_event_get_keycode(evnt == null ? IntPtr.Zero : evnt.Handle, out keycode);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_keyval(IntPtr evnt, out uint keyval);
+		static d_gdk_event_get_keyval gdk_event_get_keyval = FuncLoader.LoadFunction<d_gdk_event_get_keyval>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_keyval"));
+
+		public static bool GetKeyval(Gdk.Event evnt, out uint keyval) {
+			bool raw_ret = gdk_event_get_keyval(evnt == null ? IntPtr.Zero : evnt.Handle, out keyval);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_pointer_emulated(IntPtr evnt);
+		static d_gdk_event_get_pointer_emulated gdk_event_get_pointer_emulated = FuncLoader.LoadFunction<d_gdk_event_get_pointer_emulated>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_pointer_emulated"));
+
+		public static bool GetPointerEmulated(Gdk.Event evnt) {
+			bool raw_ret = gdk_event_get_pointer_emulated(evnt == null ? IntPtr.Zero : evnt.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_root_coords(IntPtr evnt, out double x_root, out double y_root);
+		static d_gdk_event_get_root_coords gdk_event_get_root_coords = FuncLoader.LoadFunction<d_gdk_event_get_root_coords>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_root_coords"));
+
+		public static bool GetRootCoords(Gdk.Event evnt, out double x_root, out double y_root) {
+			bool raw_ret = gdk_event_get_root_coords(evnt == null ? IntPtr.Zero : evnt.Handle, out x_root, out y_root);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_event_get_scancode(IntPtr evnt);
+		static d_gdk_event_get_scancode gdk_event_get_scancode = FuncLoader.LoadFunction<d_gdk_event_get_scancode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_scancode"));
+
+		public static int GetScancode(Gdk.Event evnt) {
+			int raw_ret = gdk_event_get_scancode(evnt == null ? IntPtr.Zero : evnt.Handle);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_screen(IntPtr evnt);
+		static d_gdk_event_get_screen gdk_event_get_screen = FuncLoader.LoadFunction<d_gdk_event_get_screen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_screen"));
+
+		public static Gdk.Screen GetScreen(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_get_screen(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.Screen ret = GLib.Object.GetObject(raw_ret) as Gdk.Screen;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_scroll_deltas(IntPtr evnt, out double delta_x, out double delta_y);
+		static d_gdk_event_get_scroll_deltas gdk_event_get_scroll_deltas = FuncLoader.LoadFunction<d_gdk_event_get_scroll_deltas>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_scroll_deltas"));
+
+		public static bool GetScrollDeltas(Gdk.Event evnt, out double delta_x, out double delta_y) {
+			bool raw_ret = gdk_event_get_scroll_deltas(evnt == null ? IntPtr.Zero : evnt.Handle, out delta_x, out delta_y);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_scroll_direction(IntPtr evnt, out int direction);
+		static d_gdk_event_get_scroll_direction gdk_event_get_scroll_direction = FuncLoader.LoadFunction<d_gdk_event_get_scroll_direction>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_scroll_direction"));
+
+		public static bool GetScrollDirection(Gdk.Event evnt, out Gdk.ScrollDirection direction) {
+			int native_direction;
+			bool raw_ret = gdk_event_get_scroll_direction(evnt == null ? IntPtr.Zero : evnt.Handle, out native_direction);
+			bool ret = raw_ret;
+			direction = (Gdk.ScrollDirection) native_direction;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_seat(IntPtr evnt);
+		static d_gdk_event_get_seat gdk_event_get_seat = FuncLoader.LoadFunction<d_gdk_event_get_seat>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_seat"));
+
+		public static Gdk.Seat GetSeat(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_get_seat(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.Seat ret = GLib.Object.GetObject(raw_ret) as Gdk.Seat;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_source_device(IntPtr evnt);
+		static d_gdk_event_get_source_device gdk_event_get_source_device = FuncLoader.LoadFunction<d_gdk_event_get_source_device>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_source_device"));
+
+		public static Gdk.Device GetSourceDevice(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_get_source_device(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.Device ret = GLib.Object.GetObject(raw_ret) as Gdk.Device;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_get_state(IntPtr evnt, out int state);
+		static d_gdk_event_get_state gdk_event_get_state = FuncLoader.LoadFunction<d_gdk_event_get_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_state"));
+
+		public static bool GetState(Gdk.Event evnt, out Gdk.ModifierType state) {
+			int native_state;
+			bool raw_ret = gdk_event_get_state(evnt == null ? IntPtr.Zero : evnt.Handle, out native_state);
+			bool ret = raw_ret;
+			state = (Gdk.ModifierType) native_state;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gdk_event_get_time(IntPtr evnt);
+		static d_gdk_event_get_time gdk_event_get_time = FuncLoader.LoadFunction<d_gdk_event_get_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_time"));
+
+		public static uint GetTime(Gdk.Event evnt) {
+			uint raw_ret = gdk_event_get_time(evnt == null ? IntPtr.Zero : evnt.Handle);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_type();
+		static d_gdk_event_get_type gdk_event_get_type = FuncLoader.LoadFunction<d_gdk_event_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_event_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_get_window(IntPtr evnt);
+		static d_gdk_event_get_window gdk_event_get_window = FuncLoader.LoadFunction<d_gdk_event_get_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_window"));
+
+		public static Gdk.Window GetWindow(Gdk.Event evnt) {
+			IntPtr raw_ret = gdk_event_get_window(evnt == null ? IntPtr.Zero : evnt.Handle);
+			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_handler_set(GdkSharp.EventFuncNative func, IntPtr data, GLib.DestroyNotify notify);
+		static d_gdk_event_handler_set gdk_event_handler_set = FuncLoader.LoadFunction<d_gdk_event_handler_set>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_handler_set"));
+
+		public static void HandlerSet(Gdk.EventFunc func) {
+			GdkSharp.EventFuncWrapper func_wrapper = new GdkSharp.EventFuncWrapper (func);
+			IntPtr data;
+			GLib.DestroyNotify notify;
+			if (func == null) {
+				data = IntPtr.Zero;
+				notify = null;
+			} else {
+				data = (IntPtr) GCHandle.Alloc (func_wrapper);
+				notify = GLib.DestroyHelper.NotifyHandler;
+			}
+			gdk_event_handler_set(func_wrapper.NativeDelegate, data, notify);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_is_scroll_stop_event(IntPtr evnt);
+		static d_gdk_event_is_scroll_stop_event gdk_event_is_scroll_stop_event = FuncLoader.LoadFunction<d_gdk_event_is_scroll_stop_event>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_is_scroll_stop_event"));
+
+		public static bool IsScrollStopEvent(Gdk.Event evnt) {
+			bool raw_ret = gdk_event_is_scroll_stop_event(evnt == null ? IntPtr.Zero : evnt.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_new(int type);
+		static d_gdk_event_new gdk_event_new = FuncLoader.LoadFunction<d_gdk_event_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_new"));
+
+		public static Gdk.Event New(Gdk.EventType type) {
+			IntPtr raw_ret = gdk_event_new((int) type);
+			Gdk.Event ret = Gdk.Event.GetEvent (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_peek();
+		static d_gdk_event_peek gdk_event_peek = FuncLoader.LoadFunction<d_gdk_event_peek>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_peek"));
+
+		public static Gdk.Event Peek() {
+			IntPtr raw_ret = gdk_event_peek();
+			Gdk.Event ret = Gdk.Event.GetEvent (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_put(IntPtr evnt);
+		static d_gdk_event_put gdk_event_put = FuncLoader.LoadFunction<d_gdk_event_put>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_put"));
+
+		public static void Put(Gdk.Event evnt) {
+			gdk_event_put(evnt == null ? IntPtr.Zero : evnt.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_request_motions(IntPtr evnt);
+		static d_gdk_event_request_motions gdk_event_request_motions = FuncLoader.LoadFunction<d_gdk_event_request_motions>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_request_motions"));
+
+		public static void RequestMotions(Gdk.EventMotion evnt) {
+			gdk_event_request_motions(evnt == null ? IntPtr.Zero : evnt.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_set_device(IntPtr evnt, IntPtr device);
+		static d_gdk_event_set_device gdk_event_set_device = FuncLoader.LoadFunction<d_gdk_event_set_device>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_set_device"));
+
+		public static void SetDevice(Gdk.Event evnt, Gdk.Device device) {
+			gdk_event_set_device(evnt == null ? IntPtr.Zero : evnt.Handle, device == null ? IntPtr.Zero : device.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_set_device_tool(IntPtr evnt, IntPtr tool);
+		static d_gdk_event_set_device_tool gdk_event_set_device_tool = FuncLoader.LoadFunction<d_gdk_event_set_device_tool>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_set_device_tool"));
+
+		public static void SetDeviceTool(Gdk.Event evnt, Gdk.DeviceTool tool) {
+			gdk_event_set_device_tool(evnt == null ? IntPtr.Zero : evnt.Handle, tool == null ? IntPtr.Zero : tool.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_set_screen(IntPtr evnt, IntPtr screen);
+		static d_gdk_event_set_screen gdk_event_set_screen = FuncLoader.LoadFunction<d_gdk_event_set_screen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_set_screen"));
+
+		public static void SetScreen(Gdk.Event evnt, Gdk.Screen screen) {
+			gdk_event_set_screen(evnt == null ? IntPtr.Zero : evnt.Handle, screen == null ? IntPtr.Zero : screen.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_event_set_source_device(IntPtr evnt, IntPtr device);
+		static d_gdk_event_set_source_device gdk_event_set_source_device = FuncLoader.LoadFunction<d_gdk_event_set_source_device>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_set_source_device"));
+
+		public static void SetSourceDevice(Gdk.Event evnt, Gdk.Device device) {
+			gdk_event_set_source_device(evnt == null ? IntPtr.Zero : evnt.Handle, device == null ? IntPtr.Zero : device.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_event_triggers_context_menu(IntPtr evnt);
+		static d_gdk_event_triggers_context_menu gdk_event_triggers_context_menu = FuncLoader.LoadFunction<d_gdk_event_triggers_context_menu>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_triggers_context_menu"));
+
+		public static bool TriggersContextMenu(Gdk.Event evnt) {
+			bool raw_ret = gdk_event_triggers_context_menu(evnt == null ? IntPtr.Zero : evnt.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventMask.cs

@@ -0,0 +1,54 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (Gdk.EventMaskGType))]
+	public enum EventMask {
+
+		ExposureMask = 1 << 1,
+		PointerMotionMask = 1 << 2,
+		PointerMotionHintMask = 1 << 3,
+		ButtonMotionMask = 1 << 4,
+		Button1MotionMask = 1 << 5,
+		Button2MotionMask = 1 << 6,
+		Button3MotionMask = 1 << 7,
+		ButtonPressMask = 1 << 8,
+		ButtonReleaseMask = 1 << 9,
+		KeyPressMask = 1 << 10,
+		KeyReleaseMask = 1 << 11,
+		EnterNotifyMask = 1 << 12,
+		LeaveNotifyMask = 1 << 13,
+		FocusChangeMask = 1 << 14,
+		StructureMask = 1 << 15,
+		PropertyChangeMask = 1 << 16,
+		VisibilityNotifyMask = 1 << 17,
+		ProximityInMask = 1 << 18,
+		ProximityOutMask = 1 << 19,
+		SubstructureMask = 1 << 20,
+		ScrollMask = 1 << 21,
+		TouchMask = 1 << 22,
+		SmoothScrollMask = 1 << 23,
+		TouchpadGestureMask = 1 << 24,
+		TabletPadMask = 1 << 25,
+		AllEventsMask = 0xFFFFFE,
+	}
+
+	internal class EventMaskGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_mask_get_type();
+		static d_gdk_event_mask_get_type gdk_event_mask_get_type = FuncLoader.LoadFunction<d_gdk_event_mask_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_mask_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_event_mask_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventPadAxis.cs

@@ -0,0 +1,60 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct EventPadAxis : IEquatable<EventPadAxis> {
+
+		public Gdk.EventType Type;
+		private IntPtr _window;
+		public Gdk.Window Window {
+			get {
+				return GLib.Object.GetObject(_window) as Gdk.Window;
+			}
+			set {
+				_window = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public sbyte SendEvent;
+		public uint Time;
+		public uint Group;
+		public uint Index;
+		public uint Mode;
+		public double Value;
+
+		public static Gdk.EventPadAxis Zero = new Gdk.EventPadAxis ();
+
+		public static Gdk.EventPadAxis New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.EventPadAxis.Zero;
+			return (Gdk.EventPadAxis) Marshal.PtrToStructure (raw, typeof (Gdk.EventPadAxis));
+		}
+
+		public bool Equals (EventPadAxis other)
+		{
+			return true && Type.Equals (other.Type) && Window.Equals (other.Window) && SendEvent.Equals (other.SendEvent) && Time.Equals (other.Time) && Group.Equals (other.Group) && Index.Equals (other.Index) && Mode.Equals (other.Mode) && Value.Equals (other.Value);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is EventPadAxis && Equals ((EventPadAxis) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Type.GetHashCode () ^ Window.GetHashCode () ^ SendEvent.GetHashCode () ^ Time.GetHashCode () ^ Group.GetHashCode () ^ Index.GetHashCode () ^ Mode.GetHashCode () ^ Value.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventPadButton.cs

@@ -0,0 +1,59 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct EventPadButton : IEquatable<EventPadButton> {
+
+		public Gdk.EventType Type;
+		private IntPtr _window;
+		public Gdk.Window Window {
+			get {
+				return GLib.Object.GetObject(_window) as Gdk.Window;
+			}
+			set {
+				_window = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public sbyte SendEvent;
+		public uint Time;
+		public uint Group;
+		public uint Button;
+		public uint Mode;
+
+		public static Gdk.EventPadButton Zero = new Gdk.EventPadButton ();
+
+		public static Gdk.EventPadButton New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.EventPadButton.Zero;
+			return (Gdk.EventPadButton) Marshal.PtrToStructure (raw, typeof (Gdk.EventPadButton));
+		}
+
+		public bool Equals (EventPadButton other)
+		{
+			return true && Type.Equals (other.Type) && Window.Equals (other.Window) && SendEvent.Equals (other.SendEvent) && Time.Equals (other.Time) && Group.Equals (other.Group) && Button.Equals (other.Button) && Mode.Equals (other.Mode);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is EventPadButton && Equals ((EventPadButton) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Type.GetHashCode () ^ Window.GetHashCode () ^ SendEvent.GetHashCode () ^ Time.GetHashCode () ^ Group.GetHashCode () ^ Button.GetHashCode () ^ Mode.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventPadGroupMode.cs

@@ -0,0 +1,58 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct EventPadGroupMode : IEquatable<EventPadGroupMode> {
+
+		public Gdk.EventType Type;
+		private IntPtr _window;
+		public Gdk.Window Window {
+			get {
+				return GLib.Object.GetObject(_window) as Gdk.Window;
+			}
+			set {
+				_window = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public sbyte SendEvent;
+		public uint Time;
+		public uint Group;
+		public uint Mode;
+
+		public static Gdk.EventPadGroupMode Zero = new Gdk.EventPadGroupMode ();
+
+		public static Gdk.EventPadGroupMode New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.EventPadGroupMode.Zero;
+			return (Gdk.EventPadGroupMode) Marshal.PtrToStructure (raw, typeof (Gdk.EventPadGroupMode));
+		}
+
+		public bool Equals (EventPadGroupMode other)
+		{
+			return true && Type.Equals (other.Type) && Window.Equals (other.Window) && SendEvent.Equals (other.SendEvent) && Time.Equals (other.Time) && Group.Equals (other.Group) && Mode.Equals (other.Mode);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is EventPadGroupMode && Equals ((EventPadGroupMode) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Type.GetHashCode () ^ Window.GetHashCode () ^ SendEvent.GetHashCode () ^ Time.GetHashCode () ^ Group.GetHashCode () ^ Mode.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventSequence.cs

@@ -0,0 +1,46 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EventSequence : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_sequence_get_type();
+		static d_gdk_event_sequence_get_type gdk_event_sequence_get_type = FuncLoader.LoadFunction<d_gdk_event_sequence_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_sequence_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_event_sequence_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		public EventSequence(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventTouch.cs

@@ -0,0 +1,81 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct EventTouch : IEquatable<EventTouch> {
+
+		public Gdk.EventType Type;
+		private IntPtr _window;
+		public Gdk.Window Window {
+			get {
+				return GLib.Object.GetObject(_window) as Gdk.Window;
+			}
+			set {
+				_window = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public sbyte SendEvent;
+		public uint Time;
+		public double X;
+		public double Y;
+		private IntPtr _axes;
+		public uint State;
+		private IntPtr _sequence;
+		public Gdk.EventSequence Sequence {
+			get {
+				return _sequence == IntPtr.Zero ? null : (Gdk.EventSequence) GLib.Opaque.GetOpaque (_sequence, typeof (Gdk.EventSequence), false);
+			}
+			set {
+				_sequence = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public bool EmulatingPointer;
+		private IntPtr _device;
+		public Gdk.Device Device {
+			get {
+				return GLib.Object.GetObject(_device) as Gdk.Device;
+			}
+			set {
+				_device = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public double XRoot;
+		public double YRoot;
+
+		public static Gdk.EventTouch Zero = new Gdk.EventTouch ();
+
+		public static Gdk.EventTouch New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.EventTouch.Zero;
+			return (Gdk.EventTouch) Marshal.PtrToStructure (raw, typeof (Gdk.EventTouch));
+		}
+
+		public bool Equals (EventTouch other)
+		{
+			return true && Type.Equals (other.Type) && Window.Equals (other.Window) && SendEvent.Equals (other.SendEvent) && Time.Equals (other.Time) && X.Equals (other.X) && Y.Equals (other.Y) && _axes.Equals (other._axes) && State.Equals (other.State) && Sequence.Equals (other.Sequence) && EmulatingPointer.Equals (other.EmulatingPointer) && Device.Equals (other.Device) && XRoot.Equals (other.XRoot) && YRoot.Equals (other.YRoot);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is EventTouch && Equals ((EventTouch) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Type.GetHashCode () ^ Window.GetHashCode () ^ SendEvent.GetHashCode () ^ Time.GetHashCode () ^ X.GetHashCode () ^ Y.GetHashCode () ^ _axes.GetHashCode () ^ State.GetHashCode () ^ Sequence.GetHashCode () ^ EmulatingPointer.GetHashCode () ^ Device.GetHashCode () ^ XRoot.GetHashCode () ^ YRoot.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventTouchpadPinch.cs

@@ -0,0 +1,67 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct EventTouchpadPinch : IEquatable<EventTouchpadPinch> {
+
+		public Gdk.EventType Type;
+		private IntPtr _window;
+		public Gdk.Window Window {
+			get {
+				return GLib.Object.GetObject(_window) as Gdk.Window;
+			}
+			set {
+				_window = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public sbyte SendEvent;
+		public sbyte Phase;
+		public sbyte NFingers;
+		public uint Time;
+		public double X;
+		public double Y;
+		public double Dx;
+		public double Dy;
+		public double AngleDelta;
+		public double Scale;
+		public double XRoot;
+		public double YRoot;
+		public uint State;
+
+		public static Gdk.EventTouchpadPinch Zero = new Gdk.EventTouchpadPinch ();
+
+		public static Gdk.EventTouchpadPinch New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.EventTouchpadPinch.Zero;
+			return (Gdk.EventTouchpadPinch) Marshal.PtrToStructure (raw, typeof (Gdk.EventTouchpadPinch));
+		}
+
+		public bool Equals (EventTouchpadPinch other)
+		{
+			return true && Type.Equals (other.Type) && Window.Equals (other.Window) && SendEvent.Equals (other.SendEvent) && Phase.Equals (other.Phase) && NFingers.Equals (other.NFingers) && Time.Equals (other.Time) && X.Equals (other.X) && Y.Equals (other.Y) && Dx.Equals (other.Dx) && Dy.Equals (other.Dy) && AngleDelta.Equals (other.AngleDelta) && Scale.Equals (other.Scale) && XRoot.Equals (other.XRoot) && YRoot.Equals (other.YRoot) && State.Equals (other.State);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is EventTouchpadPinch && Equals ((EventTouchpadPinch) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Type.GetHashCode () ^ Window.GetHashCode () ^ SendEvent.GetHashCode () ^ Phase.GetHashCode () ^ NFingers.GetHashCode () ^ Time.GetHashCode () ^ X.GetHashCode () ^ Y.GetHashCode () ^ Dx.GetHashCode () ^ Dy.GetHashCode () ^ AngleDelta.GetHashCode () ^ Scale.GetHashCode () ^ XRoot.GetHashCode () ^ YRoot.GetHashCode () ^ State.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventTouchpadSwipe.cs

@@ -0,0 +1,65 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct EventTouchpadSwipe : IEquatable<EventTouchpadSwipe> {
+
+		public Gdk.EventType Type;
+		private IntPtr _window;
+		public Gdk.Window Window {
+			get {
+				return GLib.Object.GetObject(_window) as Gdk.Window;
+			}
+			set {
+				_window = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public sbyte SendEvent;
+		public sbyte Phase;
+		public sbyte NFingers;
+		public uint Time;
+		public double X;
+		public double Y;
+		public double Dx;
+		public double Dy;
+		public double XRoot;
+		public double YRoot;
+		public uint State;
+
+		public static Gdk.EventTouchpadSwipe Zero = new Gdk.EventTouchpadSwipe ();
+
+		public static Gdk.EventTouchpadSwipe New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.EventTouchpadSwipe.Zero;
+			return (Gdk.EventTouchpadSwipe) Marshal.PtrToStructure (raw, typeof (Gdk.EventTouchpadSwipe));
+		}
+
+		public bool Equals (EventTouchpadSwipe other)
+		{
+			return true && Type.Equals (other.Type) && Window.Equals (other.Window) && SendEvent.Equals (other.SendEvent) && Phase.Equals (other.Phase) && NFingers.Equals (other.NFingers) && Time.Equals (other.Time) && X.Equals (other.X) && Y.Equals (other.Y) && Dx.Equals (other.Dx) && Dy.Equals (other.Dy) && XRoot.Equals (other.XRoot) && YRoot.Equals (other.YRoot) && State.Equals (other.State);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is EventTouchpadSwipe && Equals ((EventTouchpadSwipe) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Type.GetHashCode () ^ Window.GetHashCode () ^ SendEvent.GetHashCode () ^ Phase.GetHashCode () ^ NFingers.GetHashCode () ^ Time.GetHashCode () ^ X.GetHashCode () ^ Y.GetHashCode () ^ Dx.GetHashCode () ^ Dy.GetHashCode () ^ XRoot.GetHashCode () ^ YRoot.GetHashCode () ^ State.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/EventType.cs

@@ -0,0 +1,78 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.EventTypeGType))]
+	public enum EventType {
+
+		Nothing = -1,
+		Delete,
+		Destroy = 1,
+		Expose = 2,
+		MotionNotify = 3,
+		ButtonPress = 4,
+		TwoButtonPress = 5,
+		DoubleButtonPress = TwoButtonPress,
+		ThreeButtonPress = 6,
+		TripleButtonPress = ThreeButtonPress,
+		ButtonRelease = 7,
+		KeyPress = 8,
+		KeyRelease = 9,
+		EnterNotify = 10,
+		LeaveNotify = 11,
+		FocusChange = 12,
+		Configure = 13,
+		Map = 14,
+		Unmap = 15,
+		PropertyNotify = 16,
+		SelectionClear = 17,
+		SelectionRequest = 18,
+		SelectionNotify = 19,
+		ProximityIn = 20,
+		ProximityOut = 21,
+		DragEnter = 22,
+		DragLeave = 23,
+		DragMotion = 24,
+		DragStatus = 25,
+		DropStart = 26,
+		DropFinished = 27,
+		ClientEvent = 28,
+		VisibilityNotify = 29,
+		Scroll = 31,
+		WindowState = 32,
+		Setting = 33,
+		OwnerChange = 34,
+		GrabBroken = 35,
+		Damage = 36,
+		TouchBegin = 37,
+		TouchUpdate = 38,
+		TouchEnd = 39,
+		TouchCancel = 40,
+		TouchpadSwipe = 41,
+		TouchpadPinch = 42,
+		PadButtonPress = 43,
+		PadButtonRelease = 44,
+		PadRing = 45,
+		PadStrip = 46,
+		PadGroupMode = 47,
+		EventLast,
+	}
+
+	internal class EventTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_event_type_get_type();
+		static d_gdk_event_type_get_type gdk_event_type_get_type = FuncLoader.LoadFunction<d_gdk_event_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_event_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Events.cs

@@ -0,0 +1,54 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Events {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_events_get_angle(IntPtr event1, IntPtr event2, out double angle);
+		static d_gdk_events_get_angle gdk_events_get_angle = FuncLoader.LoadFunction<d_gdk_events_get_angle>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_events_get_angle"));
+
+		public static bool GetAngle(Gdk.Event event1, Gdk.Event event2, out double angle) {
+			bool raw_ret = gdk_events_get_angle(event1 == null ? IntPtr.Zero : event1.Handle, event2 == null ? IntPtr.Zero : event2.Handle, out angle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_events_get_center(IntPtr event1, IntPtr event2, out double x, out double y);
+		static d_gdk_events_get_center gdk_events_get_center = FuncLoader.LoadFunction<d_gdk_events_get_center>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_events_get_center"));
+
+		public static bool GetCenter(Gdk.Event event1, Gdk.Event event2, out double x, out double y) {
+			bool raw_ret = gdk_events_get_center(event1 == null ? IntPtr.Zero : event1.Handle, event2 == null ? IntPtr.Zero : event2.Handle, out x, out y);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_events_get_distance(IntPtr event1, IntPtr event2, out double distance);
+		static d_gdk_events_get_distance gdk_events_get_distance = FuncLoader.LoadFunction<d_gdk_events_get_distance>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_events_get_distance"));
+
+		public static bool GetDistance(Gdk.Event event1, Gdk.Event event2, out double distance) {
+			bool raw_ret = gdk_events_get_distance(event1 == null ? IntPtr.Zero : event1.Handle, event2 == null ? IntPtr.Zero : event2.Handle, out distance);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_events_pending();
+		static d_gdk_events_pending gdk_events_pending = FuncLoader.LoadFunction<d_gdk_events_pending>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_events_pending"));
+
+		public static bool Pending() {
+			bool raw_ret = gdk_events_pending();
+			bool ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FilterFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate Gdk.FilterReturn FilterFunc(System.IntPtr xevent, Gdk.Event evnt);
+
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FilterReturn.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.FilterReturnGType))]
+	public enum FilterReturn {
+
+		Continue,
+		Translate,
+		Remove,
+	}
+
+	internal class FilterReturnGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_filter_return_get_type();
+		static d_gdk_filter_return_get_type gdk_filter_return_get_type = FuncLoader.LoadFunction<d_gdk_filter_return_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_filter_return_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_filter_return_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FrameClock.cs

@@ -0,0 +1,917 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class FrameClock : GLib.Object {
+
+		public FrameClock (IntPtr raw) : base(raw) {}
+
+		protected FrameClock() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[GLib.Signal("layout")]
+		public event System.EventHandler Layout {
+			add {
+				this.AddSignalHandler ("layout", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("layout", value);
+			}
+		}
+
+		[GLib.Signal("resume-events")]
+		public event System.EventHandler ResumeEvents {
+			add {
+				this.AddSignalHandler ("resume-events", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("resume-events", value);
+			}
+		}
+
+		[GLib.Signal("after-paint")]
+		public event System.EventHandler AfterPaint {
+			add {
+				this.AddSignalHandler ("after-paint", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("after-paint", value);
+			}
+		}
+
+		[GLib.Signal("update")]
+		public event System.EventHandler Update {
+			add {
+				this.AddSignalHandler ("update", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("update", value);
+			}
+		}
+
+		[GLib.Signal("paint")]
+		public event System.EventHandler Paint {
+			add {
+				this.AddSignalHandler ("paint", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("paint", value);
+			}
+		}
+
+		[GLib.Signal("flush-events")]
+		public event System.EventHandler FlushEvents {
+			add {
+				this.AddSignalHandler ("flush-events", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("flush-events", value);
+			}
+		}
+
+		[GLib.Signal("before-paint")]
+		public event System.EventHandler BeforePaint {
+			add {
+				this.AddSignalHandler ("before-paint", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("before-paint", value);
+			}
+		}
+
+		static FlushEventsNativeDelegate FlushEvents_cb_delegate;
+		static FlushEventsNativeDelegate FlushEventsVMCallback {
+			get {
+				if (FlushEvents_cb_delegate == null)
+					FlushEvents_cb_delegate = new FlushEventsNativeDelegate (FlushEvents_cb);
+				return FlushEvents_cb_delegate;
+			}
+		}
+
+		static void OverrideFlushEvents (GLib.GType gtype)
+		{
+			OverrideFlushEvents (gtype, FlushEventsVMCallback);
+		}
+
+		static void OverrideFlushEvents (GLib.GType gtype, FlushEventsNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "flush-events", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void FlushEventsNativeDelegate (IntPtr inst);
+
+		static void FlushEvents_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnFlushEvents ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideFlushEvents")]
+		protected virtual void OnFlushEvents ()
+		{
+			InternalFlushEvents ();
+		}
+
+		private void InternalFlushEvents ()
+		{
+			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 BeforePaintNativeDelegate BeforePaint_cb_delegate;
+		static BeforePaintNativeDelegate BeforePaintVMCallback {
+			get {
+				if (BeforePaint_cb_delegate == null)
+					BeforePaint_cb_delegate = new BeforePaintNativeDelegate (BeforePaint_cb);
+				return BeforePaint_cb_delegate;
+			}
+		}
+
+		static void OverrideBeforePaint (GLib.GType gtype)
+		{
+			OverrideBeforePaint (gtype, BeforePaintVMCallback);
+		}
+
+		static void OverrideBeforePaint (GLib.GType gtype, BeforePaintNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "before-paint", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void BeforePaintNativeDelegate (IntPtr inst);
+
+		static void BeforePaint_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnBeforePaint ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideBeforePaint")]
+		protected virtual void OnBeforePaint ()
+		{
+			InternalBeforePaint ();
+		}
+
+		private void InternalBeforePaint ()
+		{
+			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 UpdateNativeDelegate Update_cb_delegate;
+		static UpdateNativeDelegate UpdateVMCallback {
+			get {
+				if (Update_cb_delegate == null)
+					Update_cb_delegate = new UpdateNativeDelegate (Update_cb);
+				return Update_cb_delegate;
+			}
+		}
+
+		static void OverrideUpdate (GLib.GType gtype)
+		{
+			OverrideUpdate (gtype, UpdateVMCallback);
+		}
+
+		static void OverrideUpdate (GLib.GType gtype, UpdateNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "update", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void UpdateNativeDelegate (IntPtr inst);
+
+		static void Update_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnUpdate ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideUpdate")]
+		protected virtual void OnUpdate ()
+		{
+			InternalUpdate ();
+		}
+
+		private void InternalUpdate ()
+		{
+			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 LayoutNativeDelegate Layout_cb_delegate;
+		static LayoutNativeDelegate LayoutVMCallback {
+			get {
+				if (Layout_cb_delegate == null)
+					Layout_cb_delegate = new LayoutNativeDelegate (Layout_cb);
+				return Layout_cb_delegate;
+			}
+		}
+
+		static void OverrideLayout (GLib.GType gtype)
+		{
+			OverrideLayout (gtype, LayoutVMCallback);
+		}
+
+		static void OverrideLayout (GLib.GType gtype, LayoutNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "layout", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void LayoutNativeDelegate (IntPtr inst);
+
+		static void Layout_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnLayout ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideLayout")]
+		protected virtual void OnLayout ()
+		{
+			InternalLayout ();
+		}
+
+		private void InternalLayout ()
+		{
+			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 PaintNativeDelegate Paint_cb_delegate;
+		static PaintNativeDelegate PaintVMCallback {
+			get {
+				if (Paint_cb_delegate == null)
+					Paint_cb_delegate = new PaintNativeDelegate (Paint_cb);
+				return Paint_cb_delegate;
+			}
+		}
+
+		static void OverridePaint (GLib.GType gtype)
+		{
+			OverridePaint (gtype, PaintVMCallback);
+		}
+
+		static void OverridePaint (GLib.GType gtype, PaintNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "paint", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void PaintNativeDelegate (IntPtr inst);
+
+		static void Paint_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnPaint ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverridePaint")]
+		protected virtual void OnPaint ()
+		{
+			InternalPaint ();
+		}
+
+		private void InternalPaint ()
+		{
+			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 AfterPaintNativeDelegate AfterPaint_cb_delegate;
+		static AfterPaintNativeDelegate AfterPaintVMCallback {
+			get {
+				if (AfterPaint_cb_delegate == null)
+					AfterPaint_cb_delegate = new AfterPaintNativeDelegate (AfterPaint_cb);
+				return AfterPaint_cb_delegate;
+			}
+		}
+
+		static void OverrideAfterPaint (GLib.GType gtype)
+		{
+			OverrideAfterPaint (gtype, AfterPaintVMCallback);
+		}
+
+		static void OverrideAfterPaint (GLib.GType gtype, AfterPaintNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "after-paint", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void AfterPaintNativeDelegate (IntPtr inst);
+
+		static void AfterPaint_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnAfterPaint ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideAfterPaint")]
+		protected virtual void OnAfterPaint ()
+		{
+			InternalAfterPaint ();
+		}
+
+		private void InternalAfterPaint ()
+		{
+			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 ResumeEventsNativeDelegate ResumeEvents_cb_delegate;
+		static ResumeEventsNativeDelegate ResumeEventsVMCallback {
+			get {
+				if (ResumeEvents_cb_delegate == null)
+					ResumeEvents_cb_delegate = new ResumeEventsNativeDelegate (ResumeEvents_cb);
+				return ResumeEvents_cb_delegate;
+			}
+		}
+
+		static void OverrideResumeEvents (GLib.GType gtype)
+		{
+			OverrideResumeEvents (gtype, ResumeEventsVMCallback);
+		}
+
+		static void OverrideResumeEvents (GLib.GType gtype, ResumeEventsNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "resume-events", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ResumeEventsNativeDelegate (IntPtr inst);
+
+		static void ResumeEvents_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnResumeEvents ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideResumeEvents")]
+		protected virtual void OnResumeEvents ()
+		{
+			InternalResumeEvents ();
+		}
+
+		private void InternalResumeEvents ()
+		{
+			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 GetFrameTimeNativeDelegate GetFrameTime_cb_delegate;
+		static GetFrameTimeNativeDelegate GetFrameTimeVMCallback {
+			get {
+				if (GetFrameTime_cb_delegate == null)
+					GetFrameTime_cb_delegate = new GetFrameTimeNativeDelegate (GetFrameTime_cb);
+				return GetFrameTime_cb_delegate;
+			}
+		}
+
+		static void OverrideGetFrameTime (GLib.GType gtype)
+		{
+			OverrideGetFrameTime (gtype, GetFrameTimeVMCallback);
+		}
+
+		static void OverrideGetFrameTime (GLib.GType gtype, GetFrameTimeNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_frame_time"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long GetFrameTimeNativeDelegate (IntPtr inst);
+
+		static long GetFrameTime_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				long __result;
+				__result = __obj.OnGetFrameTime ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideGetFrameTime")]
+		protected virtual long OnGetFrameTime ()
+		{
+			return InternalGetFrameTime ();
+		}
+
+		private long InternalGetFrameTime ()
+		{
+			GetFrameTimeNativeDelegate unmanaged = class_abi.BaseOverride<GetFrameTimeNativeDelegate>(this.LookupGType(), "get_frame_time");
+			if (unmanaged == null) return 0;
+
+			long __result = unmanaged (this.Handle);
+			return __result;
+		}
+
+		static RequestPhaseNativeDelegate RequestPhase_cb_delegate;
+		static RequestPhaseNativeDelegate RequestPhaseVMCallback {
+			get {
+				if (RequestPhase_cb_delegate == null)
+					RequestPhase_cb_delegate = new RequestPhaseNativeDelegate (RequestPhase_cb);
+				return RequestPhase_cb_delegate;
+			}
+		}
+
+		static void OverrideRequestPhase (GLib.GType gtype)
+		{
+			OverrideRequestPhase (gtype, RequestPhaseVMCallback);
+		}
+
+		static void OverrideRequestPhase (GLib.GType gtype, RequestPhaseNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("request_phase"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void RequestPhaseNativeDelegate (IntPtr inst, int phase);
+
+		static void RequestPhase_cb (IntPtr inst, int phase)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnRequestPhase ((Gdk.FrameClockPhase) phase);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideRequestPhase")]
+		protected virtual void OnRequestPhase (Gdk.FrameClockPhase phase)
+		{
+			InternalRequestPhase (phase);
+		}
+
+		private void InternalRequestPhase (Gdk.FrameClockPhase phase)
+		{
+			RequestPhaseNativeDelegate unmanaged = class_abi.BaseOverride<RequestPhaseNativeDelegate>(this.LookupGType(), "request_phase");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, (int) phase);
+		}
+
+		static BeginUpdatingNativeDelegate BeginUpdating_cb_delegate;
+		static BeginUpdatingNativeDelegate BeginUpdatingVMCallback {
+			get {
+				if (BeginUpdating_cb_delegate == null)
+					BeginUpdating_cb_delegate = new BeginUpdatingNativeDelegate (BeginUpdating_cb);
+				return BeginUpdating_cb_delegate;
+			}
+		}
+
+		static void OverrideBeginUpdating (GLib.GType gtype)
+		{
+			OverrideBeginUpdating (gtype, BeginUpdatingVMCallback);
+		}
+
+		static void OverrideBeginUpdating (GLib.GType gtype, BeginUpdatingNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("begin_updating"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void BeginUpdatingNativeDelegate (IntPtr inst);
+
+		static void BeginUpdating_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnBeginUpdating ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideBeginUpdating")]
+		protected virtual void OnBeginUpdating ()
+		{
+			InternalBeginUpdating ();
+		}
+
+		private void InternalBeginUpdating ()
+		{
+			BeginUpdatingNativeDelegate unmanaged = class_abi.BaseOverride<BeginUpdatingNativeDelegate>(this.LookupGType(), "begin_updating");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static EndUpdatingNativeDelegate EndUpdating_cb_delegate;
+		static EndUpdatingNativeDelegate EndUpdatingVMCallback {
+			get {
+				if (EndUpdating_cb_delegate == null)
+					EndUpdating_cb_delegate = new EndUpdatingNativeDelegate (EndUpdating_cb);
+				return EndUpdating_cb_delegate;
+			}
+		}
+
+		static void OverrideEndUpdating (GLib.GType gtype)
+		{
+			OverrideEndUpdating (gtype, EndUpdatingVMCallback);
+		}
+
+		static void OverrideEndUpdating (GLib.GType gtype, EndUpdatingNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("end_updating"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void EndUpdatingNativeDelegate (IntPtr inst);
+
+		static void EndUpdating_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnEndUpdating ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideEndUpdating")]
+		protected virtual void OnEndUpdating ()
+		{
+			InternalEndUpdating ();
+		}
+
+		private void InternalEndUpdating ()
+		{
+			EndUpdatingNativeDelegate unmanaged = class_abi.BaseOverride<EndUpdatingNativeDelegate>(this.LookupGType(), "end_updating");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static FreezeNativeDelegate Freeze_cb_delegate;
+		static FreezeNativeDelegate FreezeVMCallback {
+			get {
+				if (Freeze_cb_delegate == null)
+					Freeze_cb_delegate = new FreezeNativeDelegate (Freeze_cb);
+				return Freeze_cb_delegate;
+			}
+		}
+
+		static void OverrideFreeze (GLib.GType gtype)
+		{
+			OverrideFreeze (gtype, FreezeVMCallback);
+		}
+
+		static void OverrideFreeze (GLib.GType gtype, FreezeNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("freeze"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void FreezeNativeDelegate (IntPtr inst);
+
+		static void Freeze_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnFreeze ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideFreeze")]
+		protected virtual void OnFreeze ()
+		{
+			InternalFreeze ();
+		}
+
+		private void InternalFreeze ()
+		{
+			FreezeNativeDelegate unmanaged = class_abi.BaseOverride<FreezeNativeDelegate>(this.LookupGType(), "freeze");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static ThawNativeDelegate Thaw_cb_delegate;
+		static ThawNativeDelegate ThawVMCallback {
+			get {
+				if (Thaw_cb_delegate == null)
+					Thaw_cb_delegate = new ThawNativeDelegate (Thaw_cb);
+				return Thaw_cb_delegate;
+			}
+		}
+
+		static void OverrideThaw (GLib.GType gtype)
+		{
+			OverrideThaw (gtype, ThawVMCallback);
+		}
+
+		static void OverrideThaw (GLib.GType gtype, ThawNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("thaw"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ThawNativeDelegate (IntPtr inst);
+
+		static void Thaw_cb (IntPtr inst)
+		{
+			try {
+				FrameClock __obj = GLib.Object.GetObject (inst, false) as FrameClock;
+				__obj.OnThaw ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.FrameClock), ConnectionMethod="OverrideThaw")]
+		protected virtual void OnThaw ()
+		{
+			InternalThaw ();
+		}
+
+		private void InternalThaw ()
+		{
+			ThawNativeDelegate unmanaged = class_abi.BaseOverride<ThawNativeDelegate>(this.LookupGType(), "thaw");
+			if (unmanaged == null) return;
+
+			unmanaged (this.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("get_frame_time"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // get_frame_time
+							, null
+							, "request_phase"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("request_phase"
+							, -1
+							, (uint) sizeof( IntPtr ) // request_phase
+							, "get_frame_time"
+							, "begin_updating"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("begin_updating"
+							, -1
+							, (uint) sizeof( IntPtr ) // begin_updating
+							, "request_phase"
+							, "end_updating"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("end_updating"
+							, -1
+							, (uint) sizeof( IntPtr ) // end_updating
+							, "begin_updating"
+							, "freeze"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("freeze"
+							, -1
+							, (uint) sizeof( IntPtr ) // freeze
+							, "end_updating"
+							, "thaw"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("thaw"
+							, -1
+							, (uint) sizeof( IntPtr ) // thaw
+							, "freeze"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_frame_clock_begin_updating(IntPtr raw);
+		static d_gdk_frame_clock_begin_updating gdk_frame_clock_begin_updating = FuncLoader.LoadFunction<d_gdk_frame_clock_begin_updating>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_begin_updating"));
+
+		public void BeginUpdating() {
+			gdk_frame_clock_begin_updating(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_frame_clock_end_updating(IntPtr raw);
+		static d_gdk_frame_clock_end_updating gdk_frame_clock_end_updating = FuncLoader.LoadFunction<d_gdk_frame_clock_end_updating>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_end_updating"));
+
+		public void EndUpdating() {
+			gdk_frame_clock_end_updating(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_frame_clock_get_current_timings(IntPtr raw);
+		static d_gdk_frame_clock_get_current_timings gdk_frame_clock_get_current_timings = FuncLoader.LoadFunction<d_gdk_frame_clock_get_current_timings>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_get_current_timings"));
+
+		public Gdk.FrameTimings CurrentTimings { 
+			get {
+				IntPtr raw_ret = gdk_frame_clock_get_current_timings(Handle);
+				Gdk.FrameTimings ret = raw_ret == IntPtr.Zero ? null : (Gdk.FrameTimings) GLib.Opaque.GetOpaque (raw_ret, typeof (Gdk.FrameTimings), false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_clock_get_frame_counter(IntPtr raw);
+		static d_gdk_frame_clock_get_frame_counter gdk_frame_clock_get_frame_counter = FuncLoader.LoadFunction<d_gdk_frame_clock_get_frame_counter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_get_frame_counter"));
+
+		public long FrameCounter { 
+			get {
+				long raw_ret = gdk_frame_clock_get_frame_counter(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_clock_get_frame_time(IntPtr raw);
+		static d_gdk_frame_clock_get_frame_time gdk_frame_clock_get_frame_time = FuncLoader.LoadFunction<d_gdk_frame_clock_get_frame_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_get_frame_time"));
+
+		public long FrameTime { 
+			get {
+				long raw_ret = gdk_frame_clock_get_frame_time(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_clock_get_history_start(IntPtr raw);
+		static d_gdk_frame_clock_get_history_start gdk_frame_clock_get_history_start = FuncLoader.LoadFunction<d_gdk_frame_clock_get_history_start>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_get_history_start"));
+
+		public long HistoryStart { 
+			get {
+				long raw_ret = gdk_frame_clock_get_history_start(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_frame_clock_get_refresh_info(IntPtr raw, long base_time, out long refresh_interval_return, out long presentation_time_return);
+		static d_gdk_frame_clock_get_refresh_info gdk_frame_clock_get_refresh_info = FuncLoader.LoadFunction<d_gdk_frame_clock_get_refresh_info>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_get_refresh_info"));
+
+		public void GetRefreshInfo(long base_time, out long refresh_interval_return, out long presentation_time_return) {
+			gdk_frame_clock_get_refresh_info(Handle, base_time, out refresh_interval_return, out presentation_time_return);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_frame_clock_get_timings(IntPtr raw, long frame_counter);
+		static d_gdk_frame_clock_get_timings gdk_frame_clock_get_timings = FuncLoader.LoadFunction<d_gdk_frame_clock_get_timings>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_get_timings"));
+
+		public Gdk.FrameTimings GetTimings(long frame_counter) {
+			IntPtr raw_ret = gdk_frame_clock_get_timings(Handle, frame_counter);
+			Gdk.FrameTimings ret = raw_ret == IntPtr.Zero ? null : (Gdk.FrameTimings) GLib.Opaque.GetOpaque (raw_ret, typeof (Gdk.FrameTimings), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_frame_clock_get_type();
+		static d_gdk_frame_clock_get_type gdk_frame_clock_get_type = FuncLoader.LoadFunction<d_gdk_frame_clock_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_frame_clock_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_frame_clock_request_phase(IntPtr raw, int phase);
+		static d_gdk_frame_clock_request_phase gdk_frame_clock_request_phase = FuncLoader.LoadFunction<d_gdk_frame_clock_request_phase>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_request_phase"));
+
+		public void RequestPhase(Gdk.FrameClockPhase phase) {
+			gdk_frame_clock_request_phase(Handle, (int) phase);
+		}
+
+
+		// 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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FrameClockIdle.cs

@@ -0,0 +1,75 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class FrameClockIdle : Gdk.FrameClock {
+
+		public FrameClockIdle (IntPtr raw) : base(raw) {}
+
+		protected FrameClockIdle() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (Gdk.FrameClock.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_frame_clock_idle_get_type();
+		static d_gdk_frame_clock_idle_get_type gdk_frame_clock_idle_get_type = FuncLoader.LoadFunction<d_gdk_frame_clock_idle_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_idle_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_frame_clock_idle_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				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"
+							, Gdk.FrameClock.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FrameClockPhase.cs

@@ -0,0 +1,36 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (Gdk.FrameClockPhaseGType))]
+	public enum FrameClockPhase {
+
+		None,
+		FlushEvents = 1 << 0,
+		BeforePaint = 1 << 1,
+		Update = 1 << 2,
+		Layout = 1 << 3,
+		Paint = 1 << 4,
+		ResumeEvents = 1 << 5,
+		AfterPaint = 1 << 6,
+	}
+
+	internal class FrameClockPhaseGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_frame_clock_phase_get_type();
+		static d_gdk_frame_clock_phase_get_type gdk_frame_clock_phase_get_type = FuncLoader.LoadFunction<d_gdk_frame_clock_phase_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_clock_phase_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_frame_clock_phase_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FrameTimings.cs

@@ -0,0 +1,167 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FrameTimings : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_frame_timings_get_complete(IntPtr raw);
+		static d_gdk_frame_timings_get_complete gdk_frame_timings_get_complete = FuncLoader.LoadFunction<d_gdk_frame_timings_get_complete>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_get_complete"));
+
+		public bool Complete { 
+			get {
+				bool raw_ret = gdk_frame_timings_get_complete(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_timings_get_frame_counter(IntPtr raw);
+		static d_gdk_frame_timings_get_frame_counter gdk_frame_timings_get_frame_counter = FuncLoader.LoadFunction<d_gdk_frame_timings_get_frame_counter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_get_frame_counter"));
+
+		public long FrameCounter { 
+			get {
+				long raw_ret = gdk_frame_timings_get_frame_counter(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_timings_get_frame_time(IntPtr raw);
+		static d_gdk_frame_timings_get_frame_time gdk_frame_timings_get_frame_time = FuncLoader.LoadFunction<d_gdk_frame_timings_get_frame_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_get_frame_time"));
+
+		public long FrameTime { 
+			get {
+				long raw_ret = gdk_frame_timings_get_frame_time(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_timings_get_predicted_presentation_time(IntPtr raw);
+		static d_gdk_frame_timings_get_predicted_presentation_time gdk_frame_timings_get_predicted_presentation_time = FuncLoader.LoadFunction<d_gdk_frame_timings_get_predicted_presentation_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_get_predicted_presentation_time"));
+
+		public long PredictedPresentationTime { 
+			get {
+				long raw_ret = gdk_frame_timings_get_predicted_presentation_time(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_timings_get_presentation_time(IntPtr raw);
+		static d_gdk_frame_timings_get_presentation_time gdk_frame_timings_get_presentation_time = FuncLoader.LoadFunction<d_gdk_frame_timings_get_presentation_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_get_presentation_time"));
+
+		public long PresentationTime { 
+			get {
+				long raw_ret = gdk_frame_timings_get_presentation_time(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate long d_gdk_frame_timings_get_refresh_interval(IntPtr raw);
+		static d_gdk_frame_timings_get_refresh_interval gdk_frame_timings_get_refresh_interval = FuncLoader.LoadFunction<d_gdk_frame_timings_get_refresh_interval>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_get_refresh_interval"));
+
+		public long RefreshInterval { 
+			get {
+				long raw_ret = gdk_frame_timings_get_refresh_interval(Handle);
+				long ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_frame_timings_get_type();
+		static d_gdk_frame_timings_get_type gdk_frame_timings_get_type = FuncLoader.LoadFunction<d_gdk_frame_timings_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_frame_timings_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		public FrameTimings(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_frame_timings_ref(IntPtr raw);
+		static d_gdk_frame_timings_ref gdk_frame_timings_ref = FuncLoader.LoadFunction<d_gdk_frame_timings_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_ref"));
+
+		protected override void Ref (IntPtr raw)
+		{
+			if (!Owned) {
+				gdk_frame_timings_ref (raw);
+				Owned = true;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_frame_timings_unref(IntPtr raw);
+		static d_gdk_frame_timings_unref gdk_frame_timings_unref = FuncLoader.LoadFunction<d_gdk_frame_timings_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_frame_timings_unref"));
+
+		protected override void Unref (IntPtr raw)
+		{
+			if (Owned) {
+				gdk_frame_timings_unref (raw);
+				Owned = false;
+			}
+		}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				gdk_frame_timings_unref (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~FrameTimings ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FromEmbedderHandler.cs

@@ -0,0 +1,36 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+	public delegate void FromEmbedderHandler(object o, FromEmbedderArgs args);
+
+	public class FromEmbedderArgs : GLib.SignalArgs {
+		public double EmbedderX{
+			get {
+				return (double) Args [0];
+			}
+		}
+
+		public double EmbedderY{
+			get {
+				return (double) Args [1];
+			}
+		}
+
+		public double OffscreenX{
+			set {
+				Args[2] = (double)value;
+			}
+		}
+
+		public double OffscreenY{
+			set {
+				Args[3] = (double)value;
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/FullscreenMode.cs

@@ -0,0 +1,29 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.FullscreenModeGType))]
+	public enum FullscreenMode {
+
+		CurrentMonitor,
+		AllMonitors,
+	}
+
+	internal class FullscreenModeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_fullscreen_mode_get_type();
+		static d_gdk_fullscreen_mode_get_type gdk_fullscreen_mode_get_type = FuncLoader.LoadFunction<d_gdk_fullscreen_mode_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_fullscreen_mode_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_fullscreen_mode_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GLContext.cs

@@ -0,0 +1,423 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class GLContext : GLib.Object {
+
+		public GLContext (IntPtr raw) : base(raw) {}
+
+		protected GLContext() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_gl_context_get_display(IntPtr raw);
+		static d_gdk_gl_context_get_display gdk_gl_context_get_display = FuncLoader.LoadFunction<d_gdk_gl_context_get_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_display"));
+
+		[GLib.Property ("display")]
+		public Gdk.Display Display {
+			get  {
+				IntPtr raw_ret = gdk_gl_context_get_display(Handle);
+				Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_gl_context_get_window(IntPtr raw);
+		static d_gdk_gl_context_get_window gdk_gl_context_get_window = FuncLoader.LoadFunction<d_gdk_gl_context_get_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_window"));
+
+		[GLib.Property ("window")]
+		public Gdk.Window Window {
+			get  {
+				IntPtr raw_ret = gdk_gl_context_get_window(Handle);
+				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
+				return ret;
+			}
+		}
+
+		static RealizeNativeDelegate Realize_cb_delegate;
+		static RealizeNativeDelegate RealizeVMCallback {
+			get {
+				if (Realize_cb_delegate == null)
+					Realize_cb_delegate = new RealizeNativeDelegate (Realize_cb);
+				return Realize_cb_delegate;
+			}
+		}
+
+		static void OverrideRealize (GLib.GType gtype)
+		{
+			OverrideRealize (gtype, RealizeVMCallback);
+		}
+
+		static void OverrideRealize (GLib.GType gtype, RealizeNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("realize"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool RealizeNativeDelegate (IntPtr inst, out IntPtr error);
+
+		static bool Realize_cb (IntPtr inst, out IntPtr error)
+		{
+			error = IntPtr.Zero;
+
+			try {
+				GLContext __obj = GLib.Object.GetObject (inst, false) as GLContext;
+				bool __result;
+				__result = __obj.OnRealize ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.GLContext), ConnectionMethod="OverrideRealize")]
+		protected virtual bool OnRealize ()
+		{
+			return InternalRealize ();
+		}
+
+		private bool InternalRealize ()
+		{
+			RealizeNativeDelegate unmanaged = class_abi.BaseOverride<RealizeNativeDelegate>(this.LookupGType(), "realize");
+			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
+
+			IntPtr error = IntPtr.Zero;
+			bool __result = unmanaged (this.Handle, out error);
+			return __result;
+		}
+
+		static EndFrameNativeDelegate EndFrame_cb_delegate;
+		static EndFrameNativeDelegate EndFrameVMCallback {
+			get {
+				if (EndFrame_cb_delegate == null)
+					EndFrame_cb_delegate = new EndFrameNativeDelegate (EndFrame_cb);
+				return EndFrame_cb_delegate;
+			}
+		}
+
+		static void OverrideEndFrame (GLib.GType gtype)
+		{
+			OverrideEndFrame (gtype, EndFrameVMCallback);
+		}
+
+		static void OverrideEndFrame (GLib.GType gtype, EndFrameNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("end_frame"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void EndFrameNativeDelegate (IntPtr inst, IntPtr painted, IntPtr damage);
+
+		static void EndFrame_cb (IntPtr inst, IntPtr painted, IntPtr damage)
+		{
+			try {
+				GLContext __obj = GLib.Object.GetObject (inst, false) as GLContext;
+				__obj.OnEndFrame (new Cairo.Region(painted), new Cairo.Region(damage));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.GLContext), ConnectionMethod="OverrideEndFrame")]
+		protected virtual void OnEndFrame (Cairo.Region painted, Cairo.Region damage)
+		{
+			InternalEndFrame (painted, damage);
+		}
+
+		private void InternalEndFrame (Cairo.Region painted, Cairo.Region damage)
+		{
+			EndFrameNativeDelegate unmanaged = class_abi.BaseOverride<EndFrameNativeDelegate>(this.LookupGType(), "end_frame");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, painted == null ? IntPtr.Zero : painted.Handle, damage == null ? IntPtr.Zero : damage.Handle);
+		}
+
+		static TextureFromSurfaceNativeDelegate TextureFromSurface_cb_delegate;
+		static TextureFromSurfaceNativeDelegate TextureFromSurfaceVMCallback {
+			get {
+				if (TextureFromSurface_cb_delegate == null)
+					TextureFromSurface_cb_delegate = new TextureFromSurfaceNativeDelegate (TextureFromSurface_cb);
+				return TextureFromSurface_cb_delegate;
+			}
+		}
+
+		static void OverrideTextureFromSurface (GLib.GType gtype)
+		{
+			OverrideTextureFromSurface (gtype, TextureFromSurfaceVMCallback);
+		}
+
+		static void OverrideTextureFromSurface (GLib.GType gtype, TextureFromSurfaceNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("texture_from_surface"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool TextureFromSurfaceNativeDelegate (IntPtr inst, IntPtr surface, IntPtr region);
+
+		static bool TextureFromSurface_cb (IntPtr inst, IntPtr surface, IntPtr region)
+		{
+			try {
+				GLContext __obj = GLib.Object.GetObject (inst, false) as GLContext;
+				bool __result;
+				__result = __obj.OnTextureFromSurface (Cairo.Surface.Lookup (surface, true), new Cairo.Region(region));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.GLContext), ConnectionMethod="OverrideTextureFromSurface")]
+		protected virtual bool OnTextureFromSurface (Cairo.Surface surface, Cairo.Region region)
+		{
+			return InternalTextureFromSurface (surface, region);
+		}
+
+		private bool InternalTextureFromSurface (Cairo.Surface surface, Cairo.Region region)
+		{
+			TextureFromSurfaceNativeDelegate unmanaged = class_abi.BaseOverride<TextureFromSurfaceNativeDelegate>(this.LookupGType(), "texture_from_surface");
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle, surface.Handle, region == null ? IntPtr.Zero : region.Handle);
+			return __result;
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("realize"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // realize
+							, null
+							, "end_frame"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("end_frame"
+							, -1
+							, (uint) sizeof( IntPtr ) // end_frame
+							, "realize"
+							, "texture_from_surface"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("texture_from_surface"
+							, -1
+							, (uint) sizeof( IntPtr ) // texture_from_surface
+							, "end_frame"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_clear_current();
+		static d_gdk_gl_context_clear_current gdk_gl_context_clear_current = FuncLoader.LoadFunction<d_gdk_gl_context_clear_current>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_clear_current"));
+
+		public static void ClearCurrent() {
+			gdk_gl_context_clear_current();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_gl_context_get_current();
+		static d_gdk_gl_context_get_current gdk_gl_context_get_current = FuncLoader.LoadFunction<d_gdk_gl_context_get_current>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_current"));
+
+		public static Gdk.GLContext Current { 
+			get {
+				IntPtr raw_ret = gdk_gl_context_get_current();
+				Gdk.GLContext ret = GLib.Object.GetObject(raw_ret) as Gdk.GLContext;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_gl_context_get_debug_enabled(IntPtr raw);
+		static d_gdk_gl_context_get_debug_enabled gdk_gl_context_get_debug_enabled = FuncLoader.LoadFunction<d_gdk_gl_context_get_debug_enabled>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_debug_enabled"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_set_debug_enabled(IntPtr raw, bool enabled);
+		static d_gdk_gl_context_set_debug_enabled gdk_gl_context_set_debug_enabled = FuncLoader.LoadFunction<d_gdk_gl_context_set_debug_enabled>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_set_debug_enabled"));
+
+		public bool DebugEnabled { 
+			get {
+				bool raw_ret = gdk_gl_context_get_debug_enabled(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set {
+				gdk_gl_context_set_debug_enabled(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_gl_context_get_forward_compatible(IntPtr raw);
+		static d_gdk_gl_context_get_forward_compatible gdk_gl_context_get_forward_compatible = FuncLoader.LoadFunction<d_gdk_gl_context_get_forward_compatible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_forward_compatible"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_set_forward_compatible(IntPtr raw, bool compatible);
+		static d_gdk_gl_context_set_forward_compatible gdk_gl_context_set_forward_compatible = FuncLoader.LoadFunction<d_gdk_gl_context_set_forward_compatible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_set_forward_compatible"));
+
+		public bool ForwardCompatible { 
+			get {
+				bool raw_ret = gdk_gl_context_get_forward_compatible(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set {
+				gdk_gl_context_set_forward_compatible(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_get_required_version(IntPtr raw, out int major, out int minor);
+		static d_gdk_gl_context_get_required_version gdk_gl_context_get_required_version = FuncLoader.LoadFunction<d_gdk_gl_context_get_required_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_required_version"));
+
+		public void GetRequiredVersion(out int major, out int minor) {
+			gdk_gl_context_get_required_version(Handle, out major, out minor);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_gl_context_get_shared_context(IntPtr raw);
+		static d_gdk_gl_context_get_shared_context gdk_gl_context_get_shared_context = FuncLoader.LoadFunction<d_gdk_gl_context_get_shared_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_shared_context"));
+
+		public Gdk.GLContext SharedContext { 
+			get {
+				IntPtr raw_ret = gdk_gl_context_get_shared_context(Handle);
+				Gdk.GLContext ret = GLib.Object.GetObject(raw_ret) as Gdk.GLContext;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_gl_context_get_type();
+		static d_gdk_gl_context_get_type gdk_gl_context_get_type = FuncLoader.LoadFunction<d_gdk_gl_context_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_gl_context_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_gl_context_get_use_es(IntPtr raw);
+		static d_gdk_gl_context_get_use_es gdk_gl_context_get_use_es = FuncLoader.LoadFunction<d_gdk_gl_context_get_use_es>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_use_es"));
+
+		public bool UseEs { 
+			get {
+				bool raw_ret = gdk_gl_context_get_use_es(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_get_version(IntPtr raw, out int major, out int minor);
+		static d_gdk_gl_context_get_version gdk_gl_context_get_version = FuncLoader.LoadFunction<d_gdk_gl_context_get_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_get_version"));
+
+		public void GetVersion(out int major, out int minor) {
+			gdk_gl_context_get_version(Handle, out major, out minor);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_gl_context_is_legacy(IntPtr raw);
+		static d_gdk_gl_context_is_legacy gdk_gl_context_is_legacy = FuncLoader.LoadFunction<d_gdk_gl_context_is_legacy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_is_legacy"));
+
+		public bool IsLegacy { 
+			get {
+				bool raw_ret = gdk_gl_context_is_legacy(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_make_current(IntPtr raw);
+		static d_gdk_gl_context_make_current gdk_gl_context_make_current = FuncLoader.LoadFunction<d_gdk_gl_context_make_current>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_make_current"));
+
+		public void MakeCurrent() {
+			gdk_gl_context_make_current(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_gl_context_realize(IntPtr raw, out IntPtr error);
+		static d_gdk_gl_context_realize gdk_gl_context_realize = FuncLoader.LoadFunction<d_gdk_gl_context_realize>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_realize"));
+
+		public unsafe bool Realize() {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gdk_gl_context_realize(Handle, out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_set_required_version(IntPtr raw, int major, int minor);
+		static d_gdk_gl_context_set_required_version gdk_gl_context_set_required_version = FuncLoader.LoadFunction<d_gdk_gl_context_set_required_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_set_required_version"));
+
+		public void SetRequiredVersion(int major, int minor) {
+			gdk_gl_context_set_required_version(Handle, major, minor);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_gl_context_set_use_es(IntPtr raw, int use_es);
+		static d_gdk_gl_context_set_use_es gdk_gl_context_set_use_es = FuncLoader.LoadFunction<d_gdk_gl_context_set_use_es>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_context_set_use_es"));
+
+		public void SetUseEs(int use_es) {
+			gdk_gl_context_set_use_es(Handle, use_es);
+		}
+
+
+		// 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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GLError.cs

@@ -0,0 +1,17 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum GLError {
+
+		NotAvailable,
+		UnsupportedFormat,
+		UnsupportedProfile,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdipContext.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class GdipContext : GLib.Opaque {
+
+		public GdipContext(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdkSharp.EventFuncNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GdkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void EventFuncNative(IntPtr evnt, IntPtr data);
+
+	internal class EventFuncInvoker {
+
+		EventFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~EventFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal EventFuncInvoker (EventFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal EventFuncInvoker (EventFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal EventFuncInvoker (EventFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Gdk.EventFunc Handler {
+			get {
+				return new Gdk.EventFunc(InvokeNative);
+			}
+		}
+
+		void InvokeNative (Gdk.Event evnt)
+		{
+			native_cb (evnt == null ? IntPtr.Zero : evnt.Handle, __data);
+		}
+	}
+
+	internal class EventFuncWrapper {
+
+		public void NativeCallback (IntPtr evnt, IntPtr data)
+		{
+			try {
+				managed (Gdk.Event.GetEvent (evnt));
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal EventFuncNative NativeDelegate;
+		Gdk.EventFunc managed;
+
+		public EventFuncWrapper (Gdk.EventFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new EventFuncNative (NativeCallback);
+		}
+
+		public static Gdk.EventFunc GetManagedDelegate (EventFuncNative native)
+		{
+			if (native == null)
+				return null;
+			EventFuncWrapper wrapper = (EventFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdkSharp.FilterFuncNative.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GdkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate int FilterFuncNative(IntPtr xevent, IntPtr evnt, IntPtr data);
+
+	internal class FilterFuncInvoker {
+
+		FilterFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FilterFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FilterFuncInvoker (FilterFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FilterFuncInvoker (FilterFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FilterFuncInvoker (FilterFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Gdk.FilterFunc Handler {
+			get {
+				return new Gdk.FilterFunc(InvokeNative);
+			}
+		}
+
+		Gdk.FilterReturn InvokeNative (System.IntPtr xevent, Gdk.Event evnt)
+		{
+			Gdk.FilterReturn __result = (Gdk.FilterReturn) native_cb (xevent, evnt == null ? IntPtr.Zero : evnt.Handle, __data);
+			return __result;
+		}
+	}
+
+	internal class FilterFuncWrapper {
+
+		public int NativeCallback (IntPtr xevent, IntPtr evnt, IntPtr data)
+		{
+			try {
+				Gdk.FilterReturn __ret = managed (xevent, Gdk.Event.GetEvent (evnt));
+				if (release_on_call)
+					gch.Free ();
+				return (int) __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: Above call does not return.
+				throw;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal FilterFuncNative NativeDelegate;
+		Gdk.FilterFunc managed;
+
+		public FilterFuncWrapper (Gdk.FilterFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FilterFuncNative (NativeCallback);
+		}
+
+		public static Gdk.FilterFunc GetManagedDelegate (FilterFuncNative native)
+		{
+			if (native == null)
+				return null;
+			FilterFuncWrapper wrapper = (FilterFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdkSharp.PixbufDestroyNotifyNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GdkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void PixbufDestroyNotifyNative(byte[] pixels, IntPtr data);
+
+	internal class PixbufDestroyNotifyInvoker {
+
+		PixbufDestroyNotifyNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~PixbufDestroyNotifyInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal PixbufDestroyNotifyInvoker (PixbufDestroyNotifyNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal PixbufDestroyNotifyInvoker (PixbufDestroyNotifyNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal PixbufDestroyNotifyInvoker (PixbufDestroyNotifyNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Gdk.PixbufDestroyNotify Handler {
+			get {
+				return new Gdk.PixbufDestroyNotify(InvokeNative);
+			}
+		}
+
+		void InvokeNative (byte[] pixels)
+		{
+			native_cb (pixels, __data);
+		}
+	}
+
+	internal class PixbufDestroyNotifyWrapper {
+
+		public void NativeCallback (byte[] pixels, IntPtr data)
+		{
+			try {
+				managed (pixels);
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal PixbufDestroyNotifyNative NativeDelegate;
+		Gdk.PixbufDestroyNotify managed;
+
+		public PixbufDestroyNotifyWrapper (Gdk.PixbufDestroyNotify managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new PixbufDestroyNotifyNative (NativeCallback);
+		}
+
+		public static Gdk.PixbufDestroyNotify GetManagedDelegate (PixbufDestroyNotifyNative native)
+		{
+			if (native == null)
+				return null;
+			PixbufDestroyNotifyWrapper wrapper = (PixbufDestroyNotifyWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdkSharp.PixbufSaveFuncNative.cs

@@ -0,0 +1,99 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GdkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate bool PixbufSaveFuncNative(IntPtr buf, UIntPtr count, out IntPtr error, IntPtr data);
+
+	internal class PixbufSaveFuncInvoker {
+
+		PixbufSaveFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~PixbufSaveFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal PixbufSaveFuncInvoker (PixbufSaveFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal PixbufSaveFuncInvoker (PixbufSaveFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal PixbufSaveFuncInvoker (PixbufSaveFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Gdk.PixbufSaveFunc Handler {
+			get {
+				return new Gdk.PixbufSaveFunc(InvokeNative);
+			}
+		}
+
+		bool InvokeNative (string buf, ulong count)
+		{
+			IntPtr native_buf = GLib.Marshaller.StringToPtrGStrdup (buf);
+			IntPtr error = IntPtr.Zero;
+			bool __result = native_cb (native_buf, new UIntPtr (count), out error, __data);
+			GLib.Marshaller.Free (native_buf);
+			return __result;
+		}
+	}
+
+	internal class PixbufSaveFuncWrapper {
+
+		public bool NativeCallback (IntPtr buf, UIntPtr count, out IntPtr error, IntPtr data)
+		{
+			error = IntPtr.Zero;
+
+			try {
+				bool __ret = managed (GLib.Marshaller.Utf8PtrToString (buf), (ulong) count);
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+				return false;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal PixbufSaveFuncNative NativeDelegate;
+		Gdk.PixbufSaveFunc managed;
+
+		public PixbufSaveFuncWrapper (Gdk.PixbufSaveFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new PixbufSaveFuncNative (NativeCallback);
+		}
+
+		public static Gdk.PixbufSaveFunc GetManagedDelegate (PixbufSaveFuncNative native)
+		{
+			if (native == null)
+				return null;
+			PixbufSaveFuncWrapper wrapper = (PixbufSaveFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdkSharp.SeatGrabPrepareFuncNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GdkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void SeatGrabPrepareFuncNative(IntPtr seat, IntPtr window, IntPtr user_data);
+
+	internal class SeatGrabPrepareFuncInvoker {
+
+		SeatGrabPrepareFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~SeatGrabPrepareFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal SeatGrabPrepareFuncInvoker (SeatGrabPrepareFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal SeatGrabPrepareFuncInvoker (SeatGrabPrepareFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal SeatGrabPrepareFuncInvoker (SeatGrabPrepareFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Gdk.SeatGrabPrepareFunc Handler {
+			get {
+				return new Gdk.SeatGrabPrepareFunc(InvokeNative);
+			}
+		}
+
+		void InvokeNative (Gdk.Seat seat, Gdk.Window window)
+		{
+			native_cb (seat == null ? IntPtr.Zero : seat.Handle, window == null ? IntPtr.Zero : window.Handle, __data);
+		}
+	}
+
+	internal class SeatGrabPrepareFuncWrapper {
+
+		public void NativeCallback (IntPtr seat, IntPtr window, IntPtr user_data)
+		{
+			try {
+				managed (GLib.Object.GetObject(seat) as Gdk.Seat, GLib.Object.GetObject(window) as Gdk.Window);
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal SeatGrabPrepareFuncNative NativeDelegate;
+		Gdk.SeatGrabPrepareFunc managed;
+
+		public SeatGrabPrepareFuncWrapper (Gdk.SeatGrabPrepareFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new SeatGrabPrepareFuncNative (NativeCallback);
+		}
+
+		public static Gdk.SeatGrabPrepareFunc GetManagedDelegate (SeatGrabPrepareFuncNative native)
+		{
+			if (native == null)
+				return null;
+			SeatGrabPrepareFuncWrapper wrapper = (SeatGrabPrepareFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdkSharp.WindowChildFuncNative.cs

@@ -0,0 +1,94 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GdkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate bool WindowChildFuncNative(IntPtr window, IntPtr user_data);
+
+	internal class WindowChildFuncInvoker {
+
+		WindowChildFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~WindowChildFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal WindowChildFuncInvoker (WindowChildFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal WindowChildFuncInvoker (WindowChildFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal WindowChildFuncInvoker (WindowChildFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Gdk.WindowChildFunc Handler {
+			get {
+				return new Gdk.WindowChildFunc(InvokeNative);
+			}
+		}
+
+		bool InvokeNative (Gdk.Window window)
+		{
+			bool __result = native_cb (window == null ? IntPtr.Zero : window.Handle, __data);
+			return __result;
+		}
+	}
+
+	internal class WindowChildFuncWrapper {
+
+		public bool NativeCallback (IntPtr window, IntPtr user_data)
+		{
+			try {
+				bool __ret = managed (GLib.Object.GetObject(window) as Gdk.Window);
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+				return false;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal WindowChildFuncNative NativeDelegate;
+		Gdk.WindowChildFunc managed;
+
+		public WindowChildFuncWrapper (Gdk.WindowChildFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new WindowChildFuncNative (NativeCallback);
+		}
+
+		public static Gdk.WindowChildFunc GetManagedDelegate (WindowChildFuncNative native)
+		{
+			if (native == null)
+				return null;
+			WindowChildFuncWrapper wrapper = (WindowChildFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GdkSharp.WindowInvalidateHandlerFuncNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GdkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void WindowInvalidateHandlerFuncNative(IntPtr window, IntPtr region);
+
+	internal class WindowInvalidateHandlerFuncInvoker {
+
+		WindowInvalidateHandlerFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~WindowInvalidateHandlerFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal WindowInvalidateHandlerFuncInvoker (WindowInvalidateHandlerFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal WindowInvalidateHandlerFuncInvoker (WindowInvalidateHandlerFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal WindowInvalidateHandlerFuncInvoker (WindowInvalidateHandlerFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Gdk.WindowInvalidateHandlerFunc Handler {
+			get {
+				return new Gdk.WindowInvalidateHandlerFunc(InvokeNative);
+			}
+		}
+
+		void InvokeNative (Gdk.Window window, Cairo.Region region)
+		{
+			native_cb (window == null ? IntPtr.Zero : window.Handle, region == null ? IntPtr.Zero : region.Handle);
+		}
+	}
+
+	internal class WindowInvalidateHandlerFuncWrapper {
+
+		public void NativeCallback (IntPtr window, IntPtr region)
+		{
+			try {
+				managed (GLib.Object.GetObject(window) as Gdk.Window, new Cairo.Region(region));
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal WindowInvalidateHandlerFuncNative NativeDelegate;
+		Gdk.WindowInvalidateHandlerFunc managed;
+
+		public WindowInvalidateHandlerFuncWrapper (Gdk.WindowInvalidateHandlerFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new WindowInvalidateHandlerFuncNative (NativeCallback);
+		}
+
+		public static Gdk.WindowInvalidateHandlerFunc GetManagedDelegate (WindowInvalidateHandlerFuncNative native)
+		{
+			if (native == null)
+				return null;
+			WindowInvalidateHandlerFuncWrapper wrapper = (WindowInvalidateHandlerFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Geometry.cs

@@ -0,0 +1,55 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct Geometry : IEquatable<Geometry> {
+
+		public int MinWidth;
+		public int MinHeight;
+		public int MaxWidth;
+		public int MaxHeight;
+		public int BaseWidth;
+		public int BaseHeight;
+		public int WidthInc;
+		public int HeightInc;
+		public double MinAspect;
+		public double MaxAspect;
+		public Gdk.Gravity WinGravity;
+
+		public static Gdk.Geometry Zero = new Gdk.Geometry ();
+
+		public static Gdk.Geometry New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.Geometry.Zero;
+			return (Gdk.Geometry) Marshal.PtrToStructure (raw, typeof (Gdk.Geometry));
+		}
+
+		public bool Equals (Geometry other)
+		{
+			return true && MinWidth.Equals (other.MinWidth) && MinHeight.Equals (other.MinHeight) && MaxWidth.Equals (other.MaxWidth) && MaxHeight.Equals (other.MaxHeight) && BaseWidth.Equals (other.BaseWidth) && BaseHeight.Equals (other.BaseHeight) && WidthInc.Equals (other.WidthInc) && HeightInc.Equals (other.HeightInc) && MinAspect.Equals (other.MinAspect) && MaxAspect.Equals (other.MaxAspect) && WinGravity.Equals (other.WinGravity);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is Geometry && Equals ((Geometry) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ MinWidth.GetHashCode () ^ MinHeight.GetHashCode () ^ MaxWidth.GetHashCode () ^ MaxHeight.GetHashCode () ^ BaseWidth.GetHashCode () ^ BaseHeight.GetHashCode () ^ WidthInc.GetHashCode () ^ HeightInc.GetHashCode () ^ MinAspect.GetHashCode () ^ MaxAspect.GetHashCode () ^ WinGravity.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Gif89.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Gif89 : GLib.Opaque {
+
+		public Gif89(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GifContext.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class GifContext : GLib.Opaque {
+
+		public GifContext(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Global.cs

@@ -0,0 +1,159 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Global {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_disable_multidevice();
+		static d_gdk_disable_multidevice gdk_disable_multidevice = FuncLoader.LoadFunction<d_gdk_disable_multidevice>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_disable_multidevice"));
+
+		public static void DisableMultidevice() {
+			gdk_disable_multidevice();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_get_default_root_window();
+		static d_gdk_get_default_root_window gdk_get_default_root_window = FuncLoader.LoadFunction<d_gdk_get_default_root_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_get_default_root_window"));
+
+		public static Gdk.Window DefaultRootWindow { 
+			get {
+				IntPtr raw_ret = gdk_get_default_root_window();
+				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_get_display_arg_name();
+		static d_gdk_get_display_arg_name gdk_get_display_arg_name = FuncLoader.LoadFunction<d_gdk_get_display_arg_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_get_display_arg_name"));
+
+		public static string DisplayArgName { 
+			get {
+				IntPtr raw_ret = gdk_get_display_arg_name();
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_get_program_class();
+		static d_gdk_get_program_class gdk_get_program_class = FuncLoader.LoadFunction<d_gdk_get_program_class>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_get_program_class"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_set_program_class(IntPtr program_class);
+		static d_gdk_set_program_class gdk_set_program_class = FuncLoader.LoadFunction<d_gdk_set_program_class>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_set_program_class"));
+
+		public static string ProgramClass { 
+			get {
+				IntPtr raw_ret = gdk_get_program_class();
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+			set {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gdk_set_program_class(native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_get_show_events();
+		static d_gdk_get_show_events gdk_get_show_events = FuncLoader.LoadFunction<d_gdk_get_show_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_get_show_events"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_set_show_events(bool show_events);
+		static d_gdk_set_show_events gdk_set_show_events = FuncLoader.LoadFunction<d_gdk_set_show_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_set_show_events"));
+
+		public static bool ShowEvents { 
+			get {
+				bool raw_ret = gdk_get_show_events();
+				bool ret = raw_ret;
+				return ret;
+			}
+			set {
+				gdk_set_show_events(value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_gl_error_quark();
+		static d_gdk_gl_error_quark gdk_gl_error_quark = FuncLoader.LoadFunction<d_gdk_gl_error_quark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gl_error_quark"));
+
+		public static int GlErrorQuark() {
+			int raw_ret = gdk_gl_error_quark();
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_pre_parse_libgtk_only();
+		static d_gdk_pre_parse_libgtk_only gdk_pre_parse_libgtk_only = FuncLoader.LoadFunction<d_gdk_pre_parse_libgtk_only>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_pre_parse_libgtk_only"));
+
+		[Obsolete]
+		public static void PreParseLibgtkOnly() {
+			gdk_pre_parse_libgtk_only();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_set_allowed_backends(IntPtr backends);
+		static d_gdk_set_allowed_backends gdk_set_allowed_backends = FuncLoader.LoadFunction<d_gdk_set_allowed_backends>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_set_allowed_backends"));
+
+		public static string AllowedBackends { 
+			set {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gdk_set_allowed_backends(native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_set_double_click_time(uint msec);
+		static d_gdk_set_double_click_time gdk_set_double_click_time = FuncLoader.LoadFunction<d_gdk_set_double_click_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_set_double_click_time"));
+
+		public static uint DoubleClickTime { 
+			set {
+				gdk_set_double_click_time(value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_setting_get(IntPtr name, IntPtr value);
+		static d_gdk_setting_get gdk_setting_get = FuncLoader.LoadFunction<d_gdk_setting_get>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_setting_get"));
+
+		public static bool SettingGet(string name, GLib.Value value) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			bool raw_ret = gdk_setting_get(native_name, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_name);
+			Marshal.FreeHGlobal (native_value);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gdk_unicode_to_keyval(uint wc);
+		static d_gdk_unicode_to_keyval gdk_unicode_to_keyval = FuncLoader.LoadFunction<d_gdk_unicode_to_keyval>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_unicode_to_keyval"));
+
+		public static uint UnicodeToKeyval(uint wc) {
+			uint raw_ret = gdk_unicode_to_keyval(wc);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_notify_startup_complete();
+		static d_gdk_notify_startup_complete gdk_notify_startup_complete = FuncLoader.LoadFunction<d_gdk_notify_startup_complete>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_notify_startup_complete"));
+
+		public static void NotifyStartupComplete() {
+			gdk_notify_startup_complete();
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GlobalErrorTrap.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class GlobalErrorTrap : GLib.Opaque {
+
+		public GlobalErrorTrap(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GrabOwnership.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.GrabOwnershipGType))]
+	public enum GrabOwnership {
+
+		None,
+		Window,
+		Application,
+	}
+
+	internal class GrabOwnershipGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_grab_ownership_get_type();
+		static d_gdk_grab_ownership_get_type gdk_grab_ownership_get_type = FuncLoader.LoadFunction<d_gdk_grab_ownership_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_grab_ownership_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_grab_ownership_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/GrabStatus.cs

@@ -0,0 +1,33 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.GrabStatusGType))]
+	public enum GrabStatus {
+
+		Success,
+		AlreadyGrabbed = 1,
+		InvalidTime = 2,
+		NotViewable = 3,
+		Frozen = 4,
+		Failed = 5,
+	}
+
+	internal class GrabStatusGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_grab_status_get_type();
+		static d_gdk_grab_status_get_type gdk_grab_status_get_type = FuncLoader.LoadFunction<d_gdk_grab_status_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_grab_status_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_grab_status_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Gravity.cs

@@ -0,0 +1,37 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.GravityGType))]
+	public enum Gravity {
+
+		NorthWest = 1,
+		North,
+		NorthEast,
+		West,
+		Center,
+		East,
+		SouthWest,
+		South,
+		SouthEast,
+		Static,
+	}
+
+	internal class GravityGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_gravity_get_type();
+		static d_gdk_gravity_get_type gdk_gravity_get_type = FuncLoader.LoadFunction<d_gdk_gravity_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_gravity_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_gravity_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/IDevicePad.cs

@@ -0,0 +1,28 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IDevicePad : GLib.IWrapper {
+
+		int GetFeatureGroup(Gdk.DevicePadFeature feature, int feature_idx);
+		int GetGroupNModes(int group_idx);
+		int GetNFeatures(Gdk.DevicePadFeature feature);
+		int NGroups { 
+			get;
+		}
+	}
+
+	[GLib.GInterface (typeof (DevicePadAdapter))]
+	public partial interface IDevicePadImplementor : GLib.IWrapper {
+
+		int NGroups { get; }
+		int GetGroupNModes (int group);
+		int GetNFeatures (Gdk.DevicePadFeature feature);
+		int GetFeatureGroup (Gdk.DevicePadFeature feature, int idx);
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/IOClosure.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class IOClosure : GLib.Opaque {
+
+		public IOClosure(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/IcnsBlockHeader.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class IcnsBlockHeader : GLib.Opaque {
+
+		public IcnsBlockHeader(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/IconEntry.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class IconEntry : GLib.Opaque {
+
+		public IconEntry(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/InputMode.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.InputModeGType))]
+	public enum InputMode {
+
+		Disabled,
+		Screen,
+		Window,
+	}
+
+	internal class InputModeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_input_mode_get_type();
+		static d_gdk_input_mode_get_type gdk_input_mode_get_type = FuncLoader.LoadFunction<d_gdk_input_mode_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_input_mode_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_input_mode_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/InputSource.cs

@@ -0,0 +1,36 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.InputSourceGType))]
+	public enum InputSource {
+
+		Mouse,
+		Pen,
+		Eraser,
+		Cursor,
+		Keyboard,
+		Touchscreen,
+		Touchpad,
+		Trackpoint,
+		TabletPad,
+	}
+
+	internal class InputSourceGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_input_source_get_type();
+		static d_gdk_input_source_get_type gdk_input_source_get_type = FuncLoader.LoadFunction<d_gdk_input_source_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_input_source_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_input_source_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/InterpType.cs

@@ -0,0 +1,31 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.InterpTypeGType))]
+	public enum InterpType {
+
+		Nearest,
+		Tiles,
+		Bilinear,
+		Hyper,
+	}
+
+	internal class InterpTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_interp_type_get_type();
+		static d_gdk_interp_type_get_type gdk_interp_type_get_type = FuncLoader.LoadFunction<d_gdk_interp_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_interp_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_interp_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Keyboard.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Keyboard {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_keyboard_grab(IntPtr window, bool owner_events, uint time_);
+		static d_gdk_keyboard_grab gdk_keyboard_grab = FuncLoader.LoadFunction<d_gdk_keyboard_grab>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyboard_grab"));
+
+		[Obsolete]
+		public static Gdk.GrabStatus Grab(Gdk.Window window, bool owner_events, uint time_) {
+			int raw_ret = gdk_keyboard_grab(window == null ? IntPtr.Zero : window.Handle, owner_events, time_);
+			Gdk.GrabStatus ret = (Gdk.GrabStatus) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_keyboard_ungrab(uint time_);
+		static d_gdk_keyboard_ungrab gdk_keyboard_ungrab = FuncLoader.LoadFunction<d_gdk_keyboard_ungrab>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyboard_ungrab"));
+
+		[Obsolete]
+		public static void Ungrab(uint time_) {
+			gdk_keyboard_ungrab(time_);
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/KeymapKey.cs

@@ -0,0 +1,47 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct KeymapKey : IEquatable<KeymapKey> {
+
+		public uint Keycode;
+		public int Group;
+		public int Level;
+
+		public static Gdk.KeymapKey Zero = new Gdk.KeymapKey ();
+
+		public static Gdk.KeymapKey New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Gdk.KeymapKey.Zero;
+			return (Gdk.KeymapKey) Marshal.PtrToStructure (raw, typeof (Gdk.KeymapKey));
+		}
+
+		public bool Equals (KeymapKey other)
+		{
+			return true && Keycode.Equals (other.Keycode) && Group.Equals (other.Group) && Level.Equals (other.Level);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is KeymapKey && Equals ((KeymapKey) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Keycode.GetHashCode () ^ Group.GetHashCode () ^ Level.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Keyval.cs

@@ -0,0 +1,94 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Keyval {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_keyval_convert_case(uint symbol, out uint lower, out uint upper);
+		static d_gdk_keyval_convert_case gdk_keyval_convert_case = FuncLoader.LoadFunction<d_gdk_keyval_convert_case>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_convert_case"));
+
+		public static void ConvertCase(uint symbol, out uint lower, out uint upper) {
+			gdk_keyval_convert_case(symbol, out lower, out upper);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gdk_keyval_from_name(IntPtr keyval_name);
+		static d_gdk_keyval_from_name gdk_keyval_from_name = FuncLoader.LoadFunction<d_gdk_keyval_from_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_from_name"));
+
+		public static uint FromName(string keyval_name) {
+			IntPtr native_keyval_name = GLib.Marshaller.StringToPtrGStrdup (keyval_name);
+			uint raw_ret = gdk_keyval_from_name(native_keyval_name);
+			uint ret = raw_ret;
+			GLib.Marshaller.Free (native_keyval_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_keyval_is_lower(uint keyval);
+		static d_gdk_keyval_is_lower gdk_keyval_is_lower = FuncLoader.LoadFunction<d_gdk_keyval_is_lower>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_is_lower"));
+
+		public static bool IsLower(uint keyval) {
+			bool raw_ret = gdk_keyval_is_lower(keyval);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_keyval_is_upper(uint keyval);
+		static d_gdk_keyval_is_upper gdk_keyval_is_upper = FuncLoader.LoadFunction<d_gdk_keyval_is_upper>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_is_upper"));
+
+		public static bool IsUpper(uint keyval) {
+			bool raw_ret = gdk_keyval_is_upper(keyval);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_keyval_name(uint keyval);
+		static d_gdk_keyval_name gdk_keyval_name = FuncLoader.LoadFunction<d_gdk_keyval_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_name"));
+
+		public static string Name(uint keyval) {
+			IntPtr raw_ret = gdk_keyval_name(keyval);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gdk_keyval_to_lower(uint keyval);
+		static d_gdk_keyval_to_lower gdk_keyval_to_lower = FuncLoader.LoadFunction<d_gdk_keyval_to_lower>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_to_lower"));
+
+		public static uint ToLower(uint keyval) {
+			uint raw_ret = gdk_keyval_to_lower(keyval);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gdk_keyval_to_unicode(uint keyval);
+		static d_gdk_keyval_to_unicode gdk_keyval_to_unicode = FuncLoader.LoadFunction<d_gdk_keyval_to_unicode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_to_unicode"));
+
+		public static uint ToUnicode(uint keyval) {
+			uint raw_ret = gdk_keyval_to_unicode(keyval);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gdk_keyval_to_upper(uint keyval);
+		static d_gdk_keyval_to_upper gdk_keyval_to_upper = FuncLoader.LoadFunction<d_gdk_keyval_to_upper>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keyval_to_upper"));
+
+		public static uint ToUpper(uint keyval) {
+			uint raw_ret = gdk_keyval_to_upper(keyval);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/LoadContext.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class LoadContext : GLib.Opaque {
+
+		public LoadContext(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ModifierIntent.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Gdk.ModifierIntentGType))]
+	public enum ModifierIntent {
+
+		PrimaryAccelerator,
+		ContextMenu,
+		ExtendSelection,
+		ModifySelection,
+		NoTextInput,
+		ShiftGroup,
+		DefaultModMask,
+	}
+
+	internal class ModifierIntentGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_modifier_intent_get_type();
+		static d_gdk_modifier_intent_get_type gdk_modifier_intent_get_type = FuncLoader.LoadFunction<d_gdk_modifier_intent_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_modifier_intent_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_modifier_intent_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/ModifierType.cs

@@ -0,0 +1,61 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (Gdk.ModifierTypeGType))]
+	public enum ModifierType {
+
+		ShiftMask = 1 << 0,
+		LockMask = 1 << 1,
+		ControlMask = 1 << 2,
+		Mod1Mask = 1 << 3,
+		Mod2Mask = 1 << 4,
+		Mod3Mask = 1 << 5,
+		Mod4Mask = 1 << 6,
+		Mod5Mask = 1 << 7,
+		Button1Mask = 1 << 8,
+		Button2Mask = 1 << 9,
+		Button3Mask = 1 << 10,
+		Button4Mask = 1 << 11,
+		Button5Mask = 1 << 12,
+		ModifierReserved13Mask = 1 << 13,
+		ModifierReserved14Mask = 1 << 14,
+		ModifierReserved15Mask = 1 << 15,
+		ModifierReserved16Mask = 1 << 16,
+		ModifierReserved17Mask = 1 << 17,
+		ModifierReserved18Mask = 1 << 18,
+		ModifierReserved19Mask = 1 << 19,
+		ModifierReserved20Mask = 1 << 20,
+		ModifierReserved21Mask = 1 << 21,
+		ModifierReserved22Mask = 1 << 22,
+		ModifierReserved23Mask = 1 << 23,
+		ModifierReserved24Mask = 1 << 24,
+		ModifierReserved25Mask = 1 << 25,
+		SuperMask = 1 << 26,
+		HyperMask = 1 << 27,
+		MetaMask = 1 << 28,
+		ModifierReserved29Mask = 1 << 29,
+		ReleaseMask = 1 << 30,
+		ModifierMask = ReleaseMask | 0x1fff,
+		None = 0,
+	}
+
+	internal class ModifierTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_modifier_type_get_type();
+		static d_gdk_modifier_type_get_type gdk_modifier_type_get_type = FuncLoader.LoadFunction<d_gdk_modifier_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_modifier_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (gdk_modifier_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Monitor.cs

@@ -0,0 +1,333 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Monitor : GLib.Object {
+
+		public Monitor (IntPtr raw) : base(raw) {}
+
+		protected Monitor() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_monitor_get_display(IntPtr raw);
+		static d_gdk_monitor_get_display gdk_monitor_get_display = FuncLoader.LoadFunction<d_gdk_monitor_get_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_display"));
+
+		[GLib.Property ("display")]
+		public Gdk.Display Display {
+			get  {
+				IntPtr raw_ret = gdk_monitor_get_display(Handle);
+				Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_monitor_get_manufacturer(IntPtr raw);
+		static d_gdk_monitor_get_manufacturer gdk_monitor_get_manufacturer = FuncLoader.LoadFunction<d_gdk_monitor_get_manufacturer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_manufacturer"));
+
+		[GLib.Property ("manufacturer")]
+		public string Manufacturer {
+			get  {
+				IntPtr raw_ret = gdk_monitor_get_manufacturer(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_monitor_get_model(IntPtr raw);
+		static d_gdk_monitor_get_model gdk_monitor_get_model = FuncLoader.LoadFunction<d_gdk_monitor_get_model>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_model"));
+
+		[GLib.Property ("model")]
+		public string Model {
+			get  {
+				IntPtr raw_ret = gdk_monitor_get_model(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_monitor_get_scale_factor(IntPtr raw);
+		static d_gdk_monitor_get_scale_factor gdk_monitor_get_scale_factor = FuncLoader.LoadFunction<d_gdk_monitor_get_scale_factor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_scale_factor"));
+
+		[GLib.Property ("scale-factor")]
+		public int ScaleFactor {
+			get  {
+				int raw_ret = gdk_monitor_get_scale_factor(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_monitor_get_geometry(IntPtr raw, IntPtr geometry);
+		static d_gdk_monitor_get_geometry gdk_monitor_get_geometry = FuncLoader.LoadFunction<d_gdk_monitor_get_geometry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_geometry"));
+
+		[GLib.Property ("geometry")]
+		public Gdk.Rectangle Geometry {
+			get  {
+				Gdk.Rectangle geometry;
+				IntPtr native_geometry = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
+				gdk_monitor_get_geometry(Handle, native_geometry);
+				geometry = (Gdk.Rectangle) Marshal.PtrToStructure (native_geometry, typeof (Gdk.Rectangle));
+				Marshal.FreeHGlobal (native_geometry);
+				return geometry;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gdk_monitor_get_workarea(IntPtr raw, IntPtr workarea);
+		static d_gdk_monitor_get_workarea gdk_monitor_get_workarea = FuncLoader.LoadFunction<d_gdk_monitor_get_workarea>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_workarea"));
+
+		[GLib.Property ("workarea")]
+		public Gdk.Rectangle Workarea {
+			get  {
+				Gdk.Rectangle workarea;
+				IntPtr native_workarea = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
+				gdk_monitor_get_workarea(Handle, native_workarea);
+				workarea = (Gdk.Rectangle) Marshal.PtrToStructure (native_workarea, typeof (Gdk.Rectangle));
+				Marshal.FreeHGlobal (native_workarea);
+				return workarea;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_monitor_get_width_mm(IntPtr raw);
+		static d_gdk_monitor_get_width_mm gdk_monitor_get_width_mm = FuncLoader.LoadFunction<d_gdk_monitor_get_width_mm>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_width_mm"));
+
+		[GLib.Property ("width-mm")]
+		public int WidthMm {
+			get  {
+				int raw_ret = gdk_monitor_get_width_mm(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_monitor_get_height_mm(IntPtr raw);
+		static d_gdk_monitor_get_height_mm gdk_monitor_get_height_mm = FuncLoader.LoadFunction<d_gdk_monitor_get_height_mm>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_height_mm"));
+
+		[GLib.Property ("height-mm")]
+		public int HeightMm {
+			get  {
+				int raw_ret = gdk_monitor_get_height_mm(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_monitor_get_refresh_rate(IntPtr raw);
+		static d_gdk_monitor_get_refresh_rate gdk_monitor_get_refresh_rate = FuncLoader.LoadFunction<d_gdk_monitor_get_refresh_rate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_refresh_rate"));
+
+		[GLib.Property ("refresh-rate")]
+		public int RefreshRate {
+			get  {
+				int raw_ret = gdk_monitor_get_refresh_rate(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gdk_monitor_get_subpixel_layout(IntPtr raw);
+		static d_gdk_monitor_get_subpixel_layout gdk_monitor_get_subpixel_layout = FuncLoader.LoadFunction<d_gdk_monitor_get_subpixel_layout>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_subpixel_layout"));
+
+		[GLib.Property ("subpixel-layout")]
+		public Gdk.SubpixelLayout SubpixelLayout {
+			get  {
+				int raw_ret = gdk_monitor_get_subpixel_layout(Handle);
+				Gdk.SubpixelLayout ret = (Gdk.SubpixelLayout) raw_ret;
+				return ret;
+			}
+		}
+
+		[GLib.Signal("invalidate")]
+		public event System.EventHandler Invalidate {
+			add {
+				this.AddSignalHandler ("invalidate", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("invalidate", value);
+			}
+		}
+
+		static InvalidateNativeDelegate Invalidate_cb_delegate;
+		static InvalidateNativeDelegate InvalidateVMCallback {
+			get {
+				if (Invalidate_cb_delegate == null)
+					Invalidate_cb_delegate = new InvalidateNativeDelegate (Invalidate_cb);
+				return Invalidate_cb_delegate;
+			}
+		}
+
+		static void OverrideInvalidate (GLib.GType gtype)
+		{
+			OverrideInvalidate (gtype, InvalidateVMCallback);
+		}
+
+		static void OverrideInvalidate (GLib.GType gtype, InvalidateNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "invalidate", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void InvalidateNativeDelegate (IntPtr inst);
+
+		static void Invalidate_cb (IntPtr inst)
+		{
+			try {
+				Monitor __obj = GLib.Object.GetObject (inst, false) as Monitor;
+				__obj.OnInvalidate ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Monitor), ConnectionMethod="OverrideInvalidate")]
+		protected virtual void OnInvalidate ()
+		{
+			InternalInvalidate ();
+		}
+
+		private void InternalInvalidate ()
+		{
+			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 GetWorkareaNativeDelegate GetWorkarea_cb_delegate;
+		static GetWorkareaNativeDelegate GetWorkareaVMCallback {
+			get {
+				if (GetWorkarea_cb_delegate == null)
+					GetWorkarea_cb_delegate = new GetWorkareaNativeDelegate (GetWorkarea_cb);
+				return GetWorkarea_cb_delegate;
+			}
+		}
+
+		static void OverrideGetWorkarea (GLib.GType gtype)
+		{
+			OverrideGetWorkarea (gtype, GetWorkareaVMCallback);
+		}
+
+		static void OverrideGetWorkarea (GLib.GType gtype, GetWorkareaNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_workarea"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetWorkareaNativeDelegate (IntPtr inst, IntPtr geometry);
+
+		static void GetWorkarea_cb (IntPtr inst, IntPtr geometry)
+		{
+			try {
+				Monitor __obj = GLib.Object.GetObject (inst, false) as Monitor;
+				__obj.OnGetWorkarea ((Gdk.Rectangle) Marshal.PtrToStructure (geometry, typeof (Gdk.Rectangle)));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Monitor), ConnectionMethod="OverrideGetWorkarea")]
+		protected virtual void OnGetWorkarea (Gdk.Rectangle geometry)
+		{
+			InternalGetWorkarea (geometry);
+		}
+
+		private void InternalGetWorkarea (Gdk.Rectangle geometry)
+		{
+			GetWorkareaNativeDelegate unmanaged = class_abi.BaseOverride<GetWorkareaNativeDelegate>(this.LookupGType(), "get_workarea");
+			if (unmanaged == null) return;
+
+			IntPtr native_geometry = GLib.Marshaller.StructureToPtrAlloc (geometry);
+			unmanaged (this.Handle, native_geometry);
+			Marshal.FreeHGlobal (native_geometry);
+		}
+
+
+		// 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("get_workarea"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // get_workarea
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_monitor_get_type();
+		static d_gdk_monitor_get_type gdk_monitor_get_type = FuncLoader.LoadFunction<d_gdk_monitor_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gdk_monitor_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gdk_monitor_is_primary(IntPtr raw);
+		static d_gdk_monitor_is_primary gdk_monitor_is_primary = FuncLoader.LoadFunction<d_gdk_monitor_is_primary>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_monitor_is_primary"));
+
+		public bool IsPrimary { 
+			get {
+				bool raw_ret = gdk_monitor_is_primary(Handle);
+				bool ret = raw_ret;
+				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 (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}