no more submodule

GtkSharp/Source/Libs/GdkSharp/Atom.cs

@@ -0,0 +1,27 @@
+// Atom.cs
+// 
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Gdk {
+
+	public partial class Atom {
+
+		public static implicit operator string (Gdk.Atom atom)
+		{
+			return atom.Name;
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/Color.cs

@@ -0,0 +1,47 @@
+// Gdk.Color.cs - Gdk Color class customizations
+//
+// Author: Jasper van Putten <Jaspervp@gmx.net>, Miguel de Icaza.
+//
+// Copyright (c) 2002 Jasper van Putten
+// Copyright (c) 2003 Miguel de Icaza.
+//
+// This code is inserted after the automatically generated code.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Gdk {
+
+	using System.Runtime.InteropServices;
+
+	public partial struct Color {
+
+		public Color (byte r, byte g, byte b)
+		{
+			Red = (ushort) (r << 8 | r);
+			Green = (ushort) (g << 8 | g);
+			Blue = (ushort) (b << 8 | b);
+			Pixel = 0;
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate uint d_gdk_color_hash(ref Gdk.Color raw);
+		static d_gdk_color_hash gdk_color_hash = FuncLoader.LoadFunction<d_gdk_color_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_color_hash"));
+
+		public override int GetHashCode() {
+			return (int) gdk_color_hash(ref this);
+		}
+	}
+}
+
+

GtkSharp/Source/Libs/GdkSharp/Device.cs

@@ -0,0 +1,53 @@
+// Device.cs - customizations to Gdk.Device
+//
+// Authors: Manuel V. Santos  <mvsl@telefonica.net>
+//
+// Copyright (c) 2004 Manuel V. Santos
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class Device {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_gdk_device_free_history(IntPtr events, int n_events);
+		static d_gdk_device_free_history gdk_device_free_history = FuncLoader.LoadFunction<d_gdk_device_free_history>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_free_history"));
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate bool d_gdk_device_get_history(IntPtr device, IntPtr window, uint start, uint stop, out IntPtr events, out int n_events);
+		static d_gdk_device_get_history gdk_device_get_history = FuncLoader.LoadFunction<d_gdk_device_get_history>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_history"));
+
+		public TimeCoord[] GetHistory (Gdk.Window window, uint start, uint stop)
+		{
+			IntPtr coords_handle;
+			int count;
+
+			if (gdk_device_get_history (Handle, window.Handle, start, stop, out coords_handle, out count)) {
+				TimeCoord[] result = new TimeCoord [count];
+				for (int i = 0; i < count; i++) {
+					IntPtr ptr = Marshal.ReadIntPtr (coords_handle, i + IntPtr.Size);
+					result [i] = TimeCoord.New (ptr);
+				}
+				gdk_device_free_history (coords_handle, count);
+				return result;
+			} else
+				return new TimeCoord [0];
+		}
+	}
+}
+
+

GtkSharp/Source/Libs/GdkSharp/Display.cs

@@ -0,0 +1,86 @@
+// Display.cs - customizations to Gdk.Display
+//
+// Authors: Mike Kestner  <mkestner@ximian.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Gdk {
+
+	using System;
+	using System.Collections;
+	using System.Runtime.InteropServices;
+
+	public partial class Display {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_gdk_display_get_pointer(IntPtr raw, IntPtr screen, out int x, out int y, out int mask);
+		static d_gdk_display_get_pointer gdk_display_get_pointer = FuncLoader.LoadFunction<d_gdk_display_get_pointer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_get_pointer"));
+
+		[Obsolete]
+		public void GetPointer(Gdk.Screen screen, out int x, out int y, out Gdk.ModifierType mask) {
+			int mask_as_int;
+			gdk_display_get_pointer(Handle, screen.Handle, out x, out y, out mask_as_int);
+			mask = (Gdk.ModifierType) mask_as_int;
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_gdk_display_get_pointer2(IntPtr raw, out IntPtr screen, out int x, out int y, out int mask);
+		static d_gdk_display_get_pointer2 gdk_display_get_pointer2 = FuncLoader.LoadFunction<d_gdk_display_get_pointer2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_get_pointer"));
+
+		public void GetPointer(out Gdk.Screen screen, out int x, out int y, out Gdk.ModifierType mask) {
+			IntPtr screen_handle;
+			int mask_as_int;
+			gdk_display_get_pointer2(Handle, out screen_handle, out x, out y, out mask_as_int);
+			screen = (Gdk.Screen) GLib.Object.GetObject(screen_handle);
+			mask = (Gdk.ModifierType) mask_as_int;
+		}
+
+		public void GetPointer (out int x, out int y)
+		{
+			Gdk.ModifierType mod;
+			Gdk.Screen screen;
+			GetPointer (out screen, out x, out y, out mod);
+		}
+
+		public void GetPointer (out int x, out int y, out Gdk.ModifierType mod)
+		{
+			Gdk.Screen screen;
+			GetPointer (out screen, out x, out y, out mod);
+		}
+
+		public void GetPointer (out Gdk.Screen screen, out int x, out int y)
+		{
+			Gdk.ModifierType mod;
+			GetPointer (out screen, out x, out y, out mod);
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_display_list_devices(IntPtr raw);
+		static d_gdk_display_list_devices gdk_display_list_devices = FuncLoader.LoadFunction<d_gdk_display_list_devices>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_list_devices"));
+
+		public Device[] ListDevices ()
+		{
+			IntPtr raw_ret = gdk_display_list_devices (Handle);
+			if (raw_ret == IntPtr.Zero)
+				return new Device [0];
+			GLib.List list = new GLib.List(raw_ret);
+			Device[] result = new Device [list.Count];
+			for (int i = 0; i < list.Count; i++)
+				result [i] = list [i] as Device;
+			return result;
+		}
+	}
+}
+
+

GtkSharp/Source/Libs/GdkSharp/DisplayManager.cs

@@ -0,0 +1,45 @@
+// DisplayManager.cs - customizations to Gdk.DisplayManager
+//
+// Authors: Mike Kestner  <mkestner@ximian.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class DisplayManager {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_gdk_display_manager_list_displays(IntPtr raw);
+		static d_gdk_display_manager_list_displays gdk_display_manager_list_displays = FuncLoader.LoadFunction<d_gdk_display_manager_list_displays>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_manager_list_displays"));
+
+		public Display[] ListDisplays ()
+		{
+			IntPtr raw_ret = gdk_display_manager_list_displays (Handle);
+			if (raw_ret == IntPtr.Zero)
+				return new Display [0];
+			GLib.SList list = new GLib.SList(raw_ret);
+			Display[] result = new Display [list.Count];
+			for (int i = 0; i < list.Count; i++)
+				result [i] = list [i] as Display;
+			return result;
+		}
+	}
+}
+
+

GtkSharp/Source/Libs/GdkSharp/Event.cs

@@ -0,0 +1,157 @@
+// Gdk.Event.cs - Custom event wrapper 
+//
+// Authors: Rachel Hestilow <hestilow@ximian.com> 
+//          Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2002 Rachel Hestilow
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class Event : GLib.IWrapper {
+
+		IntPtr raw;
+
+		public Event(IntPtr raw) 
+		{
+			this.raw = raw;
+		}
+
+		public IntPtr Handle {
+			get { return raw; }
+		}
+		[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 { return new GLib.GType (gdk_event_get_type ()); }
+		}
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			public EventType type;
+			public IntPtr window;
+			public sbyte send_event;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (raw, typeof(NativeStruct)); }
+		}
+
+		public EventType Type {
+			get { return Native.type; }
+			set {
+				NativeStruct native = Native;
+				native.type = value;
+				Marshal.StructureToPtr (native, raw, false);
+			}
+		}
+
+		public Window Window {
+			get { return GLib.Object.GetObject (Native.window, false) as Window; }
+			set {
+				NativeStruct native = Native;
+				native.window = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, raw, false);
+			}
+		}
+
+		public bool SendEvent {
+			get { return Native.send_event != 0; }
+			set {
+				NativeStruct native = Native;
+				native.send_event = (sbyte) (value ? 1 : 0);
+				Marshal.StructureToPtr (native, raw, false);
+			}
+		}
+
+		public static Event New (IntPtr raw)
+		{
+			return GetEvent (raw);
+		}
+
+		public static Event GetEvent (IntPtr raw)
+		{
+			if (raw == IntPtr.Zero)
+				return null;
+
+			NativeStruct native = (NativeStruct) Marshal.PtrToStructure (raw, typeof(NativeStruct));
+			switch (native.type) {
+			case EventType.Expose:
+				return new EventExpose (raw);
+			case EventType.MotionNotify:
+				return new EventMotion (raw);
+			case EventType.ButtonPress:
+			case EventType.TwoButtonPress:
+			case EventType.ThreeButtonPress:
+			case EventType.ButtonRelease:
+				return new EventButton (raw);
+			case EventType.KeyPress:
+			case EventType.KeyRelease:
+				return new EventKey (raw);
+			case EventType.EnterNotify:
+			case EventType.LeaveNotify:
+				return new EventCrossing (raw);
+			case EventType.FocusChange:
+				return new EventFocus (raw);
+			case EventType.Configure:
+				return new EventConfigure (raw);
+			case EventType.PropertyNotify:
+				return new EventProperty (raw);
+			case EventType.SelectionClear:
+			case EventType.SelectionRequest:
+			case EventType.SelectionNotify:
+				return new EventSelection (raw);
+			case EventType.ProximityIn:
+			case EventType.ProximityOut:
+				return new EventProximity (raw);
+			case EventType.DragEnter:
+			case EventType.DragLeave:
+			case EventType.DragMotion:
+			case EventType.DragStatus:
+			case EventType.DropStart:
+			case EventType.DropFinished:
+				return new EventDND (raw);
+			case EventType.VisibilityNotify:
+				return new EventVisibility (raw);
+			case EventType.Scroll:
+				return new EventScroll (raw);
+			case EventType.WindowState:
+				return new EventWindowState (raw);
+			case EventType.Setting:
+				return new EventSetting (raw);
+			case EventType.OwnerChange:
+				return new EventOwnerChange (raw);
+			case EventType.GrabBroken:
+				return new EventGrabBroken (raw);
+			case EventType.Map:
+			case EventType.Unmap:
+			case EventType.Delete:
+			case EventType.Destroy:
+			default:
+				return new Gdk.Event (raw);
+			}
+		}
+	}
+}
+
+

GtkSharp/Source/Libs/GdkSharp/EventButton.cs

@@ -0,0 +1,141 @@
+// Gdk.EventButton.cs - Custom button event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventButton : Event {
+
+		public EventButton (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public uint time;
+			public double x;
+			public double y;
+			public IntPtr axes;
+			public uint state;
+			public uint button;
+			public IntPtr device;
+			public double x_root;
+			public double y_root;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public double[] Axes {
+			get {
+				double[] result = null;
+				IntPtr axes = Native.axes;
+				if (axes != IntPtr.Zero) {
+					result = new double [Device.NumAxes];
+					Marshal.Copy (axes, result, 0, result.Length);
+				}
+				return result;
+			}
+			set {
+				NativeStruct native = Native;
+				if (native.axes == IntPtr.Zero || value.Length != Device.NumAxes)
+					throw new InvalidOperationException ();
+				Marshal.Copy (value, 0, native.axes, value.Length);
+			}
+		}
+
+		public uint Button {
+			get { return Native.button; }
+			set {
+				NativeStruct native = Native;
+				native.button = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Device Device {
+			get { return GLib.Object.GetObject (Native.device, false) as Device; }
+			set {
+				NativeStruct native = Native;
+				native.device = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public ModifierType State {
+			get { return (ModifierType) Native.state; }
+			set {
+				NativeStruct native = Native;
+				native.state = (uint) value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double X {
+			get { return Native.x; }
+			set {
+				NativeStruct native = Native;
+				native.x = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double XRoot {
+			get { return Native.x_root; }
+			set {
+				NativeStruct native = Native;
+				native.x_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double Y {
+			get { return Native.y; }
+			set {
+				NativeStruct native = Native;
+				native.y = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double YRoot {
+			get { return Native.y_root; }
+			set {
+				NativeStruct native = Native;
+				native.y_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventConfigure.cs

@@ -0,0 +1,83 @@
+// Gdk.EventConfigure.cs - Custom configure event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventConfigure : Event {
+
+		public EventConfigure (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public int x;
+			public int y;
+			public int width;
+			public int height;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public int Height {
+			get { return Native.height; }
+			set {
+				NativeStruct native = Native;
+				native.height = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public int Width {
+			get { return Native.width; }
+			set {
+				NativeStruct native = Native;
+				native.width = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public int X {
+			get { return Native.x; }
+			set {
+				NativeStruct native = Native;
+				native.x = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public int Y {
+			get { return Native.y; }
+			set {
+				NativeStruct native = Native;
+				native.y = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventCrossing.cs

@@ -0,0 +1,143 @@
+// Gdk.EventCrossing.cs - Custom crossing event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventCrossing : Event {
+
+		public EventCrossing (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public IntPtr subwindow;
+			public uint time;
+			public double x;
+			public double y;
+			public double x_root;
+			public double y_root;
+			public CrossingMode mode;
+			public NotifyType detail;
+			public bool focus;
+			public uint state;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public NotifyType Detail {
+			get { return Native.detail; }
+			set {
+				NativeStruct native = Native;
+				native.detail = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public bool Focus {
+			get { return Native.focus; }
+			set {
+				NativeStruct native = Native;
+				native.focus = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public CrossingMode Mode {
+			get { return Native.mode; }
+			set {
+				NativeStruct native = Native;
+				native.mode = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public ModifierType State {
+			get { return (ModifierType) Native.state; }
+			set {
+				NativeStruct native = Native;
+				native.state = (uint) value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Window SubWindow {
+			get { return GLib.Object.GetObject (Native.subwindow, false) as Window; }
+			set {
+				NativeStruct native = Native;
+				native.subwindow = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double X {
+			get { return Native.x; }
+			set {
+				NativeStruct native = Native;
+				native.x = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double XRoot {
+			get { return Native.x_root; }
+			set {
+				NativeStruct native = Native;
+				native.x_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double Y {
+			get { return Native.y; }
+			set {
+				NativeStruct native = Native;
+				native.y = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double YRoot {
+			get { return Native.y_root; }
+			set {
+				NativeStruct native = Native;
+				native.y_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventDND.cs

@@ -0,0 +1,83 @@
+// Gdk.EventDND.cs - Custom dnd event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventDND : Event {
+
+		public EventDND (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public IntPtr context;
+			public uint time;
+			public short x_root;
+			public short y_root;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public DragContext Context {
+			get { return GLib.Object.GetObject (Native.context, false) as DragContext; }
+			set {
+				NativeStruct native = Native;
+				native.context = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public short XRoot {
+			get { return Native.x_root; }
+			set {
+				NativeStruct native = Native;
+				native.x_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public short YRoot {
+			get { return Native.y_root; }
+			set {
+				NativeStruct native = Native;
+				native.y_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventExpose.cs

@@ -0,0 +1,73 @@
+// Gdk.EventExpose.cs - Custom expose event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventExpose : Event {
+
+		public EventExpose (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public Rectangle area;
+			public IntPtr region;
+			public int count;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public Rectangle Area {
+			get { return Native.area; }
+			set {
+				NativeStruct native = Native;
+				native.area = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Cairo.Region Region {
+			get { return new Cairo.Region (Native.region); }
+			set {
+				NativeStruct native = Native;
+				native.region = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public int Count {
+			get { return Native.count; }
+			set {
+				NativeStruct native = Native;
+				native.count = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventFocus.cs

@@ -0,0 +1,53 @@
+// Gdk.EventFocus.cs - Custom focus event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventFocus : Event {
+
+		public EventFocus (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public short _in;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public bool In {
+			get { return Native._in != 0; }
+			set {
+				NativeStruct native = Native;
+				native._in = (short) (value ? 1 : 0);
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventGrabBroken.cs

@@ -0,0 +1,73 @@
+// Gdk.EventGrabBroken.cs - Custom GrabBroken event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2005-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventGrabBroken : Event {
+
+		public EventGrabBroken (IntPtr raw) : base (raw) {} 
+
+		[StructLayout(LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public bool keyboard;
+			public bool _implicit;
+			public IntPtr grab_window;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public bool Keyboard {
+			get { return Native.keyboard; }
+			set {
+				NativeStruct native = Native;
+				native.keyboard = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public bool Implicit {
+			get { return Native._implicit; }
+			set {
+				NativeStruct native = Native;
+				native._implicit = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Window GrabWindow {
+			get { return GLib.Object.GetObject(Native.grab_window, false) as Window; }
+			set {
+				NativeStruct native = Native;
+				native.grab_window = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventKey.cs

@@ -0,0 +1,99 @@
+// Gdk.EventKey.cs - Custom key event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventKey : Event {
+
+		public EventKey (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public uint time;
+			public uint state;
+			public uint keyval;
+			int length;
+			IntPtr _string;
+			public ushort hardware_keycode;
+			public byte group;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public byte Group {
+			get { return Native.group; }
+			set {
+				NativeStruct native = Native;
+				native.group = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public ushort HardwareKeycode {
+			get { return Native.hardware_keycode; }
+			set {
+				NativeStruct native = Native;
+				native.hardware_keycode = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Key Key {
+			get { return (Key) KeyValue; }
+		}
+
+		public uint KeyValue {
+			get { return Native.keyval; }
+			set {
+				NativeStruct native = Native;
+				native.keyval = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public ModifierType State {
+			get { return (ModifierType) Native.state; }
+			set {
+				NativeStruct native = Native;
+				native.state = (uint) value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventMotion.cs

@@ -0,0 +1,142 @@
+// Gdk.EventMotion.cs - Custom motion event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventMotion : Event {
+
+		public EventMotion (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public uint time;
+			public double x;
+			public double y;
+			public IntPtr axes;
+			public uint state;
+			public short is_hint;
+			public IntPtr device;
+			public double x_root;
+			public double y_root;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public double[] Axes {
+			get {
+				double[] result = null;
+				IntPtr axes = Native.axes;
+				if (axes != IntPtr.Zero) {
+					result = new double [Device.NumAxes];
+					Marshal.Copy (axes, result, 0, result.Length);
+				}
+				return result;
+			}
+			set {
+				NativeStruct native = Native;
+				if (native.axes == IntPtr.Zero || value.Length != Device.NumAxes)
+					throw new InvalidOperationException ();
+				Marshal.Copy (value, 0, native.axes, value.Length);
+			}
+		}
+
+		public Device Device {
+			get { return GLib.Object.GetObject (Native.device, false) as Device; }
+			set {
+				NativeStruct native = Native;
+				native.device = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public bool IsHint {
+			get { return Native.is_hint != 0; }
+			set {
+				NativeStruct native = Native;
+				native.is_hint = (short) (value ? 1 : 0);
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public ModifierType State {
+			get { return (ModifierType) Native.state; }
+			set {
+				NativeStruct native = Native;
+				native.state = (uint) value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double X {
+			get { return Native.x; }
+			set {
+				NativeStruct native = Native;
+				native.x = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double XRoot {
+			get { return Native.x_root; }
+			set {
+				NativeStruct native = Native;
+				native.x_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double Y {
+			get { return Native.y; }
+			set {
+				NativeStruct native = Native;
+				native.y = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double YRoot {
+			get { return Native.y_root; }
+			set {
+				NativeStruct native = Native;
+				native.y_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventOwnerChange.cs

@@ -0,0 +1,95 @@
+// Gdk.EventOwnerChange.cs - Custom OwnerChange event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2008-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventOwnerChange : Event {
+
+		public EventOwnerChange (IntPtr handle) : base (handle) {}
+
+		struct NativeStruct {
+			public Gdk.EventType type;
+			public IntPtr window;
+			public sbyte send_event;
+			public uint owner;
+			public Gdk.OwnerChange reason;
+			public IntPtr selection;
+			public uint time;
+			public uint selection_time;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct)); }
+		}
+
+		public uint Owner {
+			get { return Native.owner; }
+			set {
+				NativeStruct native = Native;
+				native.owner = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public OwnerChange Reason {
+			get { return Native.reason; }
+			set {
+				NativeStruct native = Native;
+				native.reason = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Gdk.Atom Selection {
+			get { 
+				IntPtr sel = Native.selection;
+				return sel == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (sel, typeof (Gdk.Atom), false);
+			}
+			set {
+				NativeStruct native = Native;
+				native.selection = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint SelectionTime {
+			get { return Native.selection_time; }
+			set {
+				NativeStruct native = Native;
+				native.selection_time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventProperty.cs

@@ -0,0 +1,73 @@
+// Gdk.EventProperty.cs - Custom property event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventProperty : Event {
+
+		public EventProperty (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public IntPtr atom;
+			public uint time;
+			public uint state;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public Atom Atom {
+			get { return GLib.Opaque.GetOpaque (Native.atom, typeof (Atom), false) as Atom; }
+			set {
+				NativeStruct native = Native;
+				native.atom = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public PropertyState State {
+			get { return (PropertyState) Native.state; }
+			set {
+				NativeStruct native = Native;
+				native.state = (uint) value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventProximity.cs

@@ -0,0 +1,63 @@
+// Gdk.EventProximity.cs - Custom proximity event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventProximity : Event {
+
+		public EventProximity (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public uint time;
+			public IntPtr device;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public Device Device {
+			get { return GLib.Object.GetObject (Native.device, false) as Device; }
+			set {
+				NativeStruct native = Native;
+				native.device = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventScroll.cs

@@ -0,0 +1,143 @@
+// Gdk.EventScroll.cs - Custom scroll event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventScroll : Event {
+
+		public EventScroll (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public uint time;
+			public double x;
+			public double y;
+			public uint state;
+			public ScrollDirection direction;
+			public IntPtr device;
+			public double x_root;
+			public double y_root;
+			public double delta_x;
+			public double delta_y;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public Device Device {
+			get { return GLib.Object.GetObject (Native.device, false) as Device; }
+			set {
+				NativeStruct native = Native;
+				native.device = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public ScrollDirection Direction {
+			get { return Native.direction; }
+			set {
+				NativeStruct native = Native;
+				native.direction = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public ModifierType State {
+			get { return (ModifierType) Native.state; }
+			set {
+				NativeStruct native = Native;
+				native.state = (uint) value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double X {
+			get { return Native.x; }
+			set {
+				NativeStruct native = Native;
+				native.x = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double XRoot {
+			get { return Native.x_root; }
+			set {
+				NativeStruct native = Native;
+				native.x_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double DeltaX {
+			get { return Native.delta_x; }
+			set {
+				NativeStruct native = Native;
+				native.delta_x = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double Y {
+			get { return Native.y; }
+			set {
+				NativeStruct native = Native;
+				native.y = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double YRoot {
+			get { return Native.y_root; }
+			set {
+				NativeStruct native = Native;
+				native.y_root = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public double DeltaY {
+			get { return Native.delta_y; }
+			set {
+				NativeStruct native = Native;
+				native.delta_y = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventSelection.cs

@@ -0,0 +1,93 @@
+// Gdk.EventSelection.cs - Custom selection event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventSelection : Event {
+
+		public EventSelection (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public IntPtr selection;
+			public IntPtr target;
+			public IntPtr property;
+			public uint time;
+			public uint requestor;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public Atom Property {
+			get { return GLib.Opaque.GetOpaque (Native.property, typeof (Atom), false) as Atom; }
+			set {
+				NativeStruct native = Native;
+				native.property = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Requestor {
+			get { return Native.requestor; }
+			set {
+				NativeStruct native = Native;
+				native.requestor = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Atom Selection {
+			get { return GLib.Opaque.GetOpaque (Native.selection, typeof (Atom), false) as Atom; }
+			set {
+				NativeStruct native = Native;
+				native.selection = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public Atom Target {
+			get { return GLib.Opaque.GetOpaque (Native.target, typeof (Atom), false) as Atom; }
+			set {
+				NativeStruct native = Native;
+				native.target = value == null ? IntPtr.Zero : value.Handle;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public uint Time {
+			get { return Native.time; }
+			set {
+				NativeStruct native = Native;
+				native.time = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventSetting.cs

@@ -0,0 +1,64 @@
+// Gdk.EventSetting.cs - Custom Setting event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventSetting : Event {
+
+		public EventSetting (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public SettingAction action;
+			public IntPtr name;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public SettingAction Action {
+			get { return Native.action; }
+			set {
+				NativeStruct native = Native;
+				native.action = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public string Name {
+			get { return GLib.Marshaller.Utf8PtrToString (Native.name); }
+			set {
+				NativeStruct native = Native;
+				GLib.Marshaller.Free (native.name);
+				native.name = GLib.Marshaller.StringToPtrGStrdup (value);
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventVisibility.cs

@@ -0,0 +1,53 @@
+// Gdk.EventVisibility.cs - Custom visibility event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventVisibility : Event {
+
+		public EventVisibility (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public VisibilityState state;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public VisibilityState State {
+			get { return Native.state; }
+			set {
+				NativeStruct native = Native;
+				native.state = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/EventWindowState.cs

@@ -0,0 +1,63 @@
+// Gdk.EventWindowState.cs - Custom WindowState event wrapper 
+//
+// Author:  Mike Kestner <mkestner@novell.com>
+//
+// Copyright (c) 2004-2009 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+
+namespace Gdk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class EventWindowState : Event {
+
+		public EventWindowState (IntPtr raw) : base (raw) {} 
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct NativeStruct {
+			EventType type;
+			IntPtr window;
+			sbyte send_event;
+			public WindowState changed_mask;
+			public WindowState new_window_state;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); }
+		}
+
+		public WindowState ChangedMask {
+			get { return Native.changed_mask; }
+			set {
+				NativeStruct native = Native;
+				native.changed_mask = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+
+		public WindowState NewWindowState {
+			get { return Native.new_window_state; }
+			set {
+				NativeStruct native = Native;
+				native.new_window_state = value;
+				Marshal.StructureToPtr (native, Handle, false);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/GdkSharp/GdkSharp-symbols.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<api>
+  <symbol type="alias" cname="Window" name="gulong" />
+  <symbol type="marshal" cname="GdkEvent" name="Gdk.Event" marshal_type="IntPtr" call_fmt="{0} == null ? IntPtr.Zero : {0}.Handle" from_fmt="Gdk.Event.GetEvent ({0})"/>
+  <symbol type="marshal" cname="GdkEventAny" name="Gdk.Event" marshal_type="IntPtr" call_fmt="{0}.Handle" from_fmt="Gdk.Event.GetEvent ({0})"/>
+  <symbol type="manual" cname="GdkEventButton" name="Gdk.EventButton"/>
+  <symbol type="manual" cname="GdkEventClient" name="Gdk.EventClient"/>
+  <symbol type="manual" cname="GdkEventConfigure" name="Gdk.EventConfigure"/>
+  <symbol type="manual" cname="GdkEventCrossing" name="Gdk.EventCrossing"/>
+  <symbol type="manual" cname="GdkEventDND" name="Gdk.EventDND"/>
+  <symbol type="manual" cname="GdkEventExpose" name="Gdk.EventExpose"/>
+  <symbol type="manual" cname="GdkEventFocus" name="Gdk.EventFocus"/>
+  <symbol type="manual" cname="GdkEventGrabBroken" name="Gdk.EventGrabBroken"/>
+  <symbol type="manual" cname="GdkEventKey" name="Gdk.EventKey"/>
+  <symbol type="manual" cname="GdkEventMotion" name="Gdk.EventMotion"/>
+  <symbol type="marshal" cname="GdkEventNoExpose" name="Gdk.Event" marshal_type="IntPtr" call_fmt="{0}.Handle" from_fmt="Gdk.Event.GetEvent ({0})"/>
+  <symbol type="manual" cname="GdkEventProperty" name="Gdk.EventProperty"/>
+  <symbol type="manual" cname="GdkEventProximity" name="Gdk.EventProximity"/>
+  <symbol type="manual" cname="GdkEventScroll" name="Gdk.EventScroll"/>
+  <symbol type="manual" cname="GdkEventSelection" name="Gdk.EventSelection"/>
+  <symbol type="manual" cname="GdkEventSetting" name="Gdk.EventSetting"/>
+  <symbol type="manual" cname="GdkEventOwnerChange" name="Gdk.EventOwnerChange"/>
+  <symbol type="manual" cname="GdkEventVisibility" name="Gdk.EventVisibility"/>
+  <symbol type="manual" cname="GdkEventWindowState" name="Gdk.EventWindowState"/>
+  <symbol type="simple" cname="GdkKey" name="Gdk.Key" default_value="Gdk.Key.VoidSymbol"/>
+  <symbol type="struct" cname="GdkRectangle" name="Gdk.Rectangle"/>
+</api>
+

GtkSharp/Source/Libs/GdkSharp/GdkSharp.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Description>GdkSharp is a C# wrapper for the Gdk library.</Description>
+    <PackageTags>gdk;gdksharp;gdk-sharp;wrapper</PackageTags>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <Compile Include="..\Shared\*.cs">
+      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GLibSharp\GLibSharp.csproj">
+      <Name>GLibSharp</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\GioSharp\GioSharp.csproj">
+      <Name>GioSharp</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\CairoSharp\CairoSharp.csproj">
+      <Name>CairoSharp</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\PangoSharp\PangoSharp.csproj">
+      <Name>PangoSharp</Name>
+    </ProjectReference>
+  </ItemGroup>
+
+</Project>

GtkSharp/Source/Libs/GdkSharp/GdkSharp.metadata

@@ -0,0 +1,200 @@
+<?xml version="1.0"?>
+<metadata>
+  <attr path="/api/namespace/boxed[@cname='GdkColor']" name="nohash">true</attr>
+  <attr path="/api/namespace/boxed[@cname='GdkColor']/method[@name='Copy']" name="hidden">1</attr>
+  <attr path="/api/namespace/boxed[@cname='GdkColor']/method[@name='Free']" name="hidden">1</attr>
+  <attr path="/api/namespace/boxed[@cname='GdkColor']/method[@name='Hash']" name="hidden">1</attr>
+  <attr path="/api/namespace/boxed[@cname='GdkColor']/method[@name='Parse']/return-type" name="type">gboolean</attr>
+  <attr path="/api/namespace/boxed[@cname='GdkColor']/method[@name='Parse']/*/*[@type='GdkColor*']" name="pass_as">ref</attr>
+  <attr path="/api/namespace/boxed[@cname='GdkColor']/method[@name='ToString']" name="hidden">1</attr>
+  <attr path="/api/namespace/boxed[@cname='GdkPixbufFormat']/method[@cname='gdk_pixbuf_format_is_disabled']" name="name">GetDisabled</attr> 
+  <attr path="/api/namespace/boxed[@cname='GdkPixbufFormat']/method[@name='GetExtensions']/return-type" name="null_term_array">1</attr> 
+  <attr path="/api/namespace/boxed[@cname='GdkPixbufFormat']/method[@name='GetMimeTypes']/return-type" name="null_term_array">1</attr> 
+  <attr path="/api/namespace/callback[@cname='GdkPixbufDestroyNotify']/*/*[@type='guchar*']" name="array">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkCairo_']" name="name">CairoHelper</attr>
+  <attr path="/api/namespace/class[@cname='GdkCairo_']/method[@name='Create']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/class[@cname='GdkCairo_']/method[@name='GetClipRectangle']/parameters/parameter[@name='rect']" name="pass_as">out</attr>
+  <attr path="/api/namespace/class[@cname='GdkDrag_']/method[@name='Begin']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkDrag_']/method[@name='FindWindowForScreen']/*/*[@name='dest_window']" name="pass_as">out</attr>
+  <attr path="/api/namespace/class[@cname='GdkEvent_']" name="name">EventHelper</attr>
+  <attr path="/api/namespace/class[@cname='GdkKeyval_']/method[@name='Name']/return-type" name="type">const-gchar*</attr>
+  <attr path="/api/namespace/class[@cname='GdkGlobal']/method[@name='AddOptionEntriesLibgtkOnly']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkGlobal']/method[@name='InitCheck']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkGlobal']/method[@name='ListVisuals']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkGlobal']/method[@name='ParseArgs']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkGlobal']/method[@name='TextPropertyToUtf8ListForDisplay']" name="hidden">1</attr>
+  <move-node path="/api/namespace/class[@cname='GdkNotify_']/method">/api/namespace/class[@cname='GdkGlobal']</move-node>
+  <attr path="/api/namespace/class[@cname='GdkNotify_']" name="hidden">1</attr>
+  <attr path="/api/namespace/class/method[@cname='gdk_notify_startup_complete']" name="name">NotifyStartupComplete</attr>
+  <attr path="/api/namespace/class[@cname='GdkPango_']" name="name">PangoHelper</attr>
+  <attr path="/api/namespace/class[@cname='GdkProperty_']/method[@name='Get']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkProperty_']/method[@name='Change']/*/*[@name='data']" name="array">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkQuery_']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkSelection_']/method[@name='PropertyGet']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkThreads_']/method[@cname='gdk_threads_add_idle']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkThreads_']/method[@cname='gdk_threads_add_idle_full']" name="name">AddIdle</attr>
+  <attr path="/api/namespace/class[@cname='GdkThreads_']/method[@cname='gdk_threads_add_timeout']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkThreads_']/method[@cname='gdk_threads_add_timeout_full']" name="name">AddTimeout</attr>
+  <attr path="/api/namespace/class[@cname='GdkThreads_']/method[@cname='gdk_threads_add_timeout_seconds']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='GdkThreads_']/method[@cname='gdk_threads_add_timeout_seconds_full']" name="name">AddTimeoutSeconds</attr>
+  <attr path="/api/namespace/class[@cname='GdkThreads_']/method[@cname='gdk_threads_set_lock_functions']" name="hidden">1</attr>
+  <add-node path="/api/namespace/enum[@cname='GdkModifierType']"><member name="None" value="0" /></add-node>
+  <attr path="/api/namespace/enum[@cname='GdkModifierType']/member[@name='ModifierMask']" name="value">ReleaseMask | 0x1fff</attr>
+  <attr path="/api/namespace/enum[@cname='GdkWindowWindowClass']/member[@name='Output']" name="name">InputOutput</attr>
+  <attr path="/api/namespace/enum[@cname='GdkWindowWindowClass']/member[@name='Only']" name="name">InputOnly</attr>
+  <attr path="/api/namespace/enum[@cname='GdkSeatCapabilities']/member[@name='AllPointing']" name="value">Pointer | Touch | TabletStylus</attr>
+  <attr path="/api/namespace/enum[@cname='GdkSeatCapabilities']/member[@name='All']" name="value">AllPointing | Keyboard</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAnchorHints']/member[@name='Flip']" name="value">FlipX | FlipY</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAnchorHints']/member[@name='Slide']" name="value">SlideX | SlideY</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAnchorHints']/member[@name='Resize']" name="value">ResizeX | ResizeY</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='X']" name="value">AxisUse.X</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Y']" name="value">AxisUse.Y</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Pressure']" name="value">AxisUse.Pressure</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Xtilt']" name="value">AxisUse.Xtilt</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Ytilt']" name="value">AxisUse.Ytilt</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Wheel']" name="value">AxisUse.Wheel</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Distance']" name="value">AxisUse.Distance</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Rotation']" name="value">AxisUse.Rotation</attr>
+  <attr path="/api/namespace/enum[@cname='GdkAxisFlags']/member[@name='Slider']" name="value">AxisUse.Slider</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='GetAxis']/*/*[@name='axes']" name="array">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='FreeHistory']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='GetHistory']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='ListAxes']/return-type" name="element_type">GdkAtom*</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='ListAxes']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='ListAxes']/return-type" name="elements_owned">false</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='ListSlaveDevices']/return-type" name="element_type">GdkDevice*</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='ListSlaveDevices']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@name='ListSlaveDevices']/return-type" name="elements_owned">false</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/method[@cname='gdk_device_get_n_axes']" name="name">GetNumAxes</attr>
+  <attr path="/api/namespace/object[@cname='GdkDevice']/property[@cname='n-axes']" name="name">NumAxes</attr>
+  <attr path="/api/namespace/object[@cname='GdkDeviceManager']/method[@name='ListDevices']/return-type" name="element_type">GdkDevice*</attr>
+  <attr path="/api/namespace/object[@cname='GdkDeviceManager']/method[@name='ListDevices']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkDeviceManager']/method[@name='ListDevices']/return-type" name="elements_owned">false</attr>
+  <attr path="/api/namespace/object[@cname='GdkDeviceManager']/virtual_method[@name='ListDevices']/return-type" name="element_type">GdkDevice*</attr>
+  <attr path="/api/namespace/object[@cname='GdkDeviceManager']/virtual_method[@name='ListDevices']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkDeviceManager']/virtual_method[@name='ListDevices']/return-type" name="elements_owned">false</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='GetPointer']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='ListDevices']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='ListSeats']/return-type" name="element_type">GdkSeat*</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='ListSeats']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='ListSeats']/return-type" name="elements_owned">false</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='SupportsComposite']" name="name">GetSupportsComposite</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='SupportsInputShapes']" name="name">GetSupportsInputShapes</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplay']/method[@name='SupportsShapes']" name="name">GetSupportsShapes</attr>
+  <attr path="/api/namespace/object[@cname='GdkDisplayManager']/method[@name='ListDisplays']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkDragContext']/method[@name='ListTargets']/return-type" name="element_type">GdkAtom*</attr>
+  <attr path="/api/namespace/object[@cname='GdkKeymap']/method[@name='GetEntriesForKeycode']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkKeymap']/method[@name='GetEntriesForKeyval']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkMonitor']/method[@name='GetGeometry']/*/*[@type='GdkRectangle*']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkMonitor']/method[@name='GetWorkarea']/*/*[@type='GdkRectangle*']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_data']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_file']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_file_utf8']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_file_at_scale']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_file_at_scale_utf8']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_file_at_size']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_file_at_size_utf8']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_inline']/*/*[@name='data']" name="array">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_resource']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_resource_at_scale']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/constructor[@cname='gdk_pixbuf_new_from_xpm_data']/*/*[@name='data']" name="array">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='AddAlpha']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='ApplyEmbeddedOrientation']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='CompositeColorSimple']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='Flip']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='GetFormats']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='GetPixels']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='Save']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='Savev']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='SavevUtf8']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='SaveToBuffer']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='SaveToBufferv']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='SaveToCallback']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='SaveToCallbackv']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='SaveToStream']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='SaveToStreamv']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='ScaleSimple']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/method[@name='RotateSimple']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/property[@name='Pixels']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/property" name="readable">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/property" name="writeable">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbuf']/property" name="construct-only">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbufAnimation']/constructor[@cname='gdk_pixbuf_animation_new_from_file']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbufAnimation']/constructor[@cname='gdk_pixbuf_animation_new_from_file_utf8']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbufAnimation']/constructor[@cname='gdk_pixbuf_animation_new_from_resource']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkPixbufLoader']/method[@name='Write']/*/*[@name='buf']" name="array">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='GetFontOptions']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='GetMonitorGeometry']/*/*[@type='GdkRectangle*']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='GetMonitorWorkarea']/*/*[@type='GdkRectangle*']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='GetToplevelWindows']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='Height']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='HeightMm']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='ListVisuals']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='SetFontOptions']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='Width']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='WidthMm']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='GetWindowStack']/return-type" name="element_type">GdkWindow*</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='GetWindowStack']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/method[@name='GetWindowStack']/return-type" name="elements_owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/virtual_method[@name='GetWindowStack']/return-type" name="element_type">GdkWindow*</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/virtual_method[@name='GetWindowStack']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkScreen']/virtual_method[@name='GetWindowStack']/return-type" name="elements_owned">true</attr>
+  <remove-node path="/api/namespace/object[@cname='GdkScreen']/class_struct/signal[@vm='size_changed']" />
+  <remove-node path="/api/namespace/object[@cname='GdkScreen']/class_struct/signal[@vm='composited_changed']" />
+  <remove-node path="/api/namespace/object[@cname='GdkScreen']/class_struct/signal[@vm='monitors_changed']" />
+  <add-node path="/api/namespace/object[@cname='GdkScreen']/class_struct"><method signal_vm="size_changed" /></add-node>
+  <add-node path="/api/namespace/object[@cname='GdkScreen']/class_struct"><method signal_vm="composited_changed" /></add-node>
+  <add-node path="/api/namespace/object[@cname='GdkScreen']/class_struct"><method signal_vm="monitors_changed" /></add-node>
+  <attr path="/api/namespace/object[@cname='GdkSeat']/method[@name='GetSlaves']/return-type" name="element_type">GdkDevice*</attr>
+  <attr path="/api/namespace/object[@cname='GdkSeat']/method[@name='GetSlaves']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkSeat']/method[@name='GetSlaves']/return-type" name="elements_owned">false</attr>
+  <attr path="/api/namespace/object[@cname='GdkSeat']/virtual_method[@name='GetSlaves']/return-type" name="element_type">GdkDevice*</attr>
+  <attr path="/api/namespace/object[@cname='GdkSeat']/virtual_method[@name='GetSlaves']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='GdkSeat']/virtual_method[@name='GetSlaves']/return-type" name="elements_owned">false</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='AddFilter']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='Destroy']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='FreezeToplevelUpdatesLibgtkOnly']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='GetChildren']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='GetFrameExtents']/*/*[@name='rect']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='GetOrigin']/*/*[@type='gint*']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='GetPointer']/*/*[@type='gint*']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='GetPointer']/*/*[@type='GdkModifierType*']" name="pass_as">out</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='GetBackgroundPattern']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='InvalidateMaybeRecurse']/*/*[@name='child_func']" name="scope">call</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='PeekChildren']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='RemoveFilter']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='SetBackgroundPattern']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='SetIconList']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='ThawToplevelUpdatesLibgtkOnly']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@name='GetUserData']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='GdkWindow']/method[@cname='gdk_window_set_user_data']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkAtom']/method[@name='Name']" name="name">GetName</attr>
+  <attr path="/api/namespace/struct[@cname='GdkAtom']/method[@name='InternStaticString']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkColorInfo']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkDeviceKey']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventAny']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventButton']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventConfigure']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventCrossing']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventDND']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventExpose']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventFocus']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventGrabBroken']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventKey']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventMotion']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventOwnerChange']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventProperty']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventProximity']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventScroll']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventSelection']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventSetting']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventVisibility']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkEventWindowState']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='GdkSeatDefault']" name="parent">GdkSeat</attr>
+  <attr path="/api/namespace/struct[@cname='GdkTimeCoord']/field[@cname='axes']" name="array_len">128</attr>
+  <remove-node path="/api/namespace/object[@cname='GdkCursor']/method[@name='Ref']" />
+  <remove-node path="/api/namespace/object[@cname='GdkCursor']/method[@name='Unref']" />
+  <remove-node path="/api/namespace/alias[@name='Rectangle']" />
+  <remove-node path="/api/namespace/class[@cname='GdkRectangle_']" />
+</metadata>
+

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
+}