no more submodule

GtkSharp/Source/Libs/AtkSharp/AtkSharp.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Description>AtkSharp is a C# wrapper for the Atk library.</Description>
+    <PackageTags>atk;atksharp;atk-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>
+  </ItemGroup>
+
+</Project>

GtkSharp/Source/Libs/AtkSharp/AtkSharp.metadata

@@ -0,0 +1,44 @@
+<?xml version="1.0"?>
+<metadata>
+  <attr path="/api/namespace/class[@cname='AtkGlobal']/method[@name='AddGlobalEventListener']" name="hidden">1</attr>
+  <attr path="/api/namespace/class[@cname='AtkState_']" name="name">StateManager</attr>
+  <attr path="/api/namespace/interface[@cname='AtkComponent']/*[@name='RefAccessibleAtPoint']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/method[@name='GetAttributes']/return-type" name="element_type">AtkAttribute*</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/method[@name='GetDocument']" name="name">GetTheDocument</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/virtual_method[@name='GetDocument']" name="name">GetTheDocument</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/virtual_method[@cname='get_document_attributes']/return-type" name="element_type">AtkAttribute*</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/virtual_method[@name='GetDocumentAttributes']" name="name">GetAttributes</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/virtual_method[@name='GetDocumentAttributeValue']" name="name">GetAttributeValue</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/virtual_method[@name='GetDocumentLocale']" name="name">GetLocale</attr>
+  <attr path="/api/namespace/interface[@cname='AtkDocument']/virtual_method[@name='SetDocumentAttribute']" name="name">SetAttributeValue</attr>
+  <attr path="/api/namespace/interface[@cname='AtkEditableText']/method[@name='InsertText']/*/*[@name='position']" name="pass_as">ref</attr>
+  <attr path="/api/namespace/interface[@cname='AtkEditableText']/virtual_method[@name='InsertText']/*/*[@name='position']" name="pass_as">ref</attr>
+  <attr path="/api/namespace/interface[@cname='AtkImplementor']/*[@name='RefAccessible']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/interface[@cname='AtkSelection']/*[@name='RefSelection']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/interface[@cname='AtkTable']/*[@name='RefAt']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/interface[@cname='AtkText']/*[@name='GetRangeExtents']/*/*[@name='rect']" name="pass_as">out</attr>
+  <attr path="/api/namespace/interface[@cname='AtkValue']/*[@name='GetCurrentValue']/*/*[@name='value']" name="pass_as">ref</attr>
+  <attr path="/api/namespace/interface[@cname='AtkValue']/*[@name='GetMaximumValue']/*/*[@name='value']" name="pass_as">ref</attr>
+  <attr path="/api/namespace/interface[@cname='AtkValue']/*[@name='GetMinimumValue']/*/*[@name='value']" name="pass_as">ref</attr>
+  <attr path="/api/namespace/interface[@cname='AtkValue']/*[@name='GetMinimumIncrement']/*/*[@name='value']" name="pass_as">ref</attr>
+  <attr path="/api/namespace/object[@cname='AtkObject']/method[@name='GetAttributes']/return-type" name="element_type">AtkAttribute*</attr>
+  <attr path="/api/namespace/object[@cname='AtkObject']/method[@name='RefAccessibleChild']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='AtkObject']/method[@name='RefRelationSet']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='AtkObject']/method[@name='RefStateSet']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='AtkObject']/virtual_method[@cname='ref_child']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='AtkObject']/virtual_method[@cname='ref_state_set']/return-type" name="owned">true</attr>
+  <attr path="/api/namespace/object[@cname='AtkObjectFactory']/virtual_method" name="override_in">declaring_class</attr>
+  <attr path="/api/namespace/object[@cname='AtkRelation']/constructor[@cname='atk_relation_new']/*/*[@name='targets']" name="array">1</attr>
+  <attr path="/api/namespace/object[@cname='AtkRelation']/method[@name='GetTarget']/return-type" name="element_type">AtkObject*</attr>
+  <attr path="/api/namespace/object[@cname='AtkUtil']/virtual_method" name="override_in">declaring_class</attr>
+  <attr path="/api/namespace/object[@cname='AtkUtil']/virtual_method[@name='AddGlobalEventListener']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='AtkUtil']/virtual_method[@name='RemoveGlobalEventListener']" name="hidden">1</attr>
+  <attr path="/api/namespace/object[@cname='AtkUtil']/virtual_method[@name='RemoveKeyEventListener']" name="hidden">1</attr>
+  <attr path="/api/namespace/struct[@cname='AtkAttribute']/method[@name='SetFree']" name="hidden">1</attr>
+  <attr path="/api/namespace/interface[@cname='AtkText']/*[@name='GetRunAttributes']/return-type" name="element_type">AtkAttribute*</attr>
+  <attr path="/api/namespace/interface[@cname='AtkText']/*[@name='GetDefaultAttributes']/return-type" name="element_type">AtkAttribute*</attr>
+
+  <!-- below is a workaround for an ABI break in recent ATK: https://git.gnome.org/browse/atk/commit/?id=b1f70e81ef1d7287dcb2cafa9a115ff5752ece55 -->
+  <remove-node path="/api/namespace/interface//field[@cname='pad1' or @cname='pad2' or @cname='pad3' or @cname='pad4']" />
+
+</metadata>

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ActionAdapter.cs

@@ -0,0 +1,325 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ActionAdapter : GLib.GInterfaceAdapter, Atk.IAction {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkActionIface {
+			public DoActionNativeDelegate DoAction;
+			public GetNActionsNativeDelegate GetNActions;
+			public GetDescriptionNativeDelegate GetDescription;
+			public GetNameNativeDelegate GetName;
+			public GetKeybindingNativeDelegate GetKeybinding;
+			public SetDescriptionNativeDelegate SetDescription;
+			public GetLocalizedNameNativeDelegate GetLocalizedName;
+		}
+
+		static AtkActionIface iface;
+
+		static ActionAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (ActionAdapter));
+			iface.DoAction = new DoActionNativeDelegate (DoAction_cb);
+			iface.GetNActions = new GetNActionsNativeDelegate (GetNActions_cb);
+			iface.GetDescription = new GetDescriptionNativeDelegate (GetDescription_cb);
+			iface.GetName = new GetNameNativeDelegate (GetName_cb);
+			iface.GetKeybinding = new GetKeybindingNativeDelegate (GetKeybinding_cb);
+			iface.SetDescription = new SetDescriptionNativeDelegate (SetDescription_cb);
+			iface.GetLocalizedName = new GetLocalizedNameNativeDelegate (GetLocalizedName_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool DoActionNativeDelegate (IntPtr inst, int i);
+
+		static bool DoAction_cb (IntPtr inst, int i)
+		{
+			try {
+				IActionImplementor __obj = GLib.Object.GetObject (inst, false) as IActionImplementor;
+				bool __result;
+				__result = __obj.DoAction (i);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetNActionsNativeDelegate (IntPtr inst);
+
+		static int GetNActions_cb (IntPtr inst)
+		{
+			try {
+				IActionImplementor __obj = GLib.Object.GetObject (inst, false) as IActionImplementor;
+				int __result;
+				__result = __obj.NActions;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetDescriptionNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr GetDescription_cb (IntPtr inst, int i)
+		{
+			try {
+				IActionImplementor __obj = GLib.Object.GetObject (inst, false) as IActionImplementor;
+				string __result;
+				__result = __obj.GetDescription (i);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetNameNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr GetName_cb (IntPtr inst, int i)
+		{
+			try {
+				IActionImplementor __obj = GLib.Object.GetObject (inst, false) as IActionImplementor;
+				string __result;
+				__result = __obj.GetName (i);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetKeybindingNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr GetKeybinding_cb (IntPtr inst, int i)
+		{
+			try {
+				IActionImplementor __obj = GLib.Object.GetObject (inst, false) as IActionImplementor;
+				string __result;
+				__result = __obj.GetKeybinding (i);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetDescriptionNativeDelegate (IntPtr inst, int i, IntPtr desc);
+
+		static bool SetDescription_cb (IntPtr inst, int i, IntPtr desc)
+		{
+			try {
+				IActionImplementor __obj = GLib.Object.GetObject (inst, false) as IActionImplementor;
+				bool __result;
+				__result = __obj.SetDescription (i, GLib.Marshaller.Utf8PtrToString (desc));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetLocalizedNameNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr GetLocalizedName_cb (IntPtr inst, int i)
+		{
+			try {
+				IActionImplementor __obj = GLib.Object.GetObject (inst, false) as IActionImplementor;
+				string __result;
+				__result = __obj.GetLocalizedName (i);
+				return GLib.Marshaller.StringToPtrGStrdup(__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);
+			AtkActionIface native_iface = (AtkActionIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkActionIface));
+			native_iface.DoAction = iface.DoAction;
+			native_iface.GetNActions = iface.GetNActions;
+			native_iface.GetDescription = iface.GetDescription;
+			native_iface.GetName = iface.GetName;
+			native_iface.GetKeybinding = iface.GetKeybinding;
+			native_iface.SetDescription = iface.SetDescription;
+			native_iface.GetLocalizedName = iface.GetLocalizedName;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public ActionAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public ActionAdapter (IActionImplementor 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 ActionAdapter (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_atk_action_get_type();
+		static d_atk_action_get_type atk_action_get_type = FuncLoader.LoadFunction<d_atk_action_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_action_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 IAction GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IAction GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IActionImplementor)
+				return new ActionAdapter (obj as IActionImplementor);
+			else if (obj as IAction == null)
+				return new ActionAdapter (obj.Handle);
+			else
+				return obj as IAction;
+		}
+
+		public IActionImplementor Implementor {
+			get {
+				return implementor as IActionImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_action_do_action(IntPtr raw, int i);
+		static d_atk_action_do_action atk_action_do_action = FuncLoader.LoadFunction<d_atk_action_do_action>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_do_action"));
+
+		public bool DoAction(int i) {
+			bool raw_ret = atk_action_do_action(Handle, i);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_description(IntPtr raw, int i);
+		static d_atk_action_get_description atk_action_get_description = FuncLoader.LoadFunction<d_atk_action_get_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_description"));
+
+		public string GetDescription(int i) {
+			IntPtr raw_ret = atk_action_get_description(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_keybinding(IntPtr raw, int i);
+		static d_atk_action_get_keybinding atk_action_get_keybinding = FuncLoader.LoadFunction<d_atk_action_get_keybinding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_keybinding"));
+
+		public string GetKeybinding(int i) {
+			IntPtr raw_ret = atk_action_get_keybinding(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_localized_name(IntPtr raw, int i);
+		static d_atk_action_get_localized_name atk_action_get_localized_name = FuncLoader.LoadFunction<d_atk_action_get_localized_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_localized_name"));
+
+		public string GetLocalizedName(int i) {
+			IntPtr raw_ret = atk_action_get_localized_name(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_action_get_n_actions(IntPtr raw);
+		static d_atk_action_get_n_actions atk_action_get_n_actions = FuncLoader.LoadFunction<d_atk_action_get_n_actions>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_n_actions"));
+
+		public int NActions { 
+			get {
+				int raw_ret = atk_action_get_n_actions(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_name(IntPtr raw, int i);
+		static d_atk_action_get_name atk_action_get_name = FuncLoader.LoadFunction<d_atk_action_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_name"));
+
+		public string GetName(int i) {
+			IntPtr raw_ret = atk_action_get_name(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_action_set_description(IntPtr raw, int i, IntPtr desc);
+		static d_atk_action_set_description atk_action_set_description = FuncLoader.LoadFunction<d_atk_action_set_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_set_description"));
+
+		public bool SetDescription(int i, string desc) {
+			IntPtr native_desc = GLib.Marshaller.StringToPtrGStrdup (desc);
+			bool raw_ret = atk_action_set_description(Handle, i, native_desc);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_desc);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ActiveDescendantChangedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/AtkSharp.EventListenerInitNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace AtkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void EventListenerInitNative();
+
+	internal class EventListenerInitInvoker {
+
+		EventListenerInitNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~EventListenerInitInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal EventListenerInitInvoker (EventListenerInitNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal EventListenerInitInvoker (EventListenerInitNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal EventListenerInitInvoker (EventListenerInitNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Atk.EventListenerInit Handler {
+			get {
+				return new Atk.EventListenerInit(InvokeNative);
+			}
+		}
+
+		void InvokeNative ()
+		{
+			native_cb ();
+		}
+	}
+
+	internal class EventListenerInitWrapper {
+
+		public void NativeCallback ()
+		{
+			try {
+				managed ();
+				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 EventListenerInitNative NativeDelegate;
+		Atk.EventListenerInit managed;
+
+		public EventListenerInitWrapper (Atk.EventListenerInit managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new EventListenerInitNative (NativeCallback);
+		}
+
+		public static Atk.EventListenerInit GetManagedDelegate (EventListenerInitNative native)
+		{
+			if (native == null)
+				return null;
+			EventListenerInitWrapper wrapper = (EventListenerInitWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/AtkSharp.EventListenerNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace AtkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void EventListenerNative(IntPtr obj);
+
+	internal class EventListenerInvoker {
+
+		EventListenerNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~EventListenerInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal EventListenerInvoker (EventListenerNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal EventListenerInvoker (EventListenerNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal EventListenerInvoker (EventListenerNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Atk.EventListener Handler {
+			get {
+				return new Atk.EventListener(InvokeNative);
+			}
+		}
+
+		void InvokeNative (Atk.Object obj)
+		{
+			native_cb (obj == null ? IntPtr.Zero : obj.Handle);
+		}
+	}
+
+	internal class EventListenerWrapper {
+
+		public void NativeCallback (IntPtr obj)
+		{
+			try {
+				managed (GLib.Object.GetObject(obj) as Atk.Object);
+				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 EventListenerNative NativeDelegate;
+		Atk.EventListener managed;
+
+		public EventListenerWrapper (Atk.EventListener managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new EventListenerNative (NativeCallback);
+		}
+
+		public static Atk.EventListener GetManagedDelegate (EventListenerNative native)
+		{
+			if (native == null)
+				return null;
+			EventListenerWrapper wrapper = (EventListenerWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/AtkSharp.FocusHandlerNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace AtkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void FocusHandlerNative(IntPtr objekt, bool focus_in);
+
+	internal class FocusHandlerInvoker {
+
+		FocusHandlerNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FocusHandlerInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FocusHandlerInvoker (FocusHandlerNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FocusHandlerInvoker (FocusHandlerNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FocusHandlerInvoker (FocusHandlerNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Atk.FocusHandler Handler {
+			get {
+				return new Atk.FocusHandler(InvokeNative);
+			}
+		}
+
+		void InvokeNative (Atk.Object objekt, bool focus_in)
+		{
+			native_cb (objekt == null ? IntPtr.Zero : objekt.Handle, focus_in);
+		}
+	}
+
+	internal class FocusHandlerWrapper {
+
+		public void NativeCallback (IntPtr objekt, bool focus_in)
+		{
+			try {
+				managed (GLib.Object.GetObject(objekt) as Atk.Object, focus_in);
+				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 FocusHandlerNative NativeDelegate;
+		Atk.FocusHandler managed;
+
+		public FocusHandlerWrapper (Atk.FocusHandler managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FocusHandlerNative (NativeCallback);
+		}
+
+		public static Atk.FocusHandler GetManagedDelegate (FocusHandlerNative native)
+		{
+			if (native == null)
+				return null;
+			FocusHandlerWrapper wrapper = (FocusHandlerWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/AtkSharp.FunctionNative.cs

@@ -0,0 +1,94 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace AtkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate bool FunctionNative(IntPtr user_data);
+
+	internal class FunctionInvoker {
+
+		FunctionNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FunctionInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FunctionInvoker (FunctionNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FunctionInvoker (FunctionNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FunctionInvoker (FunctionNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Atk.Function Handler {
+			get {
+				return new Atk.Function(InvokeNative);
+			}
+		}
+
+		bool InvokeNative ()
+		{
+			bool __result = native_cb (__data);
+			return __result;
+		}
+	}
+
+	internal class FunctionWrapper {
+
+		public bool NativeCallback (IntPtr user_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 FunctionNative NativeDelegate;
+		Atk.Function managed;
+
+		public FunctionWrapper (Atk.Function managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FunctionNative (NativeCallback);
+		}
+
+		public static Atk.Function GetManagedDelegate (FunctionNative native)
+		{
+			if (native == null)
+				return null;
+			FunctionWrapper wrapper = (FunctionWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/AtkSharp.KeySnoopFuncNative.cs

@@ -0,0 +1,97 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace AtkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate int KeySnoopFuncNative(IntPtr evnt, IntPtr user_data);
+
+	internal class KeySnoopFuncInvoker {
+
+		KeySnoopFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~KeySnoopFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal KeySnoopFuncInvoker (KeySnoopFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal KeySnoopFuncInvoker (KeySnoopFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal KeySnoopFuncInvoker (KeySnoopFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Atk.KeySnoopFunc Handler {
+			get {
+				return new Atk.KeySnoopFunc(InvokeNative);
+			}
+		}
+
+		int InvokeNative (Atk.KeyEventStruct evnt)
+		{
+			IntPtr native_evnt = GLib.Marshaller.StructureToPtrAlloc (evnt);
+			int __result = native_cb (native_evnt, __data);
+			Marshal.FreeHGlobal (native_evnt);
+			return __result;
+		}
+	}
+
+	internal class KeySnoopFuncWrapper {
+
+		public int NativeCallback (IntPtr evnt, IntPtr user_data)
+		{
+			try {
+				int __ret = managed (Atk.KeyEventStruct.New (evnt));
+				if (release_on_call)
+					gch.Free ();
+				return __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 KeySnoopFuncNative NativeDelegate;
+		Atk.KeySnoopFunc managed;
+
+		public KeySnoopFuncWrapper (Atk.KeySnoopFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new KeySnoopFuncNative (NativeCallback);
+		}
+
+		public static Atk.KeySnoopFunc GetManagedDelegate (KeySnoopFuncNative native)
+		{
+			if (native == null)
+				return null;
+			KeySnoopFuncWrapper wrapper = (KeySnoopFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/AtkSharp.PropertyChangeHandlerNative.cs

@@ -0,0 +1,93 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace AtkSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void PropertyChangeHandlerNative(IntPtr obj, IntPtr vals);
+
+	internal class PropertyChangeHandlerInvoker {
+
+		PropertyChangeHandlerNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~PropertyChangeHandlerInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal PropertyChangeHandlerInvoker (PropertyChangeHandlerNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal PropertyChangeHandlerInvoker (PropertyChangeHandlerNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal PropertyChangeHandlerInvoker (PropertyChangeHandlerNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal Atk.PropertyChangeHandler Handler {
+			get {
+				return new Atk.PropertyChangeHandler(InvokeNative);
+			}
+		}
+
+		void InvokeNative (Atk.Object obj, Atk.PropertyValues vals)
+		{
+			IntPtr native_vals = GLib.Marshaller.StructureToPtrAlloc (vals);
+			native_cb (obj == null ? IntPtr.Zero : obj.Handle, native_vals);
+			Marshal.FreeHGlobal (native_vals);
+		}
+	}
+
+	internal class PropertyChangeHandlerWrapper {
+
+		public void NativeCallback (IntPtr obj, IntPtr vals)
+		{
+			try {
+				managed (GLib.Object.GetObject(obj) as Atk.Object, Atk.PropertyValues.New (vals));
+				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 PropertyChangeHandlerNative NativeDelegate;
+		Atk.PropertyChangeHandler managed;
+
+		public PropertyChangeHandlerWrapper (Atk.PropertyChangeHandler managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new PropertyChangeHandlerNative (NativeCallback);
+		}
+
+		public static Atk.PropertyChangeHandler GetManagedDelegate (PropertyChangeHandlerNative native)
+		{
+			if (native == null)
+				return null;
+			PropertyChangeHandlerWrapper wrapper = (PropertyChangeHandlerWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Attribute.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/BoundsChangedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ChildrenChangedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ColumnDeletedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ColumnInsertedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ComponentAdapter.cs

@@ -0,0 +1,536 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ComponentAdapter : GLib.GInterfaceAdapter, Atk.IComponent {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkComponentIface {
+			public AddFocusHandlerNativeDelegate AddFocusHandler;
+			public ContainsNativeDelegate Contains;
+			public RefAccessibleAtPointNativeDelegate RefAccessibleAtPoint;
+			public GetExtentsNativeDelegate GetExtents;
+			public GetPositionNativeDelegate GetPosition;
+			public GetSizeNativeDelegate GetSize;
+			public GrabFocusNativeDelegate GrabFocus;
+			public RemoveFocusHandlerNativeDelegate RemoveFocusHandler;
+			public SetExtentsNativeDelegate SetExtents;
+			public SetPositionNativeDelegate SetPosition;
+			public SetSizeNativeDelegate SetSize;
+			public GetLayerNativeDelegate GetLayer;
+			public GetMdiZorderNativeDelegate GetMdiZorder;
+			IntPtr BoundsChanged;
+			public GetAlphaNativeDelegate GetAlpha;
+		}
+
+		static AtkComponentIface iface;
+
+		static ComponentAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (ComponentAdapter));
+			iface.AddFocusHandler = new AddFocusHandlerNativeDelegate (AddFocusHandler_cb);
+			iface.Contains = new ContainsNativeDelegate (Contains_cb);
+			iface.RefAccessibleAtPoint = new RefAccessibleAtPointNativeDelegate (RefAccessibleAtPoint_cb);
+			iface.GetExtents = new GetExtentsNativeDelegate (GetExtents_cb);
+			iface.GetPosition = new GetPositionNativeDelegate (GetPosition_cb);
+			iface.GetSize = new GetSizeNativeDelegate (GetSize_cb);
+			iface.GrabFocus = new GrabFocusNativeDelegate (GrabFocus_cb);
+			iface.RemoveFocusHandler = new RemoveFocusHandlerNativeDelegate (RemoveFocusHandler_cb);
+			iface.SetExtents = new SetExtentsNativeDelegate (SetExtents_cb);
+			iface.SetPosition = new SetPositionNativeDelegate (SetPosition_cb);
+			iface.SetSize = new SetSizeNativeDelegate (SetSize_cb);
+			iface.GetLayer = new GetLayerNativeDelegate (GetLayer_cb);
+			iface.GetMdiZorder = new GetMdiZorderNativeDelegate (GetMdiZorder_cb);
+			iface.GetAlpha = new GetAlphaNativeDelegate (GetAlpha_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint AddFocusHandlerNativeDelegate (IntPtr inst, AtkSharp.FocusHandlerNative handler);
+
+		static uint AddFocusHandler_cb (IntPtr inst, AtkSharp.FocusHandlerNative handler)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				uint __result;
+				AtkSharp.FocusHandlerInvoker handler_invoker = new AtkSharp.FocusHandlerInvoker (handler);
+				__result = __obj.AddFocusHandler (handler_invoker.Handler);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool ContainsNativeDelegate (IntPtr inst, int x, int y, int coord_type);
+
+		static bool Contains_cb (IntPtr inst, int x, int y, int coord_type)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				bool __result;
+				__result = __obj.Contains (x, y, (Atk.CoordType) coord_type);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr RefAccessibleAtPointNativeDelegate (IntPtr inst, int x, int y, int coord_type);
+
+		static IntPtr RefAccessibleAtPoint_cb (IntPtr inst, int x, int y, int coord_type)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				Atk.Object __result;
+				__result = __obj.RefAccessibleAtPoint (x, y, (Atk.CoordType) coord_type);
+				return __result == null ? IntPtr.Zero : __result.OwnedHandle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetExtentsNativeDelegate (IntPtr inst, out int x, out int y, out int width, out int height, int coord_type);
+
+		static void GetExtents_cb (IntPtr inst, out int x, out int y, out int width, out int height, int coord_type)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				__obj.GetExtents (out x, out y, out width, out height, (Atk.CoordType) coord_type);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetPositionNativeDelegate (IntPtr inst, out int x, out int y, int coord_type);
+
+		static void GetPosition_cb (IntPtr inst, out int x, out int y, int coord_type)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				__obj.GetPosition (out x, out y, (Atk.CoordType) coord_type);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetSizeNativeDelegate (IntPtr inst, out int width, out int height);
+
+		static void GetSize_cb (IntPtr inst, out int width, out int height)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				__obj.GetSize (out width, out height);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool GrabFocusNativeDelegate (IntPtr inst);
+
+		static bool GrabFocus_cb (IntPtr inst)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				bool __result;
+				__result = __obj.GrabFocus ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void RemoveFocusHandlerNativeDelegate (IntPtr inst, uint handler_id);
+
+		static void RemoveFocusHandler_cb (IntPtr inst, uint handler_id)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				__obj.RemoveFocusHandler (handler_id);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetExtentsNativeDelegate (IntPtr inst, int x, int y, int width, int height, int coord_type);
+
+		static bool SetExtents_cb (IntPtr inst, int x, int y, int width, int height, int coord_type)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				bool __result;
+				__result = __obj.SetExtents (x, y, width, height, (Atk.CoordType) coord_type);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetPositionNativeDelegate (IntPtr inst, int x, int y, int coord_type);
+
+		static bool SetPosition_cb (IntPtr inst, int x, int y, int coord_type)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				bool __result;
+				__result = __obj.SetPosition (x, y, (Atk.CoordType) coord_type);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetSizeNativeDelegate (IntPtr inst, int width, int height);
+
+		static bool SetSize_cb (IntPtr inst, int width, int height)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				bool __result;
+				__result = __obj.SetSize (width, height);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetLayerNativeDelegate (IntPtr inst);
+
+		static int GetLayer_cb (IntPtr inst)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				Atk.Layer __result;
+				__result = __obj.Layer;
+				return (int) __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetMdiZorderNativeDelegate (IntPtr inst);
+
+		static int GetMdiZorder_cb (IntPtr inst)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				int __result;
+				__result = __obj.MdiZorder;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double GetAlphaNativeDelegate (IntPtr inst);
+
+		static double GetAlpha_cb (IntPtr inst)
+		{
+			try {
+				IComponentImplementor __obj = GLib.Object.GetObject (inst, false) as IComponentImplementor;
+				double __result;
+				__result = __obj.Alpha;
+				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);
+			AtkComponentIface native_iface = (AtkComponentIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkComponentIface));
+			native_iface.AddFocusHandler = iface.AddFocusHandler;
+			native_iface.Contains = iface.Contains;
+			native_iface.RefAccessibleAtPoint = iface.RefAccessibleAtPoint;
+			native_iface.GetExtents = iface.GetExtents;
+			native_iface.GetPosition = iface.GetPosition;
+			native_iface.GetSize = iface.GetSize;
+			native_iface.GrabFocus = iface.GrabFocus;
+			native_iface.RemoveFocusHandler = iface.RemoveFocusHandler;
+			native_iface.SetExtents = iface.SetExtents;
+			native_iface.SetPosition = iface.SetPosition;
+			native_iface.SetSize = iface.SetSize;
+			native_iface.GetLayer = iface.GetLayer;
+			native_iface.GetMdiZorder = iface.GetMdiZorder;
+			native_iface.GetAlpha = iface.GetAlpha;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public ComponentAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public ComponentAdapter (IComponentImplementor 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 ComponentAdapter (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_atk_component_get_type();
+		static d_atk_component_get_type atk_component_get_type = FuncLoader.LoadFunction<d_atk_component_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_component_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 IComponent GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IComponent GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IComponentImplementor)
+				return new ComponentAdapter (obj as IComponentImplementor);
+			else if (obj as IComponent == null)
+				return new ComponentAdapter (obj.Handle);
+			else
+				return obj as IComponent;
+		}
+
+		public IComponentImplementor Implementor {
+			get {
+				return implementor as IComponentImplementor;
+			}
+		}
+
+		[GLib.Signal("bounds_changed")]
+		public event Atk.BoundsChangedHandler BoundsChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("bounds_changed", value, typeof (Atk.BoundsChangedArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("bounds_changed", value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_component_add_focus_handler(IntPtr raw, AtkSharp.FocusHandlerNative handler);
+		static d_atk_component_add_focus_handler atk_component_add_focus_handler = FuncLoader.LoadFunction<d_atk_component_add_focus_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_add_focus_handler"));
+
+		[Obsolete]
+		public uint AddFocusHandler(Atk.FocusHandler handler) {
+			AtkSharp.FocusHandlerWrapper handler_wrapper = new AtkSharp.FocusHandlerWrapper (handler);
+			uint raw_ret = atk_component_add_focus_handler(Handle, handler_wrapper.NativeDelegate);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_contains(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_contains atk_component_contains = FuncLoader.LoadFunction<d_atk_component_contains>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_contains"));
+
+		public bool Contains(int x, int y, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_contains(Handle, x, y, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_atk_component_get_alpha(IntPtr raw);
+		static d_atk_component_get_alpha atk_component_get_alpha = FuncLoader.LoadFunction<d_atk_component_get_alpha>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_alpha"));
+
+		public double Alpha { 
+			get {
+				double raw_ret = atk_component_get_alpha(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_extents(IntPtr raw, out int x, out int y, out int width, out int height, int coord_type);
+		static d_atk_component_get_extents atk_component_get_extents = FuncLoader.LoadFunction<d_atk_component_get_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_extents"));
+
+		public void GetExtents(out int x, out int y, out int width, out int height, Atk.CoordType coord_type) {
+			atk_component_get_extents(Handle, out x, out y, out width, out height, (int) coord_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_component_get_layer(IntPtr raw);
+		static d_atk_component_get_layer atk_component_get_layer = FuncLoader.LoadFunction<d_atk_component_get_layer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_layer"));
+
+		public Atk.Layer Layer { 
+			get {
+				int raw_ret = atk_component_get_layer(Handle);
+				Atk.Layer ret = (Atk.Layer) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_component_get_mdi_zorder(IntPtr raw);
+		static d_atk_component_get_mdi_zorder atk_component_get_mdi_zorder = FuncLoader.LoadFunction<d_atk_component_get_mdi_zorder>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_mdi_zorder"));
+
+		public int MdiZorder { 
+			get {
+				int raw_ret = atk_component_get_mdi_zorder(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_position(IntPtr raw, out int x, out int y, int coord_type);
+		static d_atk_component_get_position atk_component_get_position = FuncLoader.LoadFunction<d_atk_component_get_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_position"));
+
+		[Obsolete]
+		public void GetPosition(out int x, out int y, Atk.CoordType coord_type) {
+			atk_component_get_position(Handle, out x, out y, (int) coord_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_size(IntPtr raw, out int width, out int height);
+		static d_atk_component_get_size atk_component_get_size = FuncLoader.LoadFunction<d_atk_component_get_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_size"));
+
+		[Obsolete]
+		public void GetSize(out int width, out int height) {
+			atk_component_get_size(Handle, out width, out height);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_grab_focus(IntPtr raw);
+		static d_atk_component_grab_focus atk_component_grab_focus = FuncLoader.LoadFunction<d_atk_component_grab_focus>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_grab_focus"));
+
+		public bool GrabFocus() {
+			bool raw_ret = atk_component_grab_focus(Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_component_ref_accessible_at_point(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_ref_accessible_at_point atk_component_ref_accessible_at_point = FuncLoader.LoadFunction<d_atk_component_ref_accessible_at_point>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_ref_accessible_at_point"));
+
+		public Atk.Object RefAccessibleAtPoint(int x, int y, Atk.CoordType coord_type) {
+			IntPtr raw_ret = atk_component_ref_accessible_at_point(Handle, x, y, (int) coord_type);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_remove_focus_handler(IntPtr raw, uint handler_id);
+		static d_atk_component_remove_focus_handler atk_component_remove_focus_handler = FuncLoader.LoadFunction<d_atk_component_remove_focus_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_remove_focus_handler"));
+
+		[Obsolete]
+		public void RemoveFocusHandler(uint handler_id) {
+			atk_component_remove_focus_handler(Handle, handler_id);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_extents(IntPtr raw, int x, int y, int width, int height, int coord_type);
+		static d_atk_component_set_extents atk_component_set_extents = FuncLoader.LoadFunction<d_atk_component_set_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_extents"));
+
+		public bool SetExtents(int x, int y, int width, int height, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_set_extents(Handle, x, y, width, height, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_position(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_set_position atk_component_set_position = FuncLoader.LoadFunction<d_atk_component_set_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_position"));
+
+		public bool SetPosition(int x, int y, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_set_position(Handle, x, y, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_size(IntPtr raw, int width, int height);
+		static d_atk_component_set_size atk_component_set_size = FuncLoader.LoadFunction<d_atk_component_set_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_size"));
+
+		public bool SetSize(int width, int height) {
+			bool raw_ret = atk_component_set_size(Handle, width, height);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/CoordType.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/DocumentAdapter.cs

@@ -0,0 +1,412 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class DocumentAdapter : GLib.GInterfaceAdapter, Atk.IDocument {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkDocumentIface {
+			public GetDocumentTypeNativeDelegate GetDocumentType;
+			public GetTheDocumentNativeDelegate GetTheDocument;
+			public GetLocaleNativeDelegate GetLocale;
+			public GetAttributesNativeDelegate GetAttributes;
+			public GetAttributeValueNativeDelegate GetAttributeValue;
+			public SetAttributeValueNativeDelegate SetAttributeValue;
+			public GetCurrentPageNumberNativeDelegate GetCurrentPageNumber;
+			public GetPageCountNativeDelegate GetPageCount;
+		}
+
+		static AtkDocumentIface iface;
+
+		static DocumentAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (DocumentAdapter));
+			iface.GetDocumentType = new GetDocumentTypeNativeDelegate (GetDocumentType_cb);
+			iface.GetTheDocument = new GetTheDocumentNativeDelegate (GetTheDocument_cb);
+			iface.GetLocale = new GetLocaleNativeDelegate (GetLocale_cb);
+			iface.GetAttributes = new GetAttributesNativeDelegate (GetAttributes_cb);
+			iface.GetAttributeValue = new GetAttributeValueNativeDelegate (GetAttributeValue_cb);
+			iface.SetAttributeValue = new SetAttributeValueNativeDelegate (SetAttributeValue_cb);
+			iface.GetCurrentPageNumber = new GetCurrentPageNumberNativeDelegate (GetCurrentPageNumber_cb);
+			iface.GetPageCount = new GetPageCountNativeDelegate (GetPageCount_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetDocumentTypeNativeDelegate (IntPtr inst);
+
+		static IntPtr GetDocumentType_cb (IntPtr inst)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				string __result;
+				__result = __obj.DocumentType;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetTheDocumentNativeDelegate (IntPtr inst);
+
+		static IntPtr GetTheDocument_cb (IntPtr inst)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				IntPtr __result;
+				__result = __obj.TheDocument;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetLocaleNativeDelegate (IntPtr inst);
+
+		static IntPtr GetLocale_cb (IntPtr inst)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				string __result;
+				__result = __obj.Locale;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetAttributesNativeDelegate (IntPtr inst);
+
+		static IntPtr GetAttributes_cb (IntPtr inst)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				Atk.Attribute[] __result;
+				__result = __obj.Attributes;
+				return new GLib.SList(__result, typeof (Atk.Attribute), false, false) == null ? IntPtr.Zero : new GLib.SList(__result, typeof (Atk.Attribute), false, false).Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetAttributeValueNativeDelegate (IntPtr inst, IntPtr attribute_name);
+
+		static IntPtr GetAttributeValue_cb (IntPtr inst, IntPtr attribute_name)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				string __result;
+				__result = __obj.GetAttributeValue (GLib.Marshaller.Utf8PtrToString (attribute_name));
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetAttributeValueNativeDelegate (IntPtr inst, IntPtr attribute_name, IntPtr attribute_value);
+
+		static bool SetAttributeValue_cb (IntPtr inst, IntPtr attribute_name, IntPtr attribute_value)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				bool __result;
+				__result = __obj.SetAttributeValue (GLib.Marshaller.Utf8PtrToString (attribute_name), GLib.Marshaller.Utf8PtrToString (attribute_value));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetCurrentPageNumberNativeDelegate (IntPtr inst);
+
+		static int GetCurrentPageNumber_cb (IntPtr inst)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				int __result;
+				__result = __obj.CurrentPageNumber;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetPageCountNativeDelegate (IntPtr inst);
+
+		static int GetPageCount_cb (IntPtr inst)
+		{
+			try {
+				IDocumentImplementor __obj = GLib.Object.GetObject (inst, false) as IDocumentImplementor;
+				int __result;
+				__result = __obj.PageCount;
+				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);
+			AtkDocumentIface native_iface = (AtkDocumentIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkDocumentIface));
+			native_iface.GetDocumentType = iface.GetDocumentType;
+			native_iface.GetTheDocument = iface.GetTheDocument;
+			native_iface.GetLocale = iface.GetLocale;
+			native_iface.GetAttributes = iface.GetAttributes;
+			native_iface.GetAttributeValue = iface.GetAttributeValue;
+			native_iface.SetAttributeValue = iface.SetAttributeValue;
+			native_iface.GetCurrentPageNumber = iface.GetCurrentPageNumber;
+			native_iface.GetPageCount = iface.GetPageCount;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public DocumentAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public DocumentAdapter (IDocumentImplementor 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 DocumentAdapter (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_atk_document_get_type();
+		static d_atk_document_get_type atk_document_get_type = FuncLoader.LoadFunction<d_atk_document_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_document_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 IDocument GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IDocument GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IDocumentImplementor)
+				return new DocumentAdapter (obj as IDocumentImplementor);
+			else if (obj as IDocument == null)
+				return new DocumentAdapter (obj.Handle);
+			else
+				return obj as IDocument;
+		}
+
+		public IDocumentImplementor Implementor {
+			get {
+				return implementor as IDocumentImplementor;
+			}
+		}
+
+		[GLib.Signal("reload")]
+		public event System.EventHandler Reload {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("reload", value);
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("reload", value);
+			}
+		}
+
+		[GLib.Signal("load_complete")]
+		public event System.EventHandler LoadComplete {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("load_complete", value);
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("load_complete", value);
+			}
+		}
+
+		[GLib.Signal("load_stopped")]
+		public event System.EventHandler LoadStopped {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("load_stopped", value);
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("load_stopped", value);
+			}
+		}
+
+		[GLib.Signal("page_changed")]
+		public event Atk.PageChangedHandler PageChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("page_changed", value, typeof (Atk.PageChangedArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("page_changed", value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_document_get_attribute_value(IntPtr raw, IntPtr attribute_name);
+		static d_atk_document_get_attribute_value atk_document_get_attribute_value = FuncLoader.LoadFunction<d_atk_document_get_attribute_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_attribute_value"));
+
+		public string GetAttributeValue(string attribute_name) {
+			IntPtr native_attribute_name = GLib.Marshaller.StringToPtrGStrdup (attribute_name);
+			IntPtr raw_ret = atk_document_get_attribute_value(Handle, native_attribute_name);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			GLib.Marshaller.Free (native_attribute_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_document_get_attributes(IntPtr raw);
+		static d_atk_document_get_attributes atk_document_get_attributes = FuncLoader.LoadFunction<d_atk_document_get_attributes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_attributes"));
+
+		public Atk.Attribute[] Attributes { 
+			get {
+				IntPtr raw_ret = atk_document_get_attributes(Handle);
+				Atk.Attribute[] ret = GLib.Marshaller.SListPtrToArray<Atk.Attribute, Atk.Attribute> (raw_ret, false, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_document_get_current_page_number(IntPtr raw);
+		static d_atk_document_get_current_page_number atk_document_get_current_page_number = FuncLoader.LoadFunction<d_atk_document_get_current_page_number>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_current_page_number"));
+
+		public int CurrentPageNumber { 
+			get {
+				int raw_ret = atk_document_get_current_page_number(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_document_get_document(IntPtr raw);
+		static d_atk_document_get_document atk_document_get_document = FuncLoader.LoadFunction<d_atk_document_get_document>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_document"));
+
+		[Obsolete]
+		public IntPtr TheDocument { 
+			get {
+				IntPtr raw_ret = atk_document_get_document(Handle);
+				IntPtr ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_document_get_document_type(IntPtr raw);
+		static d_atk_document_get_document_type atk_document_get_document_type = FuncLoader.LoadFunction<d_atk_document_get_document_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_document_type"));
+
+		[Obsolete]
+		public string DocumentType { 
+			get {
+				IntPtr raw_ret = atk_document_get_document_type(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_document_get_locale(IntPtr raw);
+		static d_atk_document_get_locale atk_document_get_locale = FuncLoader.LoadFunction<d_atk_document_get_locale>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_locale"));
+
+		[Obsolete]
+		public string Locale { 
+			get {
+				IntPtr raw_ret = atk_document_get_locale(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_document_get_page_count(IntPtr raw);
+		static d_atk_document_get_page_count atk_document_get_page_count = FuncLoader.LoadFunction<d_atk_document_get_page_count>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_get_page_count"));
+
+		public int PageCount { 
+			get {
+				int raw_ret = atk_document_get_page_count(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_document_set_attribute_value(IntPtr raw, IntPtr attribute_name, IntPtr attribute_value);
+		static d_atk_document_set_attribute_value atk_document_set_attribute_value = FuncLoader.LoadFunction<d_atk_document_set_attribute_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_document_set_attribute_value"));
+
+		public bool SetAttributeValue(string attribute_name, string attribute_value) {
+			IntPtr native_attribute_name = GLib.Marshaller.StringToPtrGStrdup (attribute_name);
+			IntPtr native_attribute_value = GLib.Marshaller.StringToPtrGStrdup (attribute_value);
+			bool raw_ret = atk_document_set_attribute_value(Handle, native_attribute_name, native_attribute_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_attribute_name);
+			GLib.Marshaller.Free (native_attribute_value);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/EditableTextAdapter.cs

@@ -0,0 +1,291 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EditableTextAdapter : GLib.GInterfaceAdapter, Atk.IEditableText {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkEditableTextIface {
+			public SetRunAttributesNativeDelegate SetRunAttributes;
+			public SetTextContentsNativeDelegate SetTextContents;
+			public InsertTextNativeDelegate InsertText;
+			public CopyTextNativeDelegate CopyText;
+			public CutTextNativeDelegate CutText;
+			public DeleteTextNativeDelegate DeleteText;
+			public PasteTextNativeDelegate PasteText;
+		}
+
+		static AtkEditableTextIface iface;
+
+		static EditableTextAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (EditableTextAdapter));
+			iface.SetRunAttributes = new SetRunAttributesNativeDelegate (SetRunAttributes_cb);
+			iface.SetTextContents = new SetTextContentsNativeDelegate (SetTextContents_cb);
+			iface.InsertText = new InsertTextNativeDelegate (InsertText_cb);
+			iface.CopyText = new CopyTextNativeDelegate (CopyText_cb);
+			iface.CutText = new CutTextNativeDelegate (CutText_cb);
+			iface.DeleteText = new DeleteTextNativeDelegate (DeleteText_cb);
+			iface.PasteText = new PasteTextNativeDelegate (PasteText_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetRunAttributesNativeDelegate (IntPtr inst, IntPtr attrib_set, int start_offset, int end_offset);
+
+		static bool SetRunAttributes_cb (IntPtr inst, IntPtr attrib_set, int start_offset, int end_offset)
+		{
+			try {
+				IEditableTextImplementor __obj = GLib.Object.GetObject (inst, false) as IEditableTextImplementor;
+				bool __result;
+				__result = __obj.SetRunAttributes (new GLib.SList(attrib_set), start_offset, end_offset);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void SetTextContentsNativeDelegate (IntPtr inst, IntPtr str1ng);
+
+		static void SetTextContents_cb (IntPtr inst, IntPtr str1ng)
+		{
+			try {
+				IEditableTextImplementor __obj = GLib.Object.GetObject (inst, false) as IEditableTextImplementor;
+				__obj.TextContents = GLib.Marshaller.Utf8PtrToString (str1ng);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void InsertTextNativeDelegate (IntPtr inst, IntPtr str1ng, int length, ref int position);
+
+		static void InsertText_cb (IntPtr inst, IntPtr str1ng, int length, ref int position)
+		{
+			try {
+				IEditableTextImplementor __obj = GLib.Object.GetObject (inst, false) as IEditableTextImplementor;
+				__obj.InsertText (GLib.Marshaller.Utf8PtrToString (str1ng), ref position);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void CopyTextNativeDelegate (IntPtr inst, int start_pos, int end_pos);
+
+		static void CopyText_cb (IntPtr inst, int start_pos, int end_pos)
+		{
+			try {
+				IEditableTextImplementor __obj = GLib.Object.GetObject (inst, false) as IEditableTextImplementor;
+				__obj.CopyText (start_pos, end_pos);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void CutTextNativeDelegate (IntPtr inst, int start_pos, int end_pos);
+
+		static void CutText_cb (IntPtr inst, int start_pos, int end_pos)
+		{
+			try {
+				IEditableTextImplementor __obj = GLib.Object.GetObject (inst, false) as IEditableTextImplementor;
+				__obj.CutText (start_pos, end_pos);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void DeleteTextNativeDelegate (IntPtr inst, int start_pos, int end_pos);
+
+		static void DeleteText_cb (IntPtr inst, int start_pos, int end_pos)
+		{
+			try {
+				IEditableTextImplementor __obj = GLib.Object.GetObject (inst, false) as IEditableTextImplementor;
+				__obj.DeleteText (start_pos, end_pos);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void PasteTextNativeDelegate (IntPtr inst, int position);
+
+		static void PasteText_cb (IntPtr inst, int position)
+		{
+			try {
+				IEditableTextImplementor __obj = GLib.Object.GetObject (inst, false) as IEditableTextImplementor;
+				__obj.PasteText (position);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		static int class_offset = 2 * IntPtr.Size;
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
+			AtkEditableTextIface native_iface = (AtkEditableTextIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkEditableTextIface));
+			native_iface.SetRunAttributes = iface.SetRunAttributes;
+			native_iface.SetTextContents = iface.SetTextContents;
+			native_iface.InsertText = iface.InsertText;
+			native_iface.CopyText = iface.CopyText;
+			native_iface.CutText = iface.CutText;
+			native_iface.DeleteText = iface.DeleteText;
+			native_iface.PasteText = iface.PasteText;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public EditableTextAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public EditableTextAdapter (IEditableTextImplementor 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 EditableTextAdapter (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_atk_editable_text_get_type();
+		static d_atk_editable_text_get_type atk_editable_text_get_type = FuncLoader.LoadFunction<d_atk_editable_text_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_editable_text_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 IEditableText GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IEditableText GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IEditableTextImplementor)
+				return new EditableTextAdapter (obj as IEditableTextImplementor);
+			else if (obj as IEditableText == null)
+				return new EditableTextAdapter (obj.Handle);
+			else
+				return obj as IEditableText;
+		}
+
+		public IEditableTextImplementor Implementor {
+			get {
+				return implementor as IEditableTextImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_editable_text_copy_text(IntPtr raw, int start_pos, int end_pos);
+		static d_atk_editable_text_copy_text atk_editable_text_copy_text = FuncLoader.LoadFunction<d_atk_editable_text_copy_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_copy_text"));
+
+		public void CopyText(int start_pos, int end_pos) {
+			atk_editable_text_copy_text(Handle, start_pos, end_pos);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_editable_text_cut_text(IntPtr raw, int start_pos, int end_pos);
+		static d_atk_editable_text_cut_text atk_editable_text_cut_text = FuncLoader.LoadFunction<d_atk_editable_text_cut_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_cut_text"));
+
+		public void CutText(int start_pos, int end_pos) {
+			atk_editable_text_cut_text(Handle, start_pos, end_pos);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_editable_text_delete_text(IntPtr raw, int start_pos, int end_pos);
+		static d_atk_editable_text_delete_text atk_editable_text_delete_text = FuncLoader.LoadFunction<d_atk_editable_text_delete_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_delete_text"));
+
+		public void DeleteText(int start_pos, int end_pos) {
+			atk_editable_text_delete_text(Handle, start_pos, end_pos);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_editable_text_insert_text(IntPtr raw, IntPtr str1ng, int length, ref int position);
+		static d_atk_editable_text_insert_text atk_editable_text_insert_text = FuncLoader.LoadFunction<d_atk_editable_text_insert_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_insert_text"));
+
+		public void InsertText(string str1ng, ref int position) {
+			IntPtr native_str1ng = GLib.Marshaller.StringToPtrGStrdup (str1ng);
+			atk_editable_text_insert_text(Handle, native_str1ng, System.Text.Encoding.UTF8.GetByteCount (str1ng), ref position);
+			GLib.Marshaller.Free (native_str1ng);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_editable_text_paste_text(IntPtr raw, int position);
+		static d_atk_editable_text_paste_text atk_editable_text_paste_text = FuncLoader.LoadFunction<d_atk_editable_text_paste_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_paste_text"));
+
+		public void PasteText(int position) {
+			atk_editable_text_paste_text(Handle, position);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_editable_text_set_run_attributes(IntPtr raw, IntPtr attrib_set, int start_offset, int end_offset);
+		static d_atk_editable_text_set_run_attributes atk_editable_text_set_run_attributes = FuncLoader.LoadFunction<d_atk_editable_text_set_run_attributes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_set_run_attributes"));
+
+		public bool SetRunAttributes(GLib.SList attrib_set, int start_offset, int end_offset) {
+			bool raw_ret = atk_editable_text_set_run_attributes(Handle, attrib_set == null ? IntPtr.Zero : attrib_set.Handle, start_offset, end_offset);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_editable_text_set_text_contents(IntPtr raw, IntPtr str1ng);
+		static d_atk_editable_text_set_text_contents atk_editable_text_set_text_contents = FuncLoader.LoadFunction<d_atk_editable_text_set_text_contents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_editable_text_set_text_contents"));
+
+		public string TextContents { 
+			set {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				atk_editable_text_set_text_contents(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/EventListener.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/EventListenerInit.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Focus.cs

@@ -0,0 +1,33 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Focus {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_focus_tracker_init(AtkSharp.EventListenerInitNative init);
+		static d_atk_focus_tracker_init atk_focus_tracker_init = FuncLoader.LoadFunction<d_atk_focus_tracker_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_focus_tracker_init"));
+
+		[Obsolete]
+		public static void TrackerInit(Atk.EventListenerInit init) {
+			AtkSharp.EventListenerInitWrapper init_wrapper = new AtkSharp.EventListenerInitWrapper (init);
+			atk_focus_tracker_init(init_wrapper.NativeDelegate);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_focus_tracker_notify(IntPtr objekt);
+		static d_atk_focus_tracker_notify atk_focus_tracker_notify = FuncLoader.LoadFunction<d_atk_focus_tracker_notify>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_focus_tracker_notify"));
+
+		[Obsolete]
+		public static void TrackerNotify(Atk.Object objekt) {
+			atk_focus_tracker_notify(objekt == null ? IntPtr.Zero : objekt.Handle);
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/FocusEventHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/FocusHandler.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+	public delegate void FocusHandler(Atk.Object objekt, bool focus_in);
+
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/FocusTracker.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FocusTracker : GLib.Opaque {
+
+		public FocusTracker(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/AtkSharp/Generated/Atk/Function.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/GObjectAccessible.cs

@@ -0,0 +1,105 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class GObjectAccessible : Atk.Object {
+
+		public GObjectAccessible (IntPtr raw) : base(raw) {}
+
+		protected GObjectAccessible() : 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 (new List<GLib.AbiField>{ 
+						new GLib.AbiField("pad1"
+							, Atk.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // pad1
+							, null
+							, "pad2"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("pad2"
+							, -1
+							, (uint) sizeof( IntPtr ) // pad2
+							, "pad1"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_gobject_accessible_for_object(IntPtr obj);
+		static d_atk_gobject_accessible_for_object atk_gobject_accessible_for_object = FuncLoader.LoadFunction<d_atk_gobject_accessible_for_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_gobject_accessible_for_object"));
+
+		public static Atk.Object ForObject(GLib.Object obj) {
+			IntPtr raw_ret = atk_gobject_accessible_for_object(obj == null ? IntPtr.Zero : obj.Handle);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_gobject_accessible_get_object(IntPtr raw);
+		static d_atk_gobject_accessible_get_object atk_gobject_accessible_get_object = FuncLoader.LoadFunction<d_atk_gobject_accessible_get_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_gobject_accessible_get_object"));
+
+		public GLib.Object Object { 
+			get {
+				IntPtr raw_ret = atk_gobject_accessible_get_object(Handle);
+				GLib.Object ret = GLib.Object.GetObject (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_gobject_accessible_get_type();
+		static d_atk_gobject_accessible_get_type atk_gobject_accessible_get_type = FuncLoader.LoadFunction<d_atk_gobject_accessible_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_gobject_accessible_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_gobject_accessible_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 (Atk.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Global.cs

@@ -0,0 +1,239 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Global {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_add_focus_tracker(AtkSharp.EventListenerNative focus_tracker);
+		static d_atk_add_focus_tracker atk_add_focus_tracker = FuncLoader.LoadFunction<d_atk_add_focus_tracker>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_add_focus_tracker"));
+
+		[Obsolete]
+		public static uint AddFocusTracker(Atk.EventListener focus_tracker) {
+			AtkSharp.EventListenerWrapper focus_tracker_wrapper = new AtkSharp.EventListenerWrapper (focus_tracker);
+			uint raw_ret = atk_add_focus_tracker(focus_tracker_wrapper.NativeDelegate);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_add_key_event_listener(AtkSharp.KeySnoopFuncNative listener, IntPtr data);
+		static d_atk_add_key_event_listener atk_add_key_event_listener = FuncLoader.LoadFunction<d_atk_add_key_event_listener>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_add_key_event_listener"));
+
+		public static uint AddKeyEventListener(Atk.KeySnoopFunc listener) {
+			AtkSharp.KeySnoopFuncWrapper listener_wrapper = new AtkSharp.KeySnoopFuncWrapper (listener);
+			uint raw_ret = atk_add_key_event_listener(listener_wrapper.NativeDelegate, IntPtr.Zero);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_get_binary_age();
+		static d_atk_get_binary_age atk_get_binary_age = FuncLoader.LoadFunction<d_atk_get_binary_age>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_binary_age"));
+
+		public static uint BinaryAge { 
+			get {
+				uint raw_ret = atk_get_binary_age();
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_get_default_registry();
+		static d_atk_get_default_registry atk_get_default_registry = FuncLoader.LoadFunction<d_atk_get_default_registry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_default_registry"));
+
+		public static Atk.Registry DefaultRegistry { 
+			get {
+				IntPtr raw_ret = atk_get_default_registry();
+				Atk.Registry ret = GLib.Object.GetObject(raw_ret) as Atk.Registry;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_get_focus_object();
+		static d_atk_get_focus_object atk_get_focus_object = FuncLoader.LoadFunction<d_atk_get_focus_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_focus_object"));
+
+		public static Atk.Object FocusObject { 
+			get {
+				IntPtr raw_ret = atk_get_focus_object();
+				Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_get_interface_age();
+		static d_atk_get_interface_age atk_get_interface_age = FuncLoader.LoadFunction<d_atk_get_interface_age>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_interface_age"));
+
+		public static uint InterfaceAge { 
+			get {
+				uint raw_ret = atk_get_interface_age();
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_get_major_version();
+		static d_atk_get_major_version atk_get_major_version = FuncLoader.LoadFunction<d_atk_get_major_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_major_version"));
+
+		public static uint MajorVersion { 
+			get {
+				uint raw_ret = atk_get_major_version();
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_get_micro_version();
+		static d_atk_get_micro_version atk_get_micro_version = FuncLoader.LoadFunction<d_atk_get_micro_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_micro_version"));
+
+		public static uint MicroVersion { 
+			get {
+				uint raw_ret = atk_get_micro_version();
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_get_minor_version();
+		static d_atk_get_minor_version atk_get_minor_version = FuncLoader.LoadFunction<d_atk_get_minor_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_minor_version"));
+
+		public static uint MinorVersion { 
+			get {
+				uint raw_ret = atk_get_minor_version();
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_get_root();
+		static d_atk_get_root atk_get_root = FuncLoader.LoadFunction<d_atk_get_root>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_root"));
+
+		public static Atk.Object Root { 
+			get {
+				IntPtr raw_ret = atk_get_root();
+				Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_get_toolkit_name();
+		static d_atk_get_toolkit_name atk_get_toolkit_name = FuncLoader.LoadFunction<d_atk_get_toolkit_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_toolkit_name"));
+
+		public static string ToolkitName { 
+			get {
+				IntPtr raw_ret = atk_get_toolkit_name();
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_get_toolkit_version();
+		static d_atk_get_toolkit_version atk_get_toolkit_version = FuncLoader.LoadFunction<d_atk_get_toolkit_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_toolkit_version"));
+
+		public static string ToolkitVersion { 
+			get {
+				IntPtr raw_ret = atk_get_toolkit_version();
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_get_version();
+		static d_atk_get_version atk_get_version = FuncLoader.LoadFunction<d_atk_get_version>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_get_version"));
+
+		public static string Version { 
+			get {
+				IntPtr raw_ret = atk_get_version();
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_remove_focus_tracker(uint tracker_id);
+		static d_atk_remove_focus_tracker atk_remove_focus_tracker = FuncLoader.LoadFunction<d_atk_remove_focus_tracker>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_remove_focus_tracker"));
+
+		[Obsolete]
+		public static void RemoveFocusTracker(uint tracker_id) {
+			atk_remove_focus_tracker(tracker_id);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_remove_global_event_listener(uint listener_id);
+		static d_atk_remove_global_event_listener atk_remove_global_event_listener = FuncLoader.LoadFunction<d_atk_remove_global_event_listener>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_remove_global_event_listener"));
+
+		public static void RemoveGlobalEventListener(uint listener_id) {
+			atk_remove_global_event_listener(listener_id);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_remove_key_event_listener(uint listener_id);
+		static d_atk_remove_key_event_listener atk_remove_key_event_listener = FuncLoader.LoadFunction<d_atk_remove_key_event_listener>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_remove_key_event_listener"));
+
+		public static void RemoveKeyEventListener(uint listener_id) {
+			atk_remove_key_event_listener(listener_id);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_role_for_name(IntPtr name);
+		static d_atk_role_for_name atk_role_for_name = FuncLoader.LoadFunction<d_atk_role_for_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_role_for_name"));
+
+		public static Atk.Role RoleForName(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_role_for_name(native_name);
+			Atk.Role ret = (Atk.Role) raw_ret;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_role_get_localized_name(int role);
+		static d_atk_role_get_localized_name atk_role_get_localized_name = FuncLoader.LoadFunction<d_atk_role_get_localized_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_role_get_localized_name"));
+
+		public static string RoleGetLocalizedName(Atk.Role role) {
+			IntPtr raw_ret = atk_role_get_localized_name((int) role);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_role_get_name(int role);
+		static d_atk_role_get_name atk_role_get_name = FuncLoader.LoadFunction<d_atk_role_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_role_get_name"));
+
+		public static string RoleGetName(Atk.Role role) {
+			IntPtr raw_ret = atk_role_get_name((int) role);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_role_register(IntPtr name);
+		static d_atk_role_register atk_role_register = FuncLoader.LoadFunction<d_atk_role_register>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_role_register"));
+
+		[Obsolete]
+		public static Atk.Role RoleRegister(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_role_register(native_name);
+			Atk.Role ret = (Atk.Role) raw_ret;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Hyperlink.cs

@@ -0,0 +1,827 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Hyperlink : GLib.Object, Atk.IAction {
+
+		public Hyperlink (IntPtr raw) : base(raw) {}
+
+		protected Hyperlink() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[GLib.Property ("selected-link")]
+		public bool SelectedLink {
+			get {
+				GLib.Value val = GetProperty ("selected-link");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("number-of-anchors")]
+		public int NumberOfAnchors {
+			get {
+				GLib.Value val = GetProperty ("number-of-anchors");
+				int ret = (int) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_hyperlink_get_end_index(IntPtr raw);
+		static d_atk_hyperlink_get_end_index atk_hyperlink_get_end_index = FuncLoader.LoadFunction<d_atk_hyperlink_get_end_index>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_get_end_index"));
+
+		[GLib.Property ("end-index")]
+		public int EndIndex {
+			get  {
+				int raw_ret = atk_hyperlink_get_end_index(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_hyperlink_get_start_index(IntPtr raw);
+		static d_atk_hyperlink_get_start_index atk_hyperlink_get_start_index = FuncLoader.LoadFunction<d_atk_hyperlink_get_start_index>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_get_start_index"));
+
+		[GLib.Property ("start-index")]
+		public int StartIndex {
+			get  {
+				int raw_ret = atk_hyperlink_get_start_index(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[GLib.Signal("link_activated")]
+		public event System.EventHandler LinkActivated {
+			add {
+				this.AddSignalHandler ("link_activated", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("link_activated", value);
+			}
+		}
+
+		static GetUriNativeDelegate GetUri_cb_delegate;
+		static GetUriNativeDelegate GetUriVMCallback {
+			get {
+				if (GetUri_cb_delegate == null)
+					GetUri_cb_delegate = new GetUriNativeDelegate (GetUri_cb);
+				return GetUri_cb_delegate;
+			}
+		}
+
+		static void OverrideGetUri (GLib.GType gtype)
+		{
+			OverrideGetUri (gtype, GetUriVMCallback);
+		}
+
+		static void OverrideGetUri (GLib.GType gtype, GetUriNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_uri"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetUriNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr GetUri_cb (IntPtr inst, int i)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				string __result;
+				__result = __obj.OnGetUri (i);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideGetUri")]
+		protected virtual string OnGetUri (int i)
+		{
+			return InternalGetUri (i);
+		}
+
+		private string InternalGetUri (int i)
+		{
+			GetUriNativeDelegate unmanaged = class_abi.BaseOverride<GetUriNativeDelegate>(this.LookupGType(), "get_uri");
+			if (unmanaged == null) return null;
+
+			IntPtr __result = unmanaged (this.Handle, i);
+			return GLib.Marshaller.PtrToStringGFree(__result);
+		}
+
+		static GetObjectNativeDelegate GetObject_cb_delegate;
+		static GetObjectNativeDelegate GetObjectVMCallback {
+			get {
+				if (GetObject_cb_delegate == null)
+					GetObject_cb_delegate = new GetObjectNativeDelegate (GetObject_cb);
+				return GetObject_cb_delegate;
+			}
+		}
+
+		static void OverrideGetObject (GLib.GType gtype)
+		{
+			OverrideGetObject (gtype, GetObjectVMCallback);
+		}
+
+		static void OverrideGetObject (GLib.GType gtype, GetObjectNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_object"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetObjectNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr GetObject_cb (IntPtr inst, int i)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				Atk.Object __result;
+				__result = __obj.OnGetObject (i);
+				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(Atk.Hyperlink), ConnectionMethod="OverrideGetObject")]
+		protected virtual Atk.Object OnGetObject (int i)
+		{
+			return InternalGetObject (i);
+		}
+
+		private Atk.Object InternalGetObject (int i)
+		{
+			GetObjectNativeDelegate unmanaged = class_abi.BaseOverride<GetObjectNativeDelegate>(this.LookupGType(), "get_object");
+			if (unmanaged == null) return null;
+
+			IntPtr __result = unmanaged (this.Handle, i);
+			return GLib.Object.GetObject(__result) as Atk.Object;
+		}
+
+		static GetEndIndexNativeDelegate GetEndIndex_cb_delegate;
+		static GetEndIndexNativeDelegate GetEndIndexVMCallback {
+			get {
+				if (GetEndIndex_cb_delegate == null)
+					GetEndIndex_cb_delegate = new GetEndIndexNativeDelegate (GetEndIndex_cb);
+				return GetEndIndex_cb_delegate;
+			}
+		}
+
+		static void OverrideGetEndIndex (GLib.GType gtype)
+		{
+			OverrideGetEndIndex (gtype, GetEndIndexVMCallback);
+		}
+
+		static void OverrideGetEndIndex (GLib.GType gtype, GetEndIndexNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_end_index"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetEndIndexNativeDelegate (IntPtr inst);
+
+		static int GetEndIndex_cb (IntPtr inst)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				int __result;
+				__result = __obj.OnGetEndIndex ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideGetEndIndex")]
+		protected virtual int OnGetEndIndex ()
+		{
+			return InternalGetEndIndex ();
+		}
+
+		private int InternalGetEndIndex ()
+		{
+			GetEndIndexNativeDelegate unmanaged = class_abi.BaseOverride<GetEndIndexNativeDelegate>(this.LookupGType(), "get_end_index");
+			if (unmanaged == null) return 0;
+
+			int __result = unmanaged (this.Handle);
+			return __result;
+		}
+
+		static GetStartIndexNativeDelegate GetStartIndex_cb_delegate;
+		static GetStartIndexNativeDelegate GetStartIndexVMCallback {
+			get {
+				if (GetStartIndex_cb_delegate == null)
+					GetStartIndex_cb_delegate = new GetStartIndexNativeDelegate (GetStartIndex_cb);
+				return GetStartIndex_cb_delegate;
+			}
+		}
+
+		static void OverrideGetStartIndex (GLib.GType gtype)
+		{
+			OverrideGetStartIndex (gtype, GetStartIndexVMCallback);
+		}
+
+		static void OverrideGetStartIndex (GLib.GType gtype, GetStartIndexNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_start_index"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetStartIndexNativeDelegate (IntPtr inst);
+
+		static int GetStartIndex_cb (IntPtr inst)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				int __result;
+				__result = __obj.OnGetStartIndex ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideGetStartIndex")]
+		protected virtual int OnGetStartIndex ()
+		{
+			return InternalGetStartIndex ();
+		}
+
+		private int InternalGetStartIndex ()
+		{
+			GetStartIndexNativeDelegate unmanaged = class_abi.BaseOverride<GetStartIndexNativeDelegate>(this.LookupGType(), "get_start_index");
+			if (unmanaged == null) return 0;
+
+			int __result = unmanaged (this.Handle);
+			return __result;
+		}
+
+		static IsValidNativeDelegate IsValid_cb_delegate;
+		static IsValidNativeDelegate IsValidVMCallback {
+			get {
+				if (IsValid_cb_delegate == null)
+					IsValid_cb_delegate = new IsValidNativeDelegate (IsValid_cb);
+				return IsValid_cb_delegate;
+			}
+		}
+
+		static void OverrideIsValid (GLib.GType gtype)
+		{
+			OverrideIsValid (gtype, IsValidVMCallback);
+		}
+
+		static void OverrideIsValid (GLib.GType gtype, IsValidNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("is_valid"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool IsValidNativeDelegate (IntPtr inst);
+
+		static bool IsValid_cb (IntPtr inst)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				bool __result;
+				__result = __obj.OnIsValid ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideIsValid")]
+		protected virtual bool OnIsValid ()
+		{
+			return InternalIsValid ();
+		}
+
+		private bool InternalIsValid ()
+		{
+			IsValidNativeDelegate unmanaged = class_abi.BaseOverride<IsValidNativeDelegate>(this.LookupGType(), "is_valid");
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle);
+			return __result;
+		}
+
+		static GetNAnchorsNativeDelegate GetNAnchors_cb_delegate;
+		static GetNAnchorsNativeDelegate GetNAnchorsVMCallback {
+			get {
+				if (GetNAnchors_cb_delegate == null)
+					GetNAnchors_cb_delegate = new GetNAnchorsNativeDelegate (GetNAnchors_cb);
+				return GetNAnchors_cb_delegate;
+			}
+		}
+
+		static void OverrideGetNAnchors (GLib.GType gtype)
+		{
+			OverrideGetNAnchors (gtype, GetNAnchorsVMCallback);
+		}
+
+		static void OverrideGetNAnchors (GLib.GType gtype, GetNAnchorsNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_n_anchors"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetNAnchorsNativeDelegate (IntPtr inst);
+
+		static int GetNAnchors_cb (IntPtr inst)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				int __result;
+				__result = __obj.OnGetNAnchors ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideGetNAnchors")]
+		protected virtual int OnGetNAnchors ()
+		{
+			return InternalGetNAnchors ();
+		}
+
+		private int InternalGetNAnchors ()
+		{
+			GetNAnchorsNativeDelegate unmanaged = class_abi.BaseOverride<GetNAnchorsNativeDelegate>(this.LookupGType(), "get_n_anchors");
+			if (unmanaged == null) return 0;
+
+			int __result = unmanaged (this.Handle);
+			return __result;
+		}
+
+		static LinkStateNativeDelegate LinkState_cb_delegate;
+		static LinkStateNativeDelegate LinkStateVMCallback {
+			get {
+				if (LinkState_cb_delegate == null)
+					LinkState_cb_delegate = new LinkStateNativeDelegate (LinkState_cb);
+				return LinkState_cb_delegate;
+			}
+		}
+
+		static void OverrideLinkState (GLib.GType gtype)
+		{
+			OverrideLinkState (gtype, LinkStateVMCallback);
+		}
+
+		static void OverrideLinkState (GLib.GType gtype, LinkStateNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("link_state"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint LinkStateNativeDelegate (IntPtr inst);
+
+		static uint LinkState_cb (IntPtr inst)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				uint __result;
+				__result = __obj.OnLinkState ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideLinkState")]
+		protected virtual uint OnLinkState ()
+		{
+			return InternalLinkState ();
+		}
+
+		private uint InternalLinkState ()
+		{
+			LinkStateNativeDelegate unmanaged = class_abi.BaseOverride<LinkStateNativeDelegate>(this.LookupGType(), "link_state");
+			if (unmanaged == null) return 0;
+
+			uint __result = unmanaged (this.Handle);
+			return __result;
+		}
+
+		static IsSelectedLinkNativeDelegate IsSelectedLink_cb_delegate;
+		static IsSelectedLinkNativeDelegate IsSelectedLinkVMCallback {
+			get {
+				if (IsSelectedLink_cb_delegate == null)
+					IsSelectedLink_cb_delegate = new IsSelectedLinkNativeDelegate (IsSelectedLink_cb);
+				return IsSelectedLink_cb_delegate;
+			}
+		}
+
+		static void OverrideIsSelectedLink (GLib.GType gtype)
+		{
+			OverrideIsSelectedLink (gtype, IsSelectedLinkVMCallback);
+		}
+
+		static void OverrideIsSelectedLink (GLib.GType gtype, IsSelectedLinkNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("is_selected_link"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool IsSelectedLinkNativeDelegate (IntPtr inst);
+
+		static bool IsSelectedLink_cb (IntPtr inst)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				bool __result;
+				__result = __obj.OnIsSelectedLink ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideIsSelectedLink")]
+		protected virtual bool OnIsSelectedLink ()
+		{
+			return InternalIsSelectedLink ();
+		}
+
+		private bool InternalIsSelectedLink ()
+		{
+			IsSelectedLinkNativeDelegate unmanaged = class_abi.BaseOverride<IsSelectedLinkNativeDelegate>(this.LookupGType(), "is_selected_link");
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle);
+			return __result;
+		}
+
+		static LinkActivatedNativeDelegate LinkActivated_cb_delegate;
+		static LinkActivatedNativeDelegate LinkActivatedVMCallback {
+			get {
+				if (LinkActivated_cb_delegate == null)
+					LinkActivated_cb_delegate = new LinkActivatedNativeDelegate (LinkActivated_cb);
+				return LinkActivated_cb_delegate;
+			}
+		}
+
+		static void OverrideLinkActivated (GLib.GType gtype)
+		{
+			OverrideLinkActivated (gtype, LinkActivatedVMCallback);
+		}
+
+		static void OverrideLinkActivated (GLib.GType gtype, LinkActivatedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("link_activated"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void LinkActivatedNativeDelegate (IntPtr inst);
+
+		static void LinkActivated_cb (IntPtr inst)
+		{
+			try {
+				Hyperlink __obj = GLib.Object.GetObject (inst, false) as Hyperlink;
+				__obj.OnLinkActivated ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Hyperlink), ConnectionMethod="OverrideLinkActivated")]
+		protected virtual void OnLinkActivated ()
+		{
+			InternalLinkActivated ();
+		}
+
+		private void InternalLinkActivated ()
+		{
+			LinkActivatedNativeDelegate unmanaged = class_abi.BaseOverride<LinkActivatedNativeDelegate>(this.LookupGType(), "link_activated");
+			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_uri"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // get_uri
+							, null
+							, "get_object"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_object"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_object
+							, "get_uri"
+							, "get_end_index"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_end_index"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_end_index
+							, "get_object"
+							, "get_start_index"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_start_index"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_start_index
+							, "get_end_index"
+							, "is_valid"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("is_valid"
+							, -1
+							, (uint) sizeof( IntPtr ) // is_valid
+							, "get_start_index"
+							, "get_n_anchors"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_n_anchors"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_n_anchors
+							, "is_valid"
+							, "link_state"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("link_state"
+							, -1
+							, (uint) sizeof( IntPtr ) // link_state
+							, "get_n_anchors"
+							, "is_selected_link"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("is_selected_link"
+							, -1
+							, (uint) sizeof( IntPtr ) // is_selected_link
+							, "link_state"
+							, "link_activated"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("link_activated"
+							, -1
+							, (uint) sizeof( IntPtr ) // link_activated
+							, "is_selected_link"
+							, "pad1"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("pad1"
+							, -1
+							, (uint) sizeof( IntPtr ) // pad1
+							, "link_activated"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_hyperlink_get_n_anchors(IntPtr raw);
+		static d_atk_hyperlink_get_n_anchors atk_hyperlink_get_n_anchors = FuncLoader.LoadFunction<d_atk_hyperlink_get_n_anchors>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_get_n_anchors"));
+
+		public int NAnchors { 
+			get {
+				int raw_ret = atk_hyperlink_get_n_anchors(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_hyperlink_get_object(IntPtr raw, int i);
+		static d_atk_hyperlink_get_object atk_hyperlink_get_object = FuncLoader.LoadFunction<d_atk_hyperlink_get_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_get_object"));
+
+		public Atk.Object GetObject(int i) {
+			IntPtr raw_ret = atk_hyperlink_get_object(Handle, i);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_hyperlink_get_type();
+		static d_atk_hyperlink_get_type atk_hyperlink_get_type = FuncLoader.LoadFunction<d_atk_hyperlink_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_hyperlink_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_hyperlink_get_uri(IntPtr raw, int i);
+		static d_atk_hyperlink_get_uri atk_hyperlink_get_uri = FuncLoader.LoadFunction<d_atk_hyperlink_get_uri>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_get_uri"));
+
+		public string GetUri(int i) {
+			IntPtr raw_ret = atk_hyperlink_get_uri(Handle, i);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_hyperlink_is_inline(IntPtr raw);
+		static d_atk_hyperlink_is_inline atk_hyperlink_is_inline = FuncLoader.LoadFunction<d_atk_hyperlink_is_inline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_is_inline"));
+
+		public bool IsInline { 
+			get {
+				bool raw_ret = atk_hyperlink_is_inline(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_hyperlink_is_selected_link(IntPtr raw);
+		static d_atk_hyperlink_is_selected_link atk_hyperlink_is_selected_link = FuncLoader.LoadFunction<d_atk_hyperlink_is_selected_link>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_is_selected_link"));
+
+		[Obsolete]
+		public bool IsSelectedLink { 
+			get {
+				bool raw_ret = atk_hyperlink_is_selected_link(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_hyperlink_is_valid(IntPtr raw);
+		static d_atk_hyperlink_is_valid atk_hyperlink_is_valid = FuncLoader.LoadFunction<d_atk_hyperlink_is_valid>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_is_valid"));
+
+		public bool IsValid { 
+			get {
+				bool raw_ret = atk_hyperlink_is_valid(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_action_do_action(IntPtr raw, int i);
+		static d_atk_action_do_action atk_action_do_action = FuncLoader.LoadFunction<d_atk_action_do_action>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_do_action"));
+
+		public bool DoAction(int i) {
+			bool raw_ret = atk_action_do_action(Handle, i);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_description(IntPtr raw, int i);
+		static d_atk_action_get_description atk_action_get_description = FuncLoader.LoadFunction<d_atk_action_get_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_description"));
+
+		public string GetDescription(int i) {
+			IntPtr raw_ret = atk_action_get_description(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_keybinding(IntPtr raw, int i);
+		static d_atk_action_get_keybinding atk_action_get_keybinding = FuncLoader.LoadFunction<d_atk_action_get_keybinding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_keybinding"));
+
+		public string GetKeybinding(int i) {
+			IntPtr raw_ret = atk_action_get_keybinding(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_localized_name(IntPtr raw, int i);
+		static d_atk_action_get_localized_name atk_action_get_localized_name = FuncLoader.LoadFunction<d_atk_action_get_localized_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_localized_name"));
+
+		public string GetLocalizedName(int i) {
+			IntPtr raw_ret = atk_action_get_localized_name(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_action_get_n_actions(IntPtr raw);
+		static d_atk_action_get_n_actions atk_action_get_n_actions = FuncLoader.LoadFunction<d_atk_action_get_n_actions>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_n_actions"));
+
+		public int NActions { 
+			get {
+				int raw_ret = atk_action_get_n_actions(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_action_get_name(IntPtr raw, int i);
+		static d_atk_action_get_name atk_action_get_name = FuncLoader.LoadFunction<d_atk_action_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_get_name"));
+
+		public string GetName(int i) {
+			IntPtr raw_ret = atk_action_get_name(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_action_set_description(IntPtr raw, int i, IntPtr desc);
+		static d_atk_action_set_description atk_action_set_description = FuncLoader.LoadFunction<d_atk_action_set_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_action_set_description"));
+
+		public bool SetDescription(int i, string desc) {
+			IntPtr native_desc = GLib.Marshaller.StringToPtrGStrdup (desc);
+			bool raw_ret = atk_action_set_description(Handle, i, native_desc);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_desc);
+			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/AtkSharp/Generated/Atk/HyperlinkImplAdapter.cs

@@ -0,0 +1,143 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class HyperlinkImplAdapter : GLib.GInterfaceAdapter, Atk.IHyperlinkImpl {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkHyperlinkImplIface {
+			public GetHyperlinkNativeDelegate GetHyperlink;
+		}
+
+		static AtkHyperlinkImplIface iface;
+
+		static HyperlinkImplAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (HyperlinkImplAdapter));
+			iface.GetHyperlink = new GetHyperlinkNativeDelegate (GetHyperlink_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetHyperlinkNativeDelegate (IntPtr inst);
+
+		static IntPtr GetHyperlink_cb (IntPtr inst)
+		{
+			try {
+				IHyperlinkImplImplementor __obj = GLib.Object.GetObject (inst, false) as IHyperlinkImplImplementor;
+				Atk.Hyperlink __result;
+				__result = __obj.Hyperlink;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} 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);
+			AtkHyperlinkImplIface native_iface = (AtkHyperlinkImplIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkHyperlinkImplIface));
+			native_iface.GetHyperlink = iface.GetHyperlink;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public HyperlinkImplAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public HyperlinkImplAdapter (IHyperlinkImplImplementor 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 HyperlinkImplAdapter (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_atk_hyperlink_impl_get_type();
+		static d_atk_hyperlink_impl_get_type atk_hyperlink_impl_get_type = FuncLoader.LoadFunction<d_atk_hyperlink_impl_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_impl_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_hyperlink_impl_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 IHyperlinkImpl GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IHyperlinkImpl GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IHyperlinkImplImplementor)
+				return new HyperlinkImplAdapter (obj as IHyperlinkImplImplementor);
+			else if (obj as IHyperlinkImpl == null)
+				return new HyperlinkImplAdapter (obj.Handle);
+			else
+				return obj as IHyperlinkImpl;
+		}
+
+		public IHyperlinkImplImplementor Implementor {
+			get {
+				return implementor as IHyperlinkImplImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_hyperlink_impl_get_hyperlink(IntPtr raw);
+		static d_atk_hyperlink_impl_get_hyperlink atk_hyperlink_impl_get_hyperlink = FuncLoader.LoadFunction<d_atk_hyperlink_impl_get_hyperlink>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hyperlink_impl_get_hyperlink"));
+
+		public Atk.Hyperlink Hyperlink { 
+			get {
+				IntPtr raw_ret = atk_hyperlink_impl_get_hyperlink(Handle);
+				Atk.Hyperlink ret = GLib.Object.GetObject(raw_ret) as Atk.Hyperlink;
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/HyperlinkStateFlags.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/HypertextAdapter.cs

@@ -0,0 +1,214 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class HypertextAdapter : GLib.GInterfaceAdapter, Atk.IHypertext {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkHypertextIface {
+			public GetLinkNativeDelegate GetLink;
+			public GetNLinksNativeDelegate GetNLinks;
+			public GetLinkIndexNativeDelegate GetLinkIndex;
+			IntPtr LinkSelected;
+		}
+
+		static AtkHypertextIface iface;
+
+		static HypertextAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (HypertextAdapter));
+			iface.GetLink = new GetLinkNativeDelegate (GetLink_cb);
+			iface.GetNLinks = new GetNLinksNativeDelegate (GetNLinks_cb);
+			iface.GetLinkIndex = new GetLinkIndexNativeDelegate (GetLinkIndex_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetLinkNativeDelegate (IntPtr inst, int link_index);
+
+		static IntPtr GetLink_cb (IntPtr inst, int link_index)
+		{
+			try {
+				IHypertextImplementor __obj = GLib.Object.GetObject (inst, false) as IHypertextImplementor;
+				Atk.Hyperlink __result;
+				__result = __obj.GetLink (link_index);
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetNLinksNativeDelegate (IntPtr inst);
+
+		static int GetNLinks_cb (IntPtr inst)
+		{
+			try {
+				IHypertextImplementor __obj = GLib.Object.GetObject (inst, false) as IHypertextImplementor;
+				int __result;
+				__result = __obj.NLinks;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetLinkIndexNativeDelegate (IntPtr inst, int char_index);
+
+		static int GetLinkIndex_cb (IntPtr inst, int char_index)
+		{
+			try {
+				IHypertextImplementor __obj = GLib.Object.GetObject (inst, false) as IHypertextImplementor;
+				int __result;
+				__result = __obj.GetLinkIndex (char_index);
+				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);
+			AtkHypertextIface native_iface = (AtkHypertextIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkHypertextIface));
+			native_iface.GetLink = iface.GetLink;
+			native_iface.GetNLinks = iface.GetNLinks;
+			native_iface.GetLinkIndex = iface.GetLinkIndex;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public HypertextAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public HypertextAdapter (IHypertextImplementor 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 HypertextAdapter (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_atk_hypertext_get_type();
+		static d_atk_hypertext_get_type atk_hypertext_get_type = FuncLoader.LoadFunction<d_atk_hypertext_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hypertext_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_hypertext_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 IHypertext GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IHypertext GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IHypertextImplementor)
+				return new HypertextAdapter (obj as IHypertextImplementor);
+			else if (obj as IHypertext == null)
+				return new HypertextAdapter (obj.Handle);
+			else
+				return obj as IHypertext;
+		}
+
+		public IHypertextImplementor Implementor {
+			get {
+				return implementor as IHypertextImplementor;
+			}
+		}
+
+		[GLib.Signal("link_selected")]
+		public event Atk.LinkSelectedHandler LinkSelected {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("link_selected", value, typeof (Atk.LinkSelectedArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("link_selected", value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_hypertext_get_link(IntPtr raw, int link_index);
+		static d_atk_hypertext_get_link atk_hypertext_get_link = FuncLoader.LoadFunction<d_atk_hypertext_get_link>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hypertext_get_link"));
+
+		public Atk.Hyperlink GetLink(int link_index) {
+			IntPtr raw_ret = atk_hypertext_get_link(Handle, link_index);
+			Atk.Hyperlink ret = GLib.Object.GetObject(raw_ret) as Atk.Hyperlink;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_hypertext_get_link_index(IntPtr raw, int char_index);
+		static d_atk_hypertext_get_link_index atk_hypertext_get_link_index = FuncLoader.LoadFunction<d_atk_hypertext_get_link_index>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hypertext_get_link_index"));
+
+		public int GetLinkIndex(int char_index) {
+			int raw_ret = atk_hypertext_get_link_index(Handle, char_index);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_hypertext_get_n_links(IntPtr raw);
+		static d_atk_hypertext_get_n_links atk_hypertext_get_n_links = FuncLoader.LoadFunction<d_atk_hypertext_get_n_links>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_hypertext_get_n_links"));
+
+		public int NLinks { 
+			get {
+				int raw_ret = atk_hypertext_get_n_links(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IAction.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IAction : GLib.IWrapper {
+
+		bool DoAction(int i);
+		string GetDescription(int i);
+		string GetKeybinding(int i);
+		string GetLocalizedName(int i);
+		int NActions { 
+			get;
+		}
+		string GetName(int i);
+		bool SetDescription(int i, string desc);
+	}
+
+	[GLib.GInterface (typeof (ActionAdapter))]
+	public partial interface IActionImplementor : GLib.IWrapper {
+
+		bool DoAction (int i);
+		int NActions { get; }
+		string GetDescription (int i);
+		string GetName (int i);
+		string GetKeybinding (int i);
+		bool SetDescription (int i, string desc);
+		string GetLocalizedName (int i);
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IComponent.cs

@@ -0,0 +1,53 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IComponent : GLib.IWrapper {
+
+		event Atk.BoundsChangedHandler BoundsChanged;
+		uint AddFocusHandler(Atk.FocusHandler handler);
+		bool Contains(int x, int y, Atk.CoordType coord_type);
+		double Alpha { 
+			get;
+		}
+		void GetExtents(out int x, out int y, out int width, out int height, Atk.CoordType coord_type);
+		Atk.Layer Layer { 
+			get;
+		}
+		int MdiZorder { 
+			get;
+		}
+		void GetPosition(out int x, out int y, Atk.CoordType coord_type);
+		void GetSize(out int width, out int height);
+		bool GrabFocus();
+		Atk.Object RefAccessibleAtPoint(int x, int y, Atk.CoordType coord_type);
+		void RemoveFocusHandler(uint handler_id);
+		bool SetExtents(int x, int y, int width, int height, Atk.CoordType coord_type);
+		bool SetPosition(int x, int y, Atk.CoordType coord_type);
+		bool SetSize(int width, int height);
+	}
+
+	[GLib.GInterface (typeof (ComponentAdapter))]
+	public partial interface IComponentImplementor : GLib.IWrapper {
+
+		uint AddFocusHandler (Atk.FocusHandler handler);
+		bool Contains (int x, int y, Atk.CoordType coord_type);
+		Atk.Object RefAccessibleAtPoint (int x, int y, Atk.CoordType coord_type);
+		void GetExtents (out int x, out int y, out int width, out int height, Atk.CoordType coord_type);
+		void GetPosition (out int x, out int y, Atk.CoordType coord_type);
+		void GetSize (out int width, out int height);
+		bool GrabFocus ();
+		void RemoveFocusHandler (uint handler_id);
+		bool SetExtents (int x, int y, int width, int height, Atk.CoordType coord_type);
+		bool SetPosition (int x, int y, Atk.CoordType coord_type);
+		bool SetSize (int width, int height);
+		Atk.Layer Layer { get; }
+		int MdiZorder { get; }
+		double Alpha { get; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IDocument.cs

@@ -0,0 +1,50 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IDocument : GLib.IWrapper {
+
+		event System.EventHandler Reload;
+		event System.EventHandler LoadComplete;
+		event System.EventHandler LoadStopped;
+		event Atk.PageChangedHandler PageChanged;
+		string GetAttributeValue(string attribute_name);
+		Atk.Attribute[] Attributes { 
+			get;
+		}
+		int CurrentPageNumber { 
+			get;
+		}
+		IntPtr TheDocument { 
+			get;
+		}
+		string DocumentType { 
+			get;
+		}
+		string Locale { 
+			get;
+		}
+		int PageCount { 
+			get;
+		}
+		bool SetAttributeValue(string attribute_name, string attribute_value);
+	}
+
+	[GLib.GInterface (typeof (DocumentAdapter))]
+	public partial interface IDocumentImplementor : GLib.IWrapper {
+
+		string DocumentType { get; }
+		IntPtr TheDocument { get; }
+		string Locale { get; }
+		Atk.Attribute[] Attributes { get; }
+		string GetAttributeValue (string attribute_name);
+		bool SetAttributeValue (string attribute_name, string attribute_value);
+		int CurrentPageNumber { get; }
+		int PageCount { get; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IEditableText.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IEditableText : GLib.IWrapper {
+
+		void CopyText(int start_pos, int end_pos);
+		void CutText(int start_pos, int end_pos);
+		void DeleteText(int start_pos, int end_pos);
+		void InsertText(string str1ng, ref int position);
+		void PasteText(int position);
+		bool SetRunAttributes(GLib.SList attrib_set, int start_offset, int end_offset);
+		string TextContents { 
+			set;
+		}
+	}
+
+	[GLib.GInterface (typeof (EditableTextAdapter))]
+	public partial interface IEditableTextImplementor : GLib.IWrapper {
+
+		bool SetRunAttributes (GLib.SList attrib_set, int start_offset, int end_offset);
+		string TextContents { set; }
+		void InsertText (string str1ng, ref int position);
+		void CopyText (int start_pos, int end_pos);
+		void CutText (int start_pos, int end_pos);
+		void DeleteText (int start_pos, int end_pos);
+		void PasteText (int position);
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IHyperlinkImpl.cs

@@ -0,0 +1,22 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IHyperlinkImpl : GLib.IWrapper {
+
+		Atk.Hyperlink Hyperlink { 
+			get;
+		}
+	}
+
+	[GLib.GInterface (typeof (HyperlinkImplAdapter))]
+	public partial interface IHyperlinkImplImplementor : GLib.IWrapper {
+
+		Atk.Hyperlink Hyperlink { get; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IHypertext.cs

@@ -0,0 +1,27 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IHypertext : GLib.IWrapper {
+
+		event Atk.LinkSelectedHandler LinkSelected;
+		Atk.Hyperlink GetLink(int link_index);
+		int GetLinkIndex(int char_index);
+		int NLinks { 
+			get;
+		}
+	}
+
+	[GLib.GInterface (typeof (HypertextAdapter))]
+	public partial interface IHypertextImplementor : GLib.IWrapper {
+
+		Atk.Hyperlink GetLink (int link_index);
+		int NLinks { get; }
+		int GetLinkIndex (int char_index);
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IImage.cs

@@ -0,0 +1,32 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IImage : GLib.IWrapper {
+
+		string ImageDescription { 
+			get;
+		}
+		string ImageLocale { 
+			get;
+		}
+		void GetImagePosition(out int x, out int y, Atk.CoordType coord_type);
+		void GetImageSize(out int width, out int height);
+		bool SetImageDescription(string description);
+	}
+
+	[GLib.GInterface (typeof (ImageAdapter))]
+	public partial interface IImageImplementor : GLib.IWrapper {
+
+		void GetImagePosition (out int x, out int y, Atk.CoordType coord_type);
+		string ImageDescription { get; }
+		void GetImageSize (out int width, out int height);
+		bool SetImageDescription (string description);
+		string ImageLocale { get; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IImplementor.cs

@@ -0,0 +1,20 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IImplementor : GLib.IWrapper {
+
+		Atk.Object RefAccessible();
+	}
+
+	[GLib.GInterface (typeof (ImplementorAdapter))]
+	public partial interface IImplementorImplementor : GLib.IWrapper {
+
+		Atk.Object RefAccessible ();
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ISelection.cs

@@ -0,0 +1,35 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface ISelection : GLib.IWrapper {
+
+		event System.EventHandler SelectionChanged;
+		bool AddSelection(int i);
+		bool ClearSelection();
+		int SelectionCount { 
+			get;
+		}
+		bool IsChildSelected(int i);
+		Atk.Object RefSelection(int i);
+		bool RemoveSelection(int i);
+		bool SelectAllSelection();
+	}
+
+	[GLib.GInterface (typeof (SelectionAdapter))]
+	public partial interface ISelectionImplementor : GLib.IWrapper {
+
+		bool AddSelection (int i);
+		bool ClearSelection ();
+		Atk.Object RefSelection (int i);
+		int SelectionCount { get; }
+		bool IsChildSelected (int i);
+		bool RemoveSelection (int i);
+		bool SelectAllSelection ();
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IStreamableContent.cs

@@ -0,0 +1,28 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IStreamableContent : GLib.IWrapper {
+
+		string GetMimeType(int i);
+		int NMimeTypes { 
+			get;
+		}
+		IntPtr GetStream(string mime_type);
+		string GetUri(string mime_type);
+	}
+
+	[GLib.GInterface (typeof (StreamableContentAdapter))]
+	public partial interface IStreamableContentImplementor : GLib.IWrapper {
+
+		int NMimeTypes { get; }
+		string GetMimeType (int i);
+		IntPtr GetStream (string mime_type);
+		string GetUri (string mime_type);
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ITable.cs

@@ -0,0 +1,87 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface ITable : GLib.IWrapper {
+
+		event Atk.ColumnInsertedHandler ColumnInserted;
+		event Atk.RowDeletedHandler RowDeleted;
+		event System.EventHandler RowReordered;
+		event Atk.ColumnDeletedHandler ColumnDeleted;
+		event Atk.RowInsertedHandler RowInserted;
+		event System.EventHandler ColumnReordered;
+		event System.EventHandler ModelChanged;
+		bool AddColumnSelection(int column);
+		bool AddRowSelection(int row);
+		Atk.Object Caption { 
+			get; set;
+		}
+		int GetColumnAtIndex(int index_);
+		string GetColumnDescription(int column);
+		int GetColumnExtentAt(int row, int column);
+		Atk.Object GetColumnHeader(int column);
+		int GetIndexAt(int row, int column);
+		int NColumns { 
+			get;
+		}
+		int NRows { 
+			get;
+		}
+		int GetRowAtIndex(int index_);
+		string GetRowDescription(int row);
+		int GetRowExtentAt(int row, int column);
+		Atk.Object GetRowHeader(int row);
+		int GetSelectedColumns(out int selected);
+		int GetSelectedRows(out int selected);
+		Atk.Object Summary { 
+			get; set;
+		}
+		bool IsColumnSelected(int column);
+		bool IsRowSelected(int row);
+		bool IsSelected(int row, int column);
+		Atk.Object RefAt(int row, int column);
+		bool RemoveColumnSelection(int column);
+		bool RemoveRowSelection(int row);
+		void SetColumnDescription(int column, string description);
+		void SetColumnHeader(int column, Atk.Object header);
+		void SetRowDescription(int row, string description);
+		void SetRowHeader(int row, Atk.Object header);
+	}
+
+	[GLib.GInterface (typeof (TableAdapter))]
+	public partial interface ITableImplementor : GLib.IWrapper {
+
+		Atk.Object RefAt (int row, int column);
+		int GetIndexAt (int row, int column);
+		int GetColumnAtIndex (int index_);
+		int GetRowAtIndex (int index_);
+		int NColumns { get; }
+		int NRows { get; }
+		int GetColumnExtentAt (int row, int column);
+		int GetRowExtentAt (int row, int column);
+		Atk.Object Caption { get; set; }
+		string GetColumnDescription (int column);
+		Atk.Object GetColumnHeader (int column);
+		string GetRowDescription (int row);
+		Atk.Object GetRowHeader (int row);
+		Atk.Object Summary { get; set; }
+		void SetColumnDescription (int column, string description);
+		void SetColumnHeader (int column, Atk.Object header);
+		void SetRowDescription (int row, string description);
+		void SetRowHeader (int row, Atk.Object header);
+		int GetSelectedColumns (out int selected);
+		int GetSelectedRows (out int selected);
+		bool IsColumnSelected (int column);
+		bool IsRowSelected (int row);
+		bool IsSelected (int row, int column);
+		bool AddRowSelection (int row);
+		bool RemoveRowSelection (int row);
+		bool AddColumnSelection (int column);
+		bool RemoveColumnSelection (int column);
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ITableCell.cs

@@ -0,0 +1,42 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface ITableCell : GLib.IWrapper {
+
+		GLib.PtrArray ColumnHeaderCells { 
+			get;
+		}
+		int ColumnSpan { 
+			get;
+		}
+		bool GetPosition(out int row, out int column);
+		bool GetRowColumnSpan(out int row, out int column, out int row_span, out int column_span);
+		GLib.PtrArray RowHeaderCells { 
+			get;
+		}
+		int RowSpan { 
+			get;
+		}
+		Atk.Object Table { 
+			get;
+		}
+	}
+
+	[GLib.GInterface (typeof (TableCellAdapter))]
+	public partial interface ITableCellImplementor : GLib.IWrapper {
+
+		int ColumnSpan { get; }
+		GLib.PtrArray ColumnHeaderCells { get; }
+		bool GetPosition (out int row, out int column);
+		int RowSpan { get; }
+		GLib.PtrArray RowHeaderCells { get; }
+		bool GetRowColumnSpan (out int row, out int column, out int row_span, out int column_span);
+		Atk.Object Table { get; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IText.cs

@@ -0,0 +1,72 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IText : GLib.IWrapper {
+
+		event Atk.TextInsertHandler TextInsert;
+		event Atk.TextRemoveHandler TextRemove;
+		event System.EventHandler TextAttributesChanged;
+		event Atk.TextCaretMovedHandler TextCaretMoved;
+		event Atk.TextChangedHandler TextChanged;
+		event System.EventHandler TextSelectionChanged;
+		bool AddSelection(int start_offset, int end_offset);
+		Atk.TextRange GetBoundedRanges(Atk.TextRectangle rect, Atk.CoordType coord_type, Atk.TextClipType x_clip_type, Atk.TextClipType y_clip_type);
+		int CaretOffset { 
+			get;
+		}
+		char GetCharacterAtOffset(int offset);
+		int CharacterCount { 
+			get;
+		}
+		void GetCharacterExtents(int offset, out int x, out int y, out int width, out int height, Atk.CoordType coords);
+		Atk.Attribute[] DefaultAttributes { 
+			get;
+		}
+		int NSelections { 
+			get;
+		}
+		int GetOffsetAtPoint(int x, int y, Atk.CoordType coords);
+		Atk.TextRectangle GetRangeExtents(int start_offset, int end_offset, Atk.CoordType coord_type);
+		Atk.Attribute[] GetRunAttributes(int offset, out int start_offset, out int end_offset);
+		string GetSelection(int selection_num, out int start_offset, out int end_offset);
+		string GetStringAtOffset(int offset, Atk.TextGranularity granularity, out int start_offset, out int end_offset);
+		string GetText(int start_offset, int end_offset);
+		string GetTextAfterOffset(int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset);
+		string GetTextAtOffset(int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset);
+		string GetTextBeforeOffset(int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset);
+		bool RemoveSelection(int selection_num);
+		bool SetCaretOffset(int offset);
+		bool SetSelection(int selection_num, int start_offset, int end_offset);
+	}
+
+	[GLib.GInterface (typeof (TextAdapter))]
+	public partial interface ITextImplementor : GLib.IWrapper {
+
+		string GetText (int start_offset, int end_offset);
+		string GetTextAfterOffset (int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset);
+		string GetTextAtOffset (int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset);
+		char GetCharacterAtOffset (int offset);
+		string GetTextBeforeOffset (int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset);
+		int CaretOffset { get; }
+		Atk.Attribute[] GetRunAttributes (int offset, out int start_offset, out int end_offset);
+		Atk.Attribute[] DefaultAttributes { get; }
+		void GetCharacterExtents (int offset, out int x, out int y, out int width, out int height, Atk.CoordType coords);
+		int CharacterCount { get; }
+		int GetOffsetAtPoint (int x, int y, Atk.CoordType coords);
+		int NSelections { get; }
+		string GetSelection (int selection_num, out int start_offset, out int end_offset);
+		bool AddSelection (int start_offset, int end_offset);
+		bool RemoveSelection (int selection_num);
+		bool SetSelection (int selection_num, int start_offset, int end_offset);
+		bool SetCaretOffset (int offset);
+		void GetRangeExtents (int start_offset, int end_offset, Atk.CoordType coord_type, out Atk.TextRectangle rect);
+		Atk.TextRange GetBoundedRanges (Atk.TextRectangle rect, Atk.CoordType coord_type, Atk.TextClipType x_clip_type, Atk.TextClipType y_clip_type);
+		string GetStringAtOffset (int offset, Atk.TextGranularity granularity, out int start_offset, out int end_offset);
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IValue.cs

@@ -0,0 +1,47 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IValue : GLib.IWrapper {
+
+		event Atk.ValueChangedHandler ValueChanged;
+		void GetCurrentValue(ref GLib.Value value);
+		double Increment { 
+			get;
+		}
+		void GetMaximumValue(ref GLib.Value value);
+		void GetMinimumIncrement(ref GLib.Value value);
+		void GetMinimumValue(ref GLib.Value value);
+		Atk.Range Range { 
+			get;
+		}
+		GLib.SList SubRanges { 
+			get;
+		}
+		double GetValueAndText(string text);
+		bool SetCurrentValue(GLib.Value value);
+		double Value { 
+			set;
+		}
+	}
+
+	[GLib.GInterface (typeof (ValueAdapter))]
+	public partial interface IValueImplementor : GLib.IWrapper {
+
+		void GetCurrentValue (ref GLib.Value value);
+		void GetMaximumValue (ref GLib.Value value);
+		void GetMinimumValue (ref GLib.Value value);
+		bool SetCurrentValue (GLib.Value value);
+		void GetMinimumIncrement (ref GLib.Value value);
+		void GetValueAndText (out double value, string text);
+		Atk.Range Range { get; }
+		double Increment { get; }
+		GLib.SList SubRanges { get; }
+		double Value { set; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/IWindow.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IWindow : GLib.IWrapper {
+
+	}
+
+	[GLib.GInterface (typeof (WindowAdapter))]
+	public partial interface IWindowImplementor : GLib.IWrapper {
+
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ImageAdapter.cs

@@ -0,0 +1,259 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ImageAdapter : GLib.GInterfaceAdapter, Atk.IImage {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkImageIface {
+			public GetImagePositionNativeDelegate GetImagePosition;
+			public GetImageDescriptionNativeDelegate GetImageDescription;
+			public GetImageSizeNativeDelegate GetImageSize;
+			public SetImageDescriptionNativeDelegate SetImageDescription;
+			public GetImageLocaleNativeDelegate GetImageLocale;
+		}
+
+		static AtkImageIface iface;
+
+		static ImageAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (ImageAdapter));
+			iface.GetImagePosition = new GetImagePositionNativeDelegate (GetImagePosition_cb);
+			iface.GetImageDescription = new GetImageDescriptionNativeDelegate (GetImageDescription_cb);
+			iface.GetImageSize = new GetImageSizeNativeDelegate (GetImageSize_cb);
+			iface.SetImageDescription = new SetImageDescriptionNativeDelegate (SetImageDescription_cb);
+			iface.GetImageLocale = new GetImageLocaleNativeDelegate (GetImageLocale_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetImagePositionNativeDelegate (IntPtr inst, out int x, out int y, int coord_type);
+
+		static void GetImagePosition_cb (IntPtr inst, out int x, out int y, int coord_type)
+		{
+			try {
+				IImageImplementor __obj = GLib.Object.GetObject (inst, false) as IImageImplementor;
+				__obj.GetImagePosition (out x, out y, (Atk.CoordType) coord_type);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetImageDescriptionNativeDelegate (IntPtr inst);
+
+		static IntPtr GetImageDescription_cb (IntPtr inst)
+		{
+			try {
+				IImageImplementor __obj = GLib.Object.GetObject (inst, false) as IImageImplementor;
+				string __result;
+				__result = __obj.ImageDescription;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetImageSizeNativeDelegate (IntPtr inst, out int width, out int height);
+
+		static void GetImageSize_cb (IntPtr inst, out int width, out int height)
+		{
+			try {
+				IImageImplementor __obj = GLib.Object.GetObject (inst, false) as IImageImplementor;
+				__obj.GetImageSize (out width, out height);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetImageDescriptionNativeDelegate (IntPtr inst, IntPtr description);
+
+		static bool SetImageDescription_cb (IntPtr inst, IntPtr description)
+		{
+			try {
+				IImageImplementor __obj = GLib.Object.GetObject (inst, false) as IImageImplementor;
+				bool __result;
+				__result = __obj.SetImageDescription (GLib.Marshaller.Utf8PtrToString (description));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetImageLocaleNativeDelegate (IntPtr inst);
+
+		static IntPtr GetImageLocale_cb (IntPtr inst)
+		{
+			try {
+				IImageImplementor __obj = GLib.Object.GetObject (inst, false) as IImageImplementor;
+				string __result;
+				__result = __obj.ImageLocale;
+				return GLib.Marshaller.StringToPtrGStrdup(__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);
+			AtkImageIface native_iface = (AtkImageIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkImageIface));
+			native_iface.GetImagePosition = iface.GetImagePosition;
+			native_iface.GetImageDescription = iface.GetImageDescription;
+			native_iface.GetImageSize = iface.GetImageSize;
+			native_iface.SetImageDescription = iface.SetImageDescription;
+			native_iface.GetImageLocale = iface.GetImageLocale;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public ImageAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public ImageAdapter (IImageImplementor 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 ImageAdapter (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_atk_image_get_type();
+		static d_atk_image_get_type atk_image_get_type = FuncLoader.LoadFunction<d_atk_image_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_image_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_image_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 IImage GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IImage GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IImageImplementor)
+				return new ImageAdapter (obj as IImageImplementor);
+			else if (obj as IImage == null)
+				return new ImageAdapter (obj.Handle);
+			else
+				return obj as IImage;
+		}
+
+		public IImageImplementor Implementor {
+			get {
+				return implementor as IImageImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_image_get_image_description(IntPtr raw);
+		static d_atk_image_get_image_description atk_image_get_image_description = FuncLoader.LoadFunction<d_atk_image_get_image_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_image_get_image_description"));
+
+		public string ImageDescription { 
+			get {
+				IntPtr raw_ret = atk_image_get_image_description(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_image_get_image_locale(IntPtr raw);
+		static d_atk_image_get_image_locale atk_image_get_image_locale = FuncLoader.LoadFunction<d_atk_image_get_image_locale>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_image_get_image_locale"));
+
+		public string ImageLocale { 
+			get {
+				IntPtr raw_ret = atk_image_get_image_locale(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_image_get_image_position(IntPtr raw, out int x, out int y, int coord_type);
+		static d_atk_image_get_image_position atk_image_get_image_position = FuncLoader.LoadFunction<d_atk_image_get_image_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_image_get_image_position"));
+
+		public void GetImagePosition(out int x, out int y, Atk.CoordType coord_type) {
+			atk_image_get_image_position(Handle, out x, out y, (int) coord_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_image_get_image_size(IntPtr raw, out int width, out int height);
+		static d_atk_image_get_image_size atk_image_get_image_size = FuncLoader.LoadFunction<d_atk_image_get_image_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_image_get_image_size"));
+
+		public void GetImageSize(out int width, out int height) {
+			atk_image_get_image_size(Handle, out width, out height);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_image_set_image_description(IntPtr raw, IntPtr description);
+		static d_atk_image_set_image_description atk_image_set_image_description = FuncLoader.LoadFunction<d_atk_image_set_image_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_image_set_image_description"));
+
+		public bool SetImageDescription(string description) {
+			IntPtr native_description = GLib.Marshaller.StringToPtrGStrdup (description);
+			bool raw_ret = atk_image_set_image_description(Handle, native_description);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_description);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ImplementorAdapter.cs

@@ -0,0 +1,141 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ImplementorAdapter : GLib.GInterfaceAdapter, Atk.IImplementor {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkImplementorIface {
+			public RefAccessibleNativeDelegate RefAccessible;
+		}
+
+		static AtkImplementorIface iface;
+
+		static ImplementorAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (ImplementorAdapter));
+			iface.RefAccessible = new RefAccessibleNativeDelegate (RefAccessible_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr RefAccessibleNativeDelegate (IntPtr inst);
+
+		static IntPtr RefAccessible_cb (IntPtr inst)
+		{
+			try {
+				IImplementorImplementor __obj = GLib.Object.GetObject (inst, false) as IImplementorImplementor;
+				Atk.Object __result;
+				__result = __obj.RefAccessible ();
+				return __result == null ? IntPtr.Zero : __result.OwnedHandle;
+			} 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);
+			AtkImplementorIface native_iface = (AtkImplementorIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkImplementorIface));
+			native_iface.RefAccessible = iface.RefAccessible;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public ImplementorAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public ImplementorAdapter (IImplementorImplementor 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 ImplementorAdapter (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_atk_implementor_get_type();
+		static d_atk_implementor_get_type atk_implementor_get_type = FuncLoader.LoadFunction<d_atk_implementor_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_implementor_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_implementor_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 IImplementor GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IImplementor GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IImplementorImplementor)
+				return new ImplementorAdapter (obj as IImplementorImplementor);
+			else if (obj as IImplementor == null)
+				return new ImplementorAdapter (obj.Handle);
+			else
+				return obj as IImplementor;
+		}
+
+		public IImplementorImplementor Implementor {
+			get {
+				return implementor as IImplementorImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_implementor_ref_accessible(IntPtr raw);
+		static d_atk_implementor_ref_accessible atk_implementor_ref_accessible = FuncLoader.LoadFunction<d_atk_implementor_ref_accessible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_implementor_ref_accessible"));
+
+		public Atk.Object RefAccessible() {
+			IntPtr raw_ret = atk_implementor_ref_accessible(Handle);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/KeyEventStruct.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/KeyEventType.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/KeySnoopFunc.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Layer.cs

@@ -0,0 +1,35 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.LayerGType))]
+	public enum Layer {
+
+		Invalid,
+		Background,
+		Canvas,
+		Widget,
+		Mdi,
+		Popup,
+		Overlay,
+		Window,
+	}
+
+	internal class LayerGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_layer_get_type();
+		static d_atk_layer_get_type atk_layer_get_type = FuncLoader.LoadFunction<d_atk_layer_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_layer_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_layer_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/LinkSelectedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Misc.cs

@@ -0,0 +1,221 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Misc : GLib.Object {
+
+		public Misc (IntPtr raw) : base(raw) {}
+
+		protected Misc() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		static ThreadsEnterNativeDelegate ThreadsEnter_cb_delegate;
+		static ThreadsEnterNativeDelegate ThreadsEnterVMCallback {
+			get {
+				if (ThreadsEnter_cb_delegate == null)
+					ThreadsEnter_cb_delegate = new ThreadsEnterNativeDelegate (ThreadsEnter_cb);
+				return ThreadsEnter_cb_delegate;
+			}
+		}
+
+		static void OverrideThreadsEnter (GLib.GType gtype)
+		{
+			OverrideThreadsEnter (gtype, ThreadsEnterVMCallback);
+		}
+
+		static void OverrideThreadsEnter (GLib.GType gtype, ThreadsEnterNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("threads_enter"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ThreadsEnterNativeDelegate (IntPtr inst);
+
+		static void ThreadsEnter_cb (IntPtr inst)
+		{
+			try {
+				Misc __obj = GLib.Object.GetObject (inst, false) as Misc;
+				__obj.OnThreadsEnter ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Misc), ConnectionMethod="OverrideThreadsEnter")]
+		protected virtual void OnThreadsEnter ()
+		{
+			InternalThreadsEnter ();
+		}
+
+		private void InternalThreadsEnter ()
+		{
+			ThreadsEnterNativeDelegate unmanaged = class_abi.BaseOverride<ThreadsEnterNativeDelegate>(this.LookupGType(), "threads_enter");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static ThreadsLeaveNativeDelegate ThreadsLeave_cb_delegate;
+		static ThreadsLeaveNativeDelegate ThreadsLeaveVMCallback {
+			get {
+				if (ThreadsLeave_cb_delegate == null)
+					ThreadsLeave_cb_delegate = new ThreadsLeaveNativeDelegate (ThreadsLeave_cb);
+				return ThreadsLeave_cb_delegate;
+			}
+		}
+
+		static void OverrideThreadsLeave (GLib.GType gtype)
+		{
+			OverrideThreadsLeave (gtype, ThreadsLeaveVMCallback);
+		}
+
+		static void OverrideThreadsLeave (GLib.GType gtype, ThreadsLeaveNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("threads_leave"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ThreadsLeaveNativeDelegate (IntPtr inst);
+
+		static void ThreadsLeave_cb (IntPtr inst)
+		{
+			try {
+				Misc __obj = GLib.Object.GetObject (inst, false) as Misc;
+				__obj.OnThreadsLeave ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Misc), ConnectionMethod="OverrideThreadsLeave")]
+		protected virtual void OnThreadsLeave ()
+		{
+			InternalThreadsLeave ();
+		}
+
+		private void InternalThreadsLeave ()
+		{
+			ThreadsLeaveNativeDelegate unmanaged = class_abi.BaseOverride<ThreadsLeaveNativeDelegate>(this.LookupGType(), "threads_leave");
+			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("threads_enter"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // threads_enter
+							, null
+							, "threads_leave"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("threads_leave"
+							, -1
+							, (uint) sizeof( IntPtr ) // threads_leave
+							, "threads_enter"
+							, "vfuncs"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("vfuncs"
+							, -1
+							, (uint) sizeof( IntPtr ) * 32 // vfuncs
+							, "threads_leave"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_misc_get_instance();
+		static d_atk_misc_get_instance atk_misc_get_instance = FuncLoader.LoadFunction<d_atk_misc_get_instance>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_misc_get_instance"));
+
+		[Obsolete]
+		public static Atk.Misc Instance { 
+			get {
+				IntPtr raw_ret = atk_misc_get_instance();
+				Atk.Misc ret = GLib.Object.GetObject(raw_ret) as Atk.Misc;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_misc_get_type();
+		static d_atk_misc_get_type atk_misc_get_type = FuncLoader.LoadFunction<d_atk_misc_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_misc_get_type"));
+
+		[Obsolete]
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_misc_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_misc_threads_enter(IntPtr raw);
+		static d_atk_misc_threads_enter atk_misc_threads_enter = FuncLoader.LoadFunction<d_atk_misc_threads_enter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_misc_threads_enter"));
+
+		[Obsolete]
+		public void ThreadsEnter() {
+			atk_misc_threads_enter(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_misc_threads_leave(IntPtr raw);
+		static d_atk_misc_threads_leave atk_misc_threads_leave = FuncLoader.LoadFunction<d_atk_misc_threads_leave>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_misc_threads_leave"));
+
+		[Obsolete]
+		public void ThreadsLeave() {
+			atk_misc_threads_leave(Handle);
+		}
+
+
+		// 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/AtkSharp/Generated/Atk/NoOpObjectFactory.cs

@@ -0,0 +1,74 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class NoOpObjectFactory : Atk.ObjectFactory {
+
+		public NoOpObjectFactory (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_no_op_object_factory_new();
+		static d_atk_no_op_object_factory_new atk_no_op_object_factory_new = FuncLoader.LoadFunction<d_atk_no_op_object_factory_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_no_op_object_factory_new"));
+
+		public NoOpObjectFactory () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (NoOpObjectFactory)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = atk_no_op_object_factory_new();
+		}
+
+
+		// 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 (Atk.ObjectFactory.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_no_op_object_factory_get_type();
+		static d_atk_no_op_object_factory_get_type atk_no_op_object_factory_get_type = FuncLoader.LoadFunction<d_atk_no_op_object_factory_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_no_op_object_factory_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_no_op_object_factory_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 (Atk.ObjectFactory.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ObjectFactory.cs

@@ -0,0 +1,272 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class ObjectFactory : GLib.Object {
+
+		public ObjectFactory (IntPtr raw) : base(raw) {}
+
+		protected ObjectFactory() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		static CreateAccessibleNativeDelegate CreateAccessible_cb_delegate;
+		static CreateAccessibleNativeDelegate CreateAccessibleVMCallback {
+			get {
+				if (CreateAccessible_cb_delegate == null)
+					CreateAccessible_cb_delegate = new CreateAccessibleNativeDelegate (CreateAccessible_cb);
+				return CreateAccessible_cb_delegate;
+			}
+		}
+
+		public delegate Atk.Object CreateAccessibleDelegate (GLib.Object obj);
+		static CreateAccessibleDelegate create_accessible_handler;
+
+		public static CreateAccessibleDelegate CreateAccessibleHandler {
+			set {
+				create_accessible_handler = value;
+				OverrideCreateAccessible ((GLib.GType) typeof (ObjectFactory), value == null ? null : CreateAccessibleVMCallback);
+			}
+		}
+
+		static void OverrideCreateAccessible (GLib.GType gtype, CreateAccessibleNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("create_accessible"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr CreateAccessibleNativeDelegate (IntPtr obj);
+
+		static IntPtr CreateAccessible_cb (IntPtr obj)
+		{
+			try {
+				Atk.Object __result;
+				__result = create_accessible_handler (GLib.Object.GetObject (obj));
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		static InvalidateNativeDelegate Invalidate_cb_delegate;
+		static InvalidateNativeDelegate InvalidateVMCallback {
+			get {
+				if (Invalidate_cb_delegate == null)
+					Invalidate_cb_delegate = new InvalidateNativeDelegate (Invalidate_cb);
+				return Invalidate_cb_delegate;
+			}
+		}
+
+		static void OverrideInvalidate (GLib.GType gtype)
+		{
+			OverrideInvalidate (gtype, InvalidateVMCallback);
+		}
+
+		static void OverrideInvalidate (GLib.GType gtype, InvalidateNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("invalidate"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void InvalidateNativeDelegate (IntPtr inst);
+
+		static void Invalidate_cb (IntPtr inst)
+		{
+			try {
+				ObjectFactory __obj = GLib.Object.GetObject (inst, false) as ObjectFactory;
+				__obj.OnInvalidate ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.ObjectFactory), ConnectionMethod="OverrideInvalidate")]
+		protected virtual void OnInvalidate ()
+		{
+			InternalInvalidate ();
+		}
+
+		private void InternalInvalidate ()
+		{
+			InvalidateNativeDelegate unmanaged = class_abi.BaseOverride<InvalidateNativeDelegate>(this.LookupGType(), "invalidate");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static GetAccessibleTypeNativeDelegate GetAccessibleType_cb_delegate;
+		static GetAccessibleTypeNativeDelegate GetAccessibleTypeVMCallback {
+			get {
+				if (GetAccessibleType_cb_delegate == null)
+					GetAccessibleType_cb_delegate = new GetAccessibleTypeNativeDelegate (GetAccessibleType_cb);
+				return GetAccessibleType_cb_delegate;
+			}
+		}
+
+		public delegate GLib.GType GetAccessibleTypeDelegate ();
+		static GetAccessibleTypeDelegate get_accessible_type_handler;
+
+		public static GetAccessibleTypeDelegate GetAccessibleTypeHandler {
+			set {
+				get_accessible_type_handler = value;
+				OverrideGetAccessibleType ((GLib.GType) typeof (ObjectFactory), value == null ? null : GetAccessibleTypeVMCallback);
+			}
+		}
+
+		static void OverrideGetAccessibleType (GLib.GType gtype, GetAccessibleTypeNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_accessible_type"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetAccessibleTypeNativeDelegate ();
+
+		static IntPtr GetAccessibleType_cb ()
+		{
+			try {
+				GLib.GType __result;
+				__result = get_accessible_type_handler ();
+				return __result.Val;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+
+		// 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("create_accessible"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // create_accessible
+							, null
+							, "invalidate"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("invalidate"
+							, -1
+							, (uint) sizeof( IntPtr ) // invalidate
+							, "create_accessible"
+							, "get_accessible_type"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_accessible_type"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_accessible_type
+							, "invalidate"
+							, "pad1"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("pad1"
+							, -1
+							, (uint) sizeof( IntPtr ) // pad1
+							, "get_accessible_type"
+							, "pad2"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("pad2"
+							, -1
+							, (uint) sizeof( IntPtr ) // pad2
+							, "pad1"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_object_factory_create_accessible(IntPtr raw, IntPtr obj);
+		static d_atk_object_factory_create_accessible atk_object_factory_create_accessible = FuncLoader.LoadFunction<d_atk_object_factory_create_accessible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_object_factory_create_accessible"));
+
+		public Atk.Object CreateAccessible(GLib.Object obj) {
+			IntPtr raw_ret = atk_object_factory_create_accessible(Handle, obj == null ? IntPtr.Zero : obj.Handle);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_object_factory_get_accessible_type(IntPtr raw);
+		static d_atk_object_factory_get_accessible_type atk_object_factory_get_accessible_type = FuncLoader.LoadFunction<d_atk_object_factory_get_accessible_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_object_factory_get_accessible_type"));
+
+		public GLib.GType AccessibleType { 
+			get {
+				IntPtr raw_ret = atk_object_factory_get_accessible_type(Handle);
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_object_factory_get_type();
+		static d_atk_object_factory_get_type atk_object_factory_get_type = FuncLoader.LoadFunction<d_atk_object_factory_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_object_factory_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_object_factory_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_object_factory_invalidate(IntPtr raw);
+		static d_atk_object_factory_invalidate atk_object_factory_invalidate = FuncLoader.LoadFunction<d_atk_object_factory_invalidate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_object_factory_invalidate"));
+
+		public void Invalidate() {
+			atk_object_factory_invalidate(Handle);
+		}
+
+
+		// 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/AtkSharp/Generated/Atk/PageChangedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Plug.cs

@@ -0,0 +1,353 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Plug : Atk.Object, Atk.IComponent {
+
+		public Plug (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_plug_new();
+		static d_atk_plug_new atk_plug_new = FuncLoader.LoadFunction<d_atk_plug_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_plug_new"));
+
+		public Plug () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Plug)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = atk_plug_new();
+		}
+
+		static GetObjectIdNativeDelegate GetObjectId_cb_delegate;
+		static GetObjectIdNativeDelegate GetObjectIdVMCallback {
+			get {
+				if (GetObjectId_cb_delegate == null)
+					GetObjectId_cb_delegate = new GetObjectIdNativeDelegate (GetObjectId_cb);
+				return GetObjectId_cb_delegate;
+			}
+		}
+
+		static void OverrideGetObjectId (GLib.GType gtype)
+		{
+			OverrideGetObjectId (gtype, GetObjectIdVMCallback);
+		}
+
+		static void OverrideGetObjectId (GLib.GType gtype, GetObjectIdNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_object_id"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetObjectIdNativeDelegate (IntPtr inst);
+
+		static IntPtr GetObjectId_cb (IntPtr inst)
+		{
+			try {
+				Plug __obj = GLib.Object.GetObject (inst, false) as Plug;
+				string __result;
+				__result = __obj.OnGetObjectId ();
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Plug), ConnectionMethod="OverrideGetObjectId")]
+		protected virtual string OnGetObjectId ()
+		{
+			return InternalGetObjectId ();
+		}
+
+		private string InternalGetObjectId ()
+		{
+			GetObjectIdNativeDelegate unmanaged = class_abi.BaseOverride<GetObjectIdNativeDelegate>(this.LookupGType(), "get_object_id");
+			if (unmanaged == null) return null;
+
+			IntPtr __result = unmanaged (this.Handle);
+			return GLib.Marshaller.PtrToStringGFree(__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("get_object_id"
+							, Atk.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // get_object_id
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_plug_get_id(IntPtr raw);
+		static d_atk_plug_get_id atk_plug_get_id = FuncLoader.LoadFunction<d_atk_plug_get_id>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_plug_get_id"));
+
+		public string Id { 
+			get {
+				IntPtr raw_ret = atk_plug_get_id(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_plug_get_type();
+		static d_atk_plug_get_type atk_plug_get_type = FuncLoader.LoadFunction<d_atk_plug_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_plug_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_plug_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_component_add_focus_handler(IntPtr raw, AtkSharp.FocusHandlerNative handler);
+		static d_atk_component_add_focus_handler atk_component_add_focus_handler = FuncLoader.LoadFunction<d_atk_component_add_focus_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_add_focus_handler"));
+
+		[Obsolete]
+		public uint AddFocusHandler(Atk.FocusHandler handler) {
+			AtkSharp.FocusHandlerWrapper handler_wrapper = new AtkSharp.FocusHandlerWrapper (handler);
+			uint raw_ret = atk_component_add_focus_handler(Handle, handler_wrapper.NativeDelegate);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_contains(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_contains atk_component_contains = FuncLoader.LoadFunction<d_atk_component_contains>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_contains"));
+
+		public bool Contains(int x, int y, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_contains(Handle, x, y, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_atk_component_get_alpha(IntPtr raw);
+		static d_atk_component_get_alpha atk_component_get_alpha = FuncLoader.LoadFunction<d_atk_component_get_alpha>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_alpha"));
+
+		public double Alpha { 
+			get {
+				double raw_ret = atk_component_get_alpha(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_extents(IntPtr raw, out int x, out int y, out int width, out int height, int coord_type);
+		static d_atk_component_get_extents atk_component_get_extents = FuncLoader.LoadFunction<d_atk_component_get_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_extents"));
+
+		public void GetExtents(out int x, out int y, out int width, out int height, Atk.CoordType coord_type) {
+			atk_component_get_extents(Handle, out x, out y, out width, out height, (int) coord_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_component_get_layer(IntPtr raw);
+		static d_atk_component_get_layer atk_component_get_layer = FuncLoader.LoadFunction<d_atk_component_get_layer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_layer"));
+
+		public Atk.Layer Layer { 
+			get {
+				int raw_ret = atk_component_get_layer(Handle);
+				Atk.Layer ret = (Atk.Layer) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_component_get_mdi_zorder(IntPtr raw);
+		static d_atk_component_get_mdi_zorder atk_component_get_mdi_zorder = FuncLoader.LoadFunction<d_atk_component_get_mdi_zorder>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_mdi_zorder"));
+
+		public int MdiZorder { 
+			get {
+				int raw_ret = atk_component_get_mdi_zorder(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_position(IntPtr raw, out int x, out int y, int coord_type);
+		static d_atk_component_get_position atk_component_get_position = FuncLoader.LoadFunction<d_atk_component_get_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_position"));
+
+		[Obsolete]
+		public void GetPosition(out int x, out int y, Atk.CoordType coord_type) {
+			atk_component_get_position(Handle, out x, out y, (int) coord_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_size(IntPtr raw, out int width, out int height);
+		static d_atk_component_get_size atk_component_get_size = FuncLoader.LoadFunction<d_atk_component_get_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_size"));
+
+		[Obsolete]
+		public void GetSize(out int width, out int height) {
+			atk_component_get_size(Handle, out width, out height);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_grab_focus(IntPtr raw);
+		static d_atk_component_grab_focus atk_component_grab_focus = FuncLoader.LoadFunction<d_atk_component_grab_focus>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_grab_focus"));
+
+		public bool GrabFocus() {
+			bool raw_ret = atk_component_grab_focus(Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_component_ref_accessible_at_point(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_ref_accessible_at_point atk_component_ref_accessible_at_point = FuncLoader.LoadFunction<d_atk_component_ref_accessible_at_point>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_ref_accessible_at_point"));
+
+		public Atk.Object RefAccessibleAtPoint(int x, int y, Atk.CoordType coord_type) {
+			IntPtr raw_ret = atk_component_ref_accessible_at_point(Handle, x, y, (int) coord_type);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_remove_focus_handler(IntPtr raw, uint handler_id);
+		static d_atk_component_remove_focus_handler atk_component_remove_focus_handler = FuncLoader.LoadFunction<d_atk_component_remove_focus_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_remove_focus_handler"));
+
+		[Obsolete]
+		public void RemoveFocusHandler(uint handler_id) {
+			atk_component_remove_focus_handler(Handle, handler_id);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_extents(IntPtr raw, int x, int y, int width, int height, int coord_type);
+		static d_atk_component_set_extents atk_component_set_extents = FuncLoader.LoadFunction<d_atk_component_set_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_extents"));
+
+		public bool SetExtents(int x, int y, int width, int height, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_set_extents(Handle, x, y, width, height, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_position(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_set_position atk_component_set_position = FuncLoader.LoadFunction<d_atk_component_set_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_position"));
+
+		public bool SetPosition(int x, int y, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_set_position(Handle, x, y, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_size(IntPtr raw, int width, int height);
+		static d_atk_component_set_size atk_component_set_size = FuncLoader.LoadFunction<d_atk_component_set_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_size"));
+
+		public bool SetSize(int width, int height) {
+			bool raw_ret = atk_component_set_size(Handle, width, height);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[GLib.Signal("bounds_changed")]
+		public event Atk.BoundsChangedHandler BoundsChanged {
+			add {
+				this.AddSignalHandler ("bounds_changed", value, typeof (Atk.BoundsChangedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("bounds_changed", value);
+			}
+		}
+
+		static BoundsChangedNativeDelegate BoundsChanged_cb_delegate;
+		static BoundsChangedNativeDelegate BoundsChangedVMCallback {
+			get {
+				if (BoundsChanged_cb_delegate == null)
+					BoundsChanged_cb_delegate = new BoundsChangedNativeDelegate (BoundsChanged_cb);
+				return BoundsChanged_cb_delegate;
+			}
+		}
+
+		static void OverrideBoundsChanged (GLib.GType gtype)
+		{
+			OverrideBoundsChanged (gtype, BoundsChangedVMCallback);
+		}
+
+		static void OverrideBoundsChanged (GLib.GType gtype, BoundsChangedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "bounds_changed", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void BoundsChangedNativeDelegate (IntPtr inst, IntPtr bounds);
+
+		static void BoundsChanged_cb (IntPtr inst, IntPtr bounds)
+		{
+			try {
+				Atk.Plug __obj = GLib.Object.GetObject (inst, false) as Atk.Plug;
+				__obj.OnBoundsChanged (Atk.Rectangle.New (bounds));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Plug), ConnectionMethod="OverrideBoundsChanged")]
+		protected virtual void OnBoundsChanged (Atk.Rectangle bounds)
+		{
+			InternalBoundsChanged (bounds);
+		}
+
+		private void InternalBoundsChanged (Atk.Rectangle bounds)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+			GLib.Value[] vals = new GLib.Value [2];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (bounds);
+			inst_and_params.Append (vals [1]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+
+		// 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 (Atk.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/PropertyChangeEventHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/PropertyChangeHandler.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+	public delegate void PropertyChangeHandler(Atk.Object obj, Atk.PropertyValues vals);
+
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/PropertyValues.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Range.cs

@@ -0,0 +1,137 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Range : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_range_copy(IntPtr raw);
+		static d_atk_range_copy atk_range_copy = FuncLoader.LoadFunction<d_atk_range_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_range_copy"));
+
+		public Atk.Range Copy() {
+			IntPtr raw_ret = atk_range_copy(Handle);
+			Atk.Range ret = raw_ret == IntPtr.Zero ? null : (Atk.Range) GLib.Opaque.GetOpaque (raw_ret, typeof (Atk.Range), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_range_get_description(IntPtr raw);
+		static d_atk_range_get_description atk_range_get_description = FuncLoader.LoadFunction<d_atk_range_get_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_range_get_description"));
+
+		public string Description { 
+			get {
+				IntPtr raw_ret = atk_range_get_description(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_atk_range_get_lower_limit(IntPtr raw);
+		static d_atk_range_get_lower_limit atk_range_get_lower_limit = FuncLoader.LoadFunction<d_atk_range_get_lower_limit>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_range_get_lower_limit"));
+
+		public double LowerLimit { 
+			get {
+				double raw_ret = atk_range_get_lower_limit(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_range_get_type();
+		static d_atk_range_get_type atk_range_get_type = FuncLoader.LoadFunction<d_atk_range_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_range_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_range_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_atk_range_get_upper_limit(IntPtr raw);
+		static d_atk_range_get_upper_limit atk_range_get_upper_limit = FuncLoader.LoadFunction<d_atk_range_get_upper_limit>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_range_get_upper_limit"));
+
+		public double UpperLimit { 
+			get {
+				double raw_ret = atk_range_get_upper_limit(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+		}
+
+		public Range(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_range_new(double lower_limit, double upper_limit, IntPtr description);
+		static d_atk_range_new atk_range_new = FuncLoader.LoadFunction<d_atk_range_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_range_new"));
+
+		public Range (double lower_limit, double upper_limit, string description) 
+		{
+			IntPtr native_description = GLib.Marshaller.StringToPtrGStrdup (description);
+			Raw = atk_range_new(lower_limit, upper_limit, native_description);
+			GLib.Marshaller.Free (native_description);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_range_free(IntPtr raw);
+		static d_atk_range_free atk_range_free = FuncLoader.LoadFunction<d_atk_range_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_range_free"));
+
+		protected override void Free (IntPtr raw)
+		{
+			atk_range_free (raw);
+		}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				atk_range_free (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~Range ()
+		{
+			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/AtkSharp/Generated/Atk/RealStateSet.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class RealStateSet : GLib.Opaque {
+
+		public RealStateSet(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/AtkSharp/Generated/Atk/Rectangle.cs

@@ -0,0 +1,69 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct Rectangle : IEquatable<Rectangle> {
+
+		public int X;
+		public int Y;
+		public int Width;
+		public int Height;
+
+		public static Atk.Rectangle Zero = new Atk.Rectangle ();
+
+		public static Atk.Rectangle New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Atk.Rectangle.Zero;
+			return (Atk.Rectangle) Marshal.PtrToStructure (raw, typeof (Atk.Rectangle));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_rectangle_get_type();
+		static d_atk_rectangle_get_type atk_rectangle_get_type = FuncLoader.LoadFunction<d_atk_rectangle_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_rectangle_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_rectangle_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		public bool Equals (Rectangle other)
+		{
+			return true && X.Equals (other.X) && Y.Equals (other.Y) && Width.Equals (other.Width) && Height.Equals (other.Height);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is Rectangle && Equals ((Rectangle) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ X.GetHashCode () ^ Y.GetHashCode () ^ Width.GetHashCode () ^ Height.GetHashCode ();
+		}
+
+		public static explicit operator GLib.Value (Atk.Rectangle boxed)
+		{
+			GLib.Value val = GLib.Value.Empty;
+			val.Init (Atk.Rectangle.GType);
+			val.Val = boxed;
+			return val;
+		}
+
+		public static explicit operator Atk.Rectangle (GLib.Value val)
+		{
+			return (Atk.Rectangle) val.Val;
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Registry.cs

@@ -0,0 +1,111 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Registry : GLib.Object {
+
+		public Registry (IntPtr raw) : base(raw) {}
+
+		protected Registry() : 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 (GLib.Object.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_registry_get_factory(IntPtr raw, IntPtr type);
+		static d_atk_registry_get_factory atk_registry_get_factory = FuncLoader.LoadFunction<d_atk_registry_get_factory>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_registry_get_factory"));
+
+		public Atk.ObjectFactory GetFactory(GLib.GType type) {
+			IntPtr raw_ret = atk_registry_get_factory(Handle, type.Val);
+			Atk.ObjectFactory ret = GLib.Object.GetObject(raw_ret) as Atk.ObjectFactory;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_registry_get_factory_type(IntPtr raw, IntPtr type);
+		static d_atk_registry_get_factory_type atk_registry_get_factory_type = FuncLoader.LoadFunction<d_atk_registry_get_factory_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_registry_get_factory_type"));
+
+		public GLib.GType GetFactoryType(GLib.GType type) {
+			IntPtr raw_ret = atk_registry_get_factory_type(Handle, type.Val);
+			GLib.GType ret = new GLib.GType(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_registry_get_type();
+		static d_atk_registry_get_type atk_registry_get_type = FuncLoader.LoadFunction<d_atk_registry_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_registry_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_registry_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_registry_set_factory_type(IntPtr raw, IntPtr type, IntPtr factory_type);
+		static d_atk_registry_set_factory_type atk_registry_set_factory_type = FuncLoader.LoadFunction<d_atk_registry_set_factory_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_registry_set_factory_type"));
+
+		public void SetFactoryType(GLib.GType type, GLib.GType factory_type) {
+			atk_registry_set_factory_type(Handle, type.Val, factory_type.Val);
+		}
+
+
+		// 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("factory_type_registry"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // factory_type_registry
+							, null
+							, "factory_singleton_cache"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("factory_singleton_cache"
+							, -1
+							, (uint) sizeof( IntPtr ) // factory_singleton_cache
+							, "factory_type_registry"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Relation.cs

@@ -0,0 +1,186 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Relation : GLib.Object {
+
+		public Relation (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_new(IntPtr[] targets, int n_targets, int relationship);
+		static d_atk_relation_new atk_relation_new = FuncLoader.LoadFunction<d_atk_relation_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_new"));
+
+		public Relation (Atk.Object[] targets, Atk.RelationType relationship) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Relation)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			int cnt_targets = targets == null ? 0 : targets.Length;
+			IntPtr[] native_targets = new IntPtr [cnt_targets];
+			for (int i = 0; i < cnt_targets; i++)
+				native_targets [i] = targets[i] == null ? IntPtr.Zero : targets[i].Handle;
+			Raw = atk_relation_new(native_targets, (targets == null ? 0 : targets.Length), (int) relationship);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_relation_get_relation_type(IntPtr raw);
+		static d_atk_relation_get_relation_type atk_relation_get_relation_type = FuncLoader.LoadFunction<d_atk_relation_get_relation_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_get_relation_type"));
+
+		[GLib.Property ("relation_type")]
+		public Atk.RelationType RelationType {
+			get  {
+				int raw_ret = atk_relation_get_relation_type(Handle);
+				Atk.RelationType ret = (Atk.RelationType) raw_ret;
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value((Enum) value);
+				SetProperty("relation_type", val);
+				val.Dispose ();
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_get_target(IntPtr raw);
+		static d_atk_relation_get_target atk_relation_get_target = FuncLoader.LoadFunction<d_atk_relation_get_target>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_get_target"));
+
+		public Atk.Object[] Target {
+			get  {
+				IntPtr raw_ret = atk_relation_get_target(Handle);
+				Atk.Object[] ret = GLib.Marshaller.PtrArrayToArray<Atk.Object> (raw_ret, false, false);
+				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 void d_atk_relation_add_target(IntPtr raw, IntPtr target);
+		static d_atk_relation_add_target atk_relation_add_target = FuncLoader.LoadFunction<d_atk_relation_add_target>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_add_target"));
+
+		public void AddTarget(Atk.Object target) {
+			atk_relation_add_target(Handle, target == null ? IntPtr.Zero : target.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_get_type();
+		static d_atk_relation_get_type atk_relation_get_type = FuncLoader.LoadFunction<d_atk_relation_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_relation_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_relation_remove_target(IntPtr raw, IntPtr target);
+		static d_atk_relation_remove_target atk_relation_remove_target = FuncLoader.LoadFunction<d_atk_relation_remove_target>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_remove_target"));
+
+		public bool RemoveTarget(Atk.Object target) {
+			bool raw_ret = atk_relation_remove_target(Handle, target == null ? IntPtr.Zero : target.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_relation_type_for_name(IntPtr name);
+		static d_atk_relation_type_for_name atk_relation_type_for_name = FuncLoader.LoadFunction<d_atk_relation_type_for_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_type_for_name"));
+
+		public static Atk.RelationType TypeForName(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_relation_type_for_name(native_name);
+			Atk.RelationType ret = (Atk.RelationType) raw_ret;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_type_get_name(int type);
+		static d_atk_relation_type_get_name atk_relation_type_get_name = FuncLoader.LoadFunction<d_atk_relation_type_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_type_get_name"));
+
+		public static string TypeGetName(Atk.RelationType type) {
+			IntPtr raw_ret = atk_relation_type_get_name((int) type);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_relation_type_register(IntPtr name);
+		static d_atk_relation_type_register atk_relation_type_register = FuncLoader.LoadFunction<d_atk_relation_type_register>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_type_register"));
+
+		public static Atk.RelationType TypeRegister(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_relation_type_register(native_name);
+			Atk.RelationType ret = (Atk.RelationType) raw_ret;
+			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 (new List<GLib.AbiField>{ 
+						new GLib.AbiField("target"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // target
+							, null
+							, "relationship"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("relationship"
+							, -1
+							, (uint) sizeof(Atk.RelationType) // relationship
+							, "target"
+							, null
+							, (long) Marshal.OffsetOf<AtkRelation_relationshipAlign>("relationship")
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct AtkRelation_relationshipAlign
+		{
+			sbyte f1;
+			private Atk.RelationType relationship;
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/RelationSet.cs

@@ -0,0 +1,176 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class RelationSet : GLib.Object {
+
+		public RelationSet (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_set_new();
+		static d_atk_relation_set_new atk_relation_set_new = FuncLoader.LoadFunction<d_atk_relation_set_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_new"));
+
+		public RelationSet () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (RelationSet)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = atk_relation_set_new();
+		}
+
+
+		// 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("pad1"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // pad1
+							, null
+							, "pad2"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("pad2"
+							, -1
+							, (uint) sizeof( IntPtr ) // pad2
+							, "pad1"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_relation_set_add(IntPtr raw, IntPtr relation);
+		static d_atk_relation_set_add atk_relation_set_add = FuncLoader.LoadFunction<d_atk_relation_set_add>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_add"));
+
+		public void Add(Atk.Relation relation) {
+			atk_relation_set_add(Handle, relation == null ? IntPtr.Zero : relation.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_relation_set_add_relation_by_type(IntPtr raw, int relationship, IntPtr target);
+		static d_atk_relation_set_add_relation_by_type atk_relation_set_add_relation_by_type = FuncLoader.LoadFunction<d_atk_relation_set_add_relation_by_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_add_relation_by_type"));
+
+		public void AddRelationByType(Atk.RelationType relationship, Atk.Object target) {
+			atk_relation_set_add_relation_by_type(Handle, (int) relationship, target == null ? IntPtr.Zero : target.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_relation_set_contains(IntPtr raw, int relationship);
+		static d_atk_relation_set_contains atk_relation_set_contains = FuncLoader.LoadFunction<d_atk_relation_set_contains>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_contains"));
+
+		public bool Contains(Atk.RelationType relationship) {
+			bool raw_ret = atk_relation_set_contains(Handle, (int) relationship);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_relation_set_contains_target(IntPtr raw, int relationship, IntPtr target);
+		static d_atk_relation_set_contains_target atk_relation_set_contains_target = FuncLoader.LoadFunction<d_atk_relation_set_contains_target>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_contains_target"));
+
+		public bool ContainsTarget(Atk.RelationType relationship, Atk.Object target) {
+			bool raw_ret = atk_relation_set_contains_target(Handle, (int) relationship, target == null ? IntPtr.Zero : target.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_relation_set_get_n_relations(IntPtr raw);
+		static d_atk_relation_set_get_n_relations atk_relation_set_get_n_relations = FuncLoader.LoadFunction<d_atk_relation_set_get_n_relations>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_get_n_relations"));
+
+		public int NRelations { 
+			get {
+				int raw_ret = atk_relation_set_get_n_relations(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_set_get_relation(IntPtr raw, int i);
+		static d_atk_relation_set_get_relation atk_relation_set_get_relation = FuncLoader.LoadFunction<d_atk_relation_set_get_relation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_get_relation"));
+
+		public Atk.Relation GetRelation(int i) {
+			IntPtr raw_ret = atk_relation_set_get_relation(Handle, i);
+			Atk.Relation ret = GLib.Object.GetObject(raw_ret) as Atk.Relation;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_set_get_relation_by_type(IntPtr raw, int relationship);
+		static d_atk_relation_set_get_relation_by_type atk_relation_set_get_relation_by_type = FuncLoader.LoadFunction<d_atk_relation_set_get_relation_by_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_get_relation_by_type"));
+
+		public Atk.Relation GetRelationByType(Atk.RelationType relationship) {
+			IntPtr raw_ret = atk_relation_set_get_relation_by_type(Handle, (int) relationship);
+			Atk.Relation ret = GLib.Object.GetObject(raw_ret) as Atk.Relation;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_set_get_type();
+		static d_atk_relation_set_get_type atk_relation_set_get_type = FuncLoader.LoadFunction<d_atk_relation_set_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_relation_set_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_relation_set_remove(IntPtr raw, IntPtr relation);
+		static d_atk_relation_set_remove atk_relation_set_remove = FuncLoader.LoadFunction<d_atk_relation_set_remove>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_set_remove"));
+
+		public void Remove(Atk.Relation relation) {
+			atk_relation_set_remove(Handle, relation == null ? IntPtr.Zero : relation.Handle);
+		}
+
+
+		// 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("relations"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // relations
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/RelationType.cs

@@ -0,0 +1,45 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.RelationTypeGType))]
+	public enum RelationType {
+
+		Null,
+		ControlledBy,
+		ControllerFor,
+		LabelFor,
+		LabelledBy,
+		MemberOf,
+		NodeChildOf,
+		FlowsTo,
+		FlowsFrom,
+		SubwindowOf,
+		Embeds,
+		EmbeddedBy,
+		PopupFor,
+		ParentWindowOf,
+		DescribedBy,
+		DescriptionFor,
+		NodeParentOf,
+		LastDefined,
+	}
+
+	internal class RelationTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_relation_type_get_type();
+		static d_atk_relation_type_get_type atk_relation_type_get_type = FuncLoader.LoadFunction<d_atk_relation_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_relation_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_relation_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Role.cs

@@ -0,0 +1,150 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.RoleGType))]
+	public enum Role {
+
+		Invalid,
+		AccelLabel,
+		Alert,
+		Animation,
+		Arrow,
+		Calendar,
+		Canvas,
+		CheckBox,
+		CheckMenuItem,
+		ColorChooser,
+		ColumnHeader,
+		ComboBox,
+		DateEditor,
+		DesktopIcon,
+		DesktopFrame,
+		Dial,
+		Dialog,
+		DirectoryPane,
+		DrawingArea,
+		FileChooser,
+		Filler,
+		FontChooser,
+		Frame,
+		GlassPane,
+		HtmlContainer,
+		Icon,
+		Image,
+		InternalFrame,
+		Label,
+		LayeredPane,
+		List,
+		ListItem,
+		Menu,
+		MenuBar,
+		MenuItem,
+		OptionPane,
+		PageTab,
+		PageTabList,
+		Panel,
+		PasswordText,
+		PopupMenu,
+		ProgressBar,
+		PushButton,
+		RadioButton,
+		RadioMenuItem,
+		RootPane,
+		RowHeader,
+		ScrollBar,
+		ScrollPane,
+		Separator,
+		Slider,
+		SplitPane,
+		SpinButton,
+		Statusbar,
+		Table,
+		TableCell,
+		TableColumnHeader,
+		TableRowHeader,
+		TearOffMenuItem,
+		Terminal,
+		Text,
+		ToggleButton,
+		ToolBar,
+		ToolTip,
+		Tree,
+		TreeTable,
+		Unknown,
+		Viewport,
+		Window,
+		Header,
+		Footer,
+		Paragraph,
+		Ruler,
+		Application,
+		Autocomplete,
+		Editbar,
+		Embedded,
+		Entry,
+		Chart,
+		Caption,
+		DocumentFrame,
+		Heading,
+		Page,
+		Section,
+		RedundantObject,
+		Form,
+		Link,
+		InputMethodWindow,
+		TableRow,
+		TreeItem,
+		DocumentSpreadsheet,
+		DocumentPresentation,
+		DocumentText,
+		DocumentWeb,
+		DocumentEmail,
+		Comment,
+		ListBox,
+		Grouping,
+		ImageMap,
+		Notification,
+		InfoBar,
+		LevelBar,
+		TitleBar,
+		BlockQuote,
+		Audio,
+		Video,
+		Definition,
+		Article,
+		Landmark,
+		Log,
+		Marquee,
+		Math,
+		Rating,
+		Timer,
+		DescriptionList,
+		DescriptionTerm,
+		DescriptionValue,
+		Static,
+		MathFraction,
+		MathRoot,
+		Subscript,
+		Superscript,
+		LastDefined,
+	}
+
+	internal class RoleGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_role_get_type();
+		static d_atk_role_get_type atk_role_get_type = FuncLoader.LoadFunction<d_atk_role_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_role_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_role_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/RowDeletedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/RowInsertedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/SelectionAdapter.cs

@@ -0,0 +1,334 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class SelectionAdapter : GLib.GInterfaceAdapter, Atk.ISelection {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkSelectionIface {
+			public AddSelectionNativeDelegate AddSelection;
+			public ClearSelectionNativeDelegate ClearSelection;
+			public RefSelectionNativeDelegate RefSelection;
+			public GetSelectionCountNativeDelegate GetSelectionCount;
+			public IsChildSelectedNativeDelegate IsChildSelected;
+			public RemoveSelectionNativeDelegate RemoveSelection;
+			public SelectAllSelectionNativeDelegate SelectAllSelection;
+			IntPtr SelectionChanged;
+		}
+
+		static AtkSelectionIface iface;
+
+		static SelectionAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (SelectionAdapter));
+			iface.AddSelection = new AddSelectionNativeDelegate (AddSelection_cb);
+			iface.ClearSelection = new ClearSelectionNativeDelegate (ClearSelection_cb);
+			iface.RefSelection = new RefSelectionNativeDelegate (RefSelection_cb);
+			iface.GetSelectionCount = new GetSelectionCountNativeDelegate (GetSelectionCount_cb);
+			iface.IsChildSelected = new IsChildSelectedNativeDelegate (IsChildSelected_cb);
+			iface.RemoveSelection = new RemoveSelectionNativeDelegate (RemoveSelection_cb);
+			iface.SelectAllSelection = new SelectAllSelectionNativeDelegate (SelectAllSelection_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool AddSelectionNativeDelegate (IntPtr inst, int i);
+
+		static bool AddSelection_cb (IntPtr inst, int i)
+		{
+			try {
+				ISelectionImplementor __obj = GLib.Object.GetObject (inst, false) as ISelectionImplementor;
+				bool __result;
+				__result = __obj.AddSelection (i);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool ClearSelectionNativeDelegate (IntPtr inst);
+
+		static bool ClearSelection_cb (IntPtr inst)
+		{
+			try {
+				ISelectionImplementor __obj = GLib.Object.GetObject (inst, false) as ISelectionImplementor;
+				bool __result;
+				__result = __obj.ClearSelection ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr RefSelectionNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr RefSelection_cb (IntPtr inst, int i)
+		{
+			try {
+				ISelectionImplementor __obj = GLib.Object.GetObject (inst, false) as ISelectionImplementor;
+				Atk.Object __result;
+				__result = __obj.RefSelection (i);
+				return __result == null ? IntPtr.Zero : __result.OwnedHandle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetSelectionCountNativeDelegate (IntPtr inst);
+
+		static int GetSelectionCount_cb (IntPtr inst)
+		{
+			try {
+				ISelectionImplementor __obj = GLib.Object.GetObject (inst, false) as ISelectionImplementor;
+				int __result;
+				__result = __obj.SelectionCount;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool IsChildSelectedNativeDelegate (IntPtr inst, int i);
+
+		static bool IsChildSelected_cb (IntPtr inst, int i)
+		{
+			try {
+				ISelectionImplementor __obj = GLib.Object.GetObject (inst, false) as ISelectionImplementor;
+				bool __result;
+				__result = __obj.IsChildSelected (i);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool RemoveSelectionNativeDelegate (IntPtr inst, int i);
+
+		static bool RemoveSelection_cb (IntPtr inst, int i)
+		{
+			try {
+				ISelectionImplementor __obj = GLib.Object.GetObject (inst, false) as ISelectionImplementor;
+				bool __result;
+				__result = __obj.RemoveSelection (i);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SelectAllSelectionNativeDelegate (IntPtr inst);
+
+		static bool SelectAllSelection_cb (IntPtr inst)
+		{
+			try {
+				ISelectionImplementor __obj = GLib.Object.GetObject (inst, false) as ISelectionImplementor;
+				bool __result;
+				__result = __obj.SelectAllSelection ();
+				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);
+			AtkSelectionIface native_iface = (AtkSelectionIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkSelectionIface));
+			native_iface.AddSelection = iface.AddSelection;
+			native_iface.ClearSelection = iface.ClearSelection;
+			native_iface.RefSelection = iface.RefSelection;
+			native_iface.GetSelectionCount = iface.GetSelectionCount;
+			native_iface.IsChildSelected = iface.IsChildSelected;
+			native_iface.RemoveSelection = iface.RemoveSelection;
+			native_iface.SelectAllSelection = iface.SelectAllSelection;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public SelectionAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public SelectionAdapter (ISelectionImplementor 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 SelectionAdapter (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_atk_selection_get_type();
+		static d_atk_selection_get_type atk_selection_get_type = FuncLoader.LoadFunction<d_atk_selection_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_selection_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 ISelection GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static ISelection GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is ISelectionImplementor)
+				return new SelectionAdapter (obj as ISelectionImplementor);
+			else if (obj as ISelection == null)
+				return new SelectionAdapter (obj.Handle);
+			else
+				return obj as ISelection;
+		}
+
+		public ISelectionImplementor Implementor {
+			get {
+				return implementor as ISelectionImplementor;
+			}
+		}
+
+		[GLib.Signal("selection_changed")]
+		public event System.EventHandler SelectionChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("selection_changed", value);
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("selection_changed", value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_selection_add_selection(IntPtr raw, int i);
+		static d_atk_selection_add_selection atk_selection_add_selection = FuncLoader.LoadFunction<d_atk_selection_add_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_add_selection"));
+
+		public bool AddSelection(int i) {
+			bool raw_ret = atk_selection_add_selection(Handle, i);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_selection_clear_selection(IntPtr raw);
+		static d_atk_selection_clear_selection atk_selection_clear_selection = FuncLoader.LoadFunction<d_atk_selection_clear_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_clear_selection"));
+
+		public bool ClearSelection() {
+			bool raw_ret = atk_selection_clear_selection(Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_selection_get_selection_count(IntPtr raw);
+		static d_atk_selection_get_selection_count atk_selection_get_selection_count = FuncLoader.LoadFunction<d_atk_selection_get_selection_count>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_get_selection_count"));
+
+		public int SelectionCount { 
+			get {
+				int raw_ret = atk_selection_get_selection_count(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_selection_is_child_selected(IntPtr raw, int i);
+		static d_atk_selection_is_child_selected atk_selection_is_child_selected = FuncLoader.LoadFunction<d_atk_selection_is_child_selected>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_is_child_selected"));
+
+		public bool IsChildSelected(int i) {
+			bool raw_ret = atk_selection_is_child_selected(Handle, i);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_selection_ref_selection(IntPtr raw, int i);
+		static d_atk_selection_ref_selection atk_selection_ref_selection = FuncLoader.LoadFunction<d_atk_selection_ref_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_ref_selection"));
+
+		public Atk.Object RefSelection(int i) {
+			IntPtr raw_ret = atk_selection_ref_selection(Handle, i);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_selection_remove_selection(IntPtr raw, int i);
+		static d_atk_selection_remove_selection atk_selection_remove_selection = FuncLoader.LoadFunction<d_atk_selection_remove_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_remove_selection"));
+
+		public bool RemoveSelection(int i) {
+			bool raw_ret = atk_selection_remove_selection(Handle, i);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_selection_select_all_selection(IntPtr raw);
+		static d_atk_selection_select_all_selection atk_selection_select_all_selection = FuncLoader.LoadFunction<d_atk_selection_select_all_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_selection_select_all_selection"));
+
+		public bool SelectAllSelection() {
+			bool raw_ret = atk_selection_select_all_selection(Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Socket.cs

@@ -0,0 +1,365 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Socket : Atk.Object, Atk.IComponent {
+
+		public Socket (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_socket_new();
+		static d_atk_socket_new atk_socket_new = FuncLoader.LoadFunction<d_atk_socket_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_socket_new"));
+
+		public Socket () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Socket)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = atk_socket_new();
+		}
+
+		static EmbedNativeDelegate Embed_cb_delegate;
+		static EmbedNativeDelegate EmbedVMCallback {
+			get {
+				if (Embed_cb_delegate == null)
+					Embed_cb_delegate = new EmbedNativeDelegate (Embed_cb);
+				return Embed_cb_delegate;
+			}
+		}
+
+		static void OverrideEmbed (GLib.GType gtype)
+		{
+			OverrideEmbed (gtype, EmbedVMCallback);
+		}
+
+		static void OverrideEmbed (GLib.GType gtype, EmbedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("embed"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void EmbedNativeDelegate (IntPtr inst, IntPtr plug_id);
+
+		static void Embed_cb (IntPtr inst, IntPtr plug_id)
+		{
+			try {
+				Socket __obj = GLib.Object.GetObject (inst, false) as Socket;
+				__obj.OnEmbed (GLib.Marshaller.PtrToStringGFree(plug_id));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Socket), ConnectionMethod="OverrideEmbed")]
+		protected virtual void OnEmbed (string plug_id)
+		{
+			InternalEmbed (plug_id);
+		}
+
+		private void InternalEmbed (string plug_id)
+		{
+			EmbedNativeDelegate unmanaged = class_abi.BaseOverride<EmbedNativeDelegate>(this.LookupGType(), "embed");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, GLib.Marshaller.StringToPtrGStrdup(plug_id));
+		}
+
+
+		// 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("embed"
+							, Atk.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // embed
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_socket_embed(IntPtr raw, IntPtr plug_id);
+		static d_atk_socket_embed atk_socket_embed = FuncLoader.LoadFunction<d_atk_socket_embed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_socket_embed"));
+
+		public void Embed(string plug_id) {
+			atk_socket_embed(Handle, GLib.Marshaller.StringToPtrGStrdup(plug_id));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_socket_get_type();
+		static d_atk_socket_get_type atk_socket_get_type = FuncLoader.LoadFunction<d_atk_socket_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_socket_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_socket_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_socket_is_occupied(IntPtr raw);
+		static d_atk_socket_is_occupied atk_socket_is_occupied = FuncLoader.LoadFunction<d_atk_socket_is_occupied>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_socket_is_occupied"));
+
+		public bool IsOccupied { 
+			get {
+				bool raw_ret = atk_socket_is_occupied(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_component_add_focus_handler(IntPtr raw, AtkSharp.FocusHandlerNative handler);
+		static d_atk_component_add_focus_handler atk_component_add_focus_handler = FuncLoader.LoadFunction<d_atk_component_add_focus_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_add_focus_handler"));
+
+		[Obsolete]
+		public uint AddFocusHandler(Atk.FocusHandler handler) {
+			AtkSharp.FocusHandlerWrapper handler_wrapper = new AtkSharp.FocusHandlerWrapper (handler);
+			uint raw_ret = atk_component_add_focus_handler(Handle, handler_wrapper.NativeDelegate);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_contains(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_contains atk_component_contains = FuncLoader.LoadFunction<d_atk_component_contains>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_contains"));
+
+		public bool Contains(int x, int y, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_contains(Handle, x, y, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_atk_component_get_alpha(IntPtr raw);
+		static d_atk_component_get_alpha atk_component_get_alpha = FuncLoader.LoadFunction<d_atk_component_get_alpha>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_alpha"));
+
+		public double Alpha { 
+			get {
+				double raw_ret = atk_component_get_alpha(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_extents(IntPtr raw, out int x, out int y, out int width, out int height, int coord_type);
+		static d_atk_component_get_extents atk_component_get_extents = FuncLoader.LoadFunction<d_atk_component_get_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_extents"));
+
+		public void GetExtents(out int x, out int y, out int width, out int height, Atk.CoordType coord_type) {
+			atk_component_get_extents(Handle, out x, out y, out width, out height, (int) coord_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_component_get_layer(IntPtr raw);
+		static d_atk_component_get_layer atk_component_get_layer = FuncLoader.LoadFunction<d_atk_component_get_layer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_layer"));
+
+		public Atk.Layer Layer { 
+			get {
+				int raw_ret = atk_component_get_layer(Handle);
+				Atk.Layer ret = (Atk.Layer) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_component_get_mdi_zorder(IntPtr raw);
+		static d_atk_component_get_mdi_zorder atk_component_get_mdi_zorder = FuncLoader.LoadFunction<d_atk_component_get_mdi_zorder>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_mdi_zorder"));
+
+		public int MdiZorder { 
+			get {
+				int raw_ret = atk_component_get_mdi_zorder(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_position(IntPtr raw, out int x, out int y, int coord_type);
+		static d_atk_component_get_position atk_component_get_position = FuncLoader.LoadFunction<d_atk_component_get_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_position"));
+
+		[Obsolete]
+		public void GetPosition(out int x, out int y, Atk.CoordType coord_type) {
+			atk_component_get_position(Handle, out x, out y, (int) coord_type);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_get_size(IntPtr raw, out int width, out int height);
+		static d_atk_component_get_size atk_component_get_size = FuncLoader.LoadFunction<d_atk_component_get_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_get_size"));
+
+		[Obsolete]
+		public void GetSize(out int width, out int height) {
+			atk_component_get_size(Handle, out width, out height);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_grab_focus(IntPtr raw);
+		static d_atk_component_grab_focus atk_component_grab_focus = FuncLoader.LoadFunction<d_atk_component_grab_focus>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_grab_focus"));
+
+		public bool GrabFocus() {
+			bool raw_ret = atk_component_grab_focus(Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_component_ref_accessible_at_point(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_ref_accessible_at_point atk_component_ref_accessible_at_point = FuncLoader.LoadFunction<d_atk_component_ref_accessible_at_point>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_ref_accessible_at_point"));
+
+		public Atk.Object RefAccessibleAtPoint(int x, int y, Atk.CoordType coord_type) {
+			IntPtr raw_ret = atk_component_ref_accessible_at_point(Handle, x, y, (int) coord_type);
+			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_component_remove_focus_handler(IntPtr raw, uint handler_id);
+		static d_atk_component_remove_focus_handler atk_component_remove_focus_handler = FuncLoader.LoadFunction<d_atk_component_remove_focus_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_remove_focus_handler"));
+
+		[Obsolete]
+		public void RemoveFocusHandler(uint handler_id) {
+			atk_component_remove_focus_handler(Handle, handler_id);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_extents(IntPtr raw, int x, int y, int width, int height, int coord_type);
+		static d_atk_component_set_extents atk_component_set_extents = FuncLoader.LoadFunction<d_atk_component_set_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_extents"));
+
+		public bool SetExtents(int x, int y, int width, int height, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_set_extents(Handle, x, y, width, height, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_position(IntPtr raw, int x, int y, int coord_type);
+		static d_atk_component_set_position atk_component_set_position = FuncLoader.LoadFunction<d_atk_component_set_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_position"));
+
+		public bool SetPosition(int x, int y, Atk.CoordType coord_type) {
+			bool raw_ret = atk_component_set_position(Handle, x, y, (int) coord_type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_component_set_size(IntPtr raw, int width, int height);
+		static d_atk_component_set_size atk_component_set_size = FuncLoader.LoadFunction<d_atk_component_set_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_component_set_size"));
+
+		public bool SetSize(int width, int height) {
+			bool raw_ret = atk_component_set_size(Handle, width, height);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[GLib.Signal("bounds_changed")]
+		public event Atk.BoundsChangedHandler BoundsChanged {
+			add {
+				this.AddSignalHandler ("bounds_changed", value, typeof (Atk.BoundsChangedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("bounds_changed", value);
+			}
+		}
+
+		static BoundsChangedNativeDelegate BoundsChanged_cb_delegate;
+		static BoundsChangedNativeDelegate BoundsChangedVMCallback {
+			get {
+				if (BoundsChanged_cb_delegate == null)
+					BoundsChanged_cb_delegate = new BoundsChangedNativeDelegate (BoundsChanged_cb);
+				return BoundsChanged_cb_delegate;
+			}
+		}
+
+		static void OverrideBoundsChanged (GLib.GType gtype)
+		{
+			OverrideBoundsChanged (gtype, BoundsChangedVMCallback);
+		}
+
+		static void OverrideBoundsChanged (GLib.GType gtype, BoundsChangedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "bounds_changed", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void BoundsChangedNativeDelegate (IntPtr inst, IntPtr bounds);
+
+		static void BoundsChanged_cb (IntPtr inst, IntPtr bounds)
+		{
+			try {
+				Atk.Socket __obj = GLib.Object.GetObject (inst, false) as Atk.Socket;
+				__obj.OnBoundsChanged (Atk.Rectangle.New (bounds));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(Atk.Socket), ConnectionMethod="OverrideBoundsChanged")]
+		protected virtual void OnBoundsChanged (Atk.Rectangle bounds)
+		{
+			InternalBoundsChanged (bounds);
+		}
+
+		private void InternalBoundsChanged (Atk.Rectangle bounds)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+			GLib.Value[] vals = new GLib.Value [2];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (bounds);
+			inst_and_params.Append (vals [1]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+
+		// 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("embedded_plug_id"
+							, Atk.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // embedded_plug_id
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/StateChangeHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/StateManager.cs

@@ -0,0 +1,48 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class StateManager {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_state_type_for_name(IntPtr name);
+		static d_atk_state_type_for_name atk_state_type_for_name = FuncLoader.LoadFunction<d_atk_state_type_for_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_type_for_name"));
+
+		public static Atk.StateType TypeForName(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_state_type_for_name(native_name);
+			Atk.StateType ret = (Atk.StateType) raw_ret;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_state_type_get_name(int type);
+		static d_atk_state_type_get_name atk_state_type_get_name = FuncLoader.LoadFunction<d_atk_state_type_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_type_get_name"));
+
+		public static string TypeGetName(Atk.StateType type) {
+			IntPtr raw_ret = atk_state_type_get_name((int) type);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_state_type_register(IntPtr name);
+		static d_atk_state_type_register atk_state_type_register = FuncLoader.LoadFunction<d_atk_state_type_register>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_type_register"));
+
+		public static Atk.StateType TypeRegister(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_state_type_register(native_name);
+			Atk.StateType ret = (Atk.StateType) raw_ret;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/StateSet.cs

@@ -0,0 +1,178 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class StateSet : GLib.Object {
+
+		public StateSet (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_state_set_new();
+		static d_atk_state_set_new atk_state_set_new = FuncLoader.LoadFunction<d_atk_state_set_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_new"));
+
+		public StateSet () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (StateSet)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = atk_state_set_new();
+		}
+
+
+		// 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 bool d_atk_state_set_add_state(IntPtr raw, int type);
+		static d_atk_state_set_add_state atk_state_set_add_state = FuncLoader.LoadFunction<d_atk_state_set_add_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_add_state"));
+
+		public bool AddState(Atk.StateType type) {
+			bool raw_ret = atk_state_set_add_state(Handle, (int) type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_state_set_add_states(IntPtr raw, out int types, int n_types);
+		static d_atk_state_set_add_states atk_state_set_add_states = FuncLoader.LoadFunction<d_atk_state_set_add_states>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_add_states"));
+
+		public Atk.StateType AddStates(int n_types) {
+			Atk.StateType types;
+			int native_types;
+			atk_state_set_add_states(Handle, out native_types, n_types);
+			types = (Atk.StateType) native_types;
+			return types;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_state_set_and_sets(IntPtr raw, IntPtr compare_set);
+		static d_atk_state_set_and_sets atk_state_set_and_sets = FuncLoader.LoadFunction<d_atk_state_set_and_sets>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_and_sets"));
+
+		public Atk.StateSet AndSets(Atk.StateSet compare_set) {
+			IntPtr raw_ret = atk_state_set_and_sets(Handle, compare_set == null ? IntPtr.Zero : compare_set.Handle);
+			Atk.StateSet ret = GLib.Object.GetObject(raw_ret) as Atk.StateSet;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_state_set_clear_states(IntPtr raw);
+		static d_atk_state_set_clear_states atk_state_set_clear_states = FuncLoader.LoadFunction<d_atk_state_set_clear_states>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_clear_states"));
+
+		public void ClearStates() {
+			atk_state_set_clear_states(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_state_set_contains_state(IntPtr raw, int type);
+		static d_atk_state_set_contains_state atk_state_set_contains_state = FuncLoader.LoadFunction<d_atk_state_set_contains_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_contains_state"));
+
+		public bool ContainsState(Atk.StateType type) {
+			bool raw_ret = atk_state_set_contains_state(Handle, (int) type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_state_set_contains_states(IntPtr raw, out int types, int n_types);
+		static d_atk_state_set_contains_states atk_state_set_contains_states = FuncLoader.LoadFunction<d_atk_state_set_contains_states>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_contains_states"));
+
+		public bool ContainsStates(out Atk.StateType types, int n_types) {
+			int native_types;
+			bool raw_ret = atk_state_set_contains_states(Handle, out native_types, n_types);
+			bool ret = raw_ret;
+			types = (Atk.StateType) native_types;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_state_set_get_type();
+		static d_atk_state_set_get_type atk_state_set_get_type = FuncLoader.LoadFunction<d_atk_state_set_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_state_set_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_state_set_is_empty(IntPtr raw);
+		static d_atk_state_set_is_empty atk_state_set_is_empty = FuncLoader.LoadFunction<d_atk_state_set_is_empty>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_is_empty"));
+
+		public bool IsEmpty { 
+			get {
+				bool raw_ret = atk_state_set_is_empty(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_state_set_or_sets(IntPtr raw, IntPtr compare_set);
+		static d_atk_state_set_or_sets atk_state_set_or_sets = FuncLoader.LoadFunction<d_atk_state_set_or_sets>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_or_sets"));
+
+		public Atk.StateSet OrSets(Atk.StateSet compare_set) {
+			IntPtr raw_ret = atk_state_set_or_sets(Handle, compare_set == null ? IntPtr.Zero : compare_set.Handle);
+			Atk.StateSet ret = GLib.Object.GetObject(raw_ret) as Atk.StateSet;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_state_set_remove_state(IntPtr raw, int type);
+		static d_atk_state_set_remove_state atk_state_set_remove_state = FuncLoader.LoadFunction<d_atk_state_set_remove_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_remove_state"));
+
+		public bool RemoveState(Atk.StateType type) {
+			bool raw_ret = atk_state_set_remove_state(Handle, (int) type);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_state_set_xor_sets(IntPtr raw, IntPtr compare_set);
+		static d_atk_state_set_xor_sets atk_state_set_xor_sets = FuncLoader.LoadFunction<d_atk_state_set_xor_sets>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_set_xor_sets"));
+
+		public Atk.StateSet XorSets(Atk.StateSet compare_set) {
+			IntPtr raw_ret = atk_state_set_xor_sets(Handle, compare_set == null ? IntPtr.Zero : compare_set.Handle);
+			Atk.StateSet ret = GLib.Object.GetObject(raw_ret) as Atk.StateSet;
+			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/AtkSharp/Generated/Atk/StateType.cs

@@ -0,0 +1,71 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.StateTypeGType))]
+	public enum StateType {
+
+		Invalid,
+		Active,
+		Armed,
+		Busy,
+		Checked,
+		Defunct,
+		Editable,
+		Enabled,
+		Expandable,
+		Expanded,
+		Focusable,
+		Focused,
+		Horizontal,
+		Iconified,
+		Modal,
+		MultiLine,
+		Multiselectable,
+		Opaque,
+		Pressed,
+		Resizable,
+		Selectable,
+		Selected,
+		Sensitive,
+		Showing,
+		SingleLine,
+		Stale,
+		Transient,
+		Vertical,
+		Visible,
+		ManagesDescendants,
+		Indeterminate,
+		Truncated,
+		Required,
+		InvalidEntry,
+		SupportsAutocompletion,
+		SelectableText,
+		Default,
+		Animated,
+		Visited,
+		Checkable,
+		HasPopup,
+		HasTooltip,
+		ReadOnly,
+		LastDefined,
+	}
+
+	internal class StateTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_state_type_get_type();
+		static d_atk_state_type_get_type atk_state_type_get_type = FuncLoader.LoadFunction<d_atk_state_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_state_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_state_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/StreamableContentAdapter.cs

@@ -0,0 +1,249 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class StreamableContentAdapter : GLib.GInterfaceAdapter, Atk.IStreamableContent {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkStreamableContentIface {
+			public GetNMimeTypesNativeDelegate GetNMimeTypes;
+			public GetMimeTypeNativeDelegate GetMimeType;
+			public GetStreamNativeDelegate GetStream;
+			public GetUriNativeDelegate GetUri;
+			private AtkSharp.FunctionNative _pad2;
+			public Atk.Function Pad2 {
+				get {
+					return AtkSharp.FunctionWrapper.GetManagedDelegate (_pad2);
+				}
+			}
+			private AtkSharp.FunctionNative _pad3;
+			public Atk.Function Pad3 {
+				get {
+					return AtkSharp.FunctionWrapper.GetManagedDelegate (_pad3);
+				}
+			}
+		}
+
+		static AtkStreamableContentIface iface;
+
+		static StreamableContentAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (StreamableContentAdapter));
+			iface.GetNMimeTypes = new GetNMimeTypesNativeDelegate (GetNMimeTypes_cb);
+			iface.GetMimeType = new GetMimeTypeNativeDelegate (GetMimeType_cb);
+			iface.GetStream = new GetStreamNativeDelegate (GetStream_cb);
+			iface.GetUri = new GetUriNativeDelegate (GetUri_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetNMimeTypesNativeDelegate (IntPtr inst);
+
+		static int GetNMimeTypes_cb (IntPtr inst)
+		{
+			try {
+				IStreamableContentImplementor __obj = GLib.Object.GetObject (inst, false) as IStreamableContentImplementor;
+				int __result;
+				__result = __obj.NMimeTypes;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetMimeTypeNativeDelegate (IntPtr inst, int i);
+
+		static IntPtr GetMimeType_cb (IntPtr inst, int i)
+		{
+			try {
+				IStreamableContentImplementor __obj = GLib.Object.GetObject (inst, false) as IStreamableContentImplementor;
+				string __result;
+				__result = __obj.GetMimeType (i);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetStreamNativeDelegate (IntPtr inst, IntPtr mime_type);
+
+		static IntPtr GetStream_cb (IntPtr inst, IntPtr mime_type)
+		{
+			try {
+				IStreamableContentImplementor __obj = GLib.Object.GetObject (inst, false) as IStreamableContentImplementor;
+				IntPtr __result;
+				__result = __obj.GetStream (GLib.Marshaller.Utf8PtrToString (mime_type));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetUriNativeDelegate (IntPtr inst, IntPtr mime_type);
+
+		static IntPtr GetUri_cb (IntPtr inst, IntPtr mime_type)
+		{
+			try {
+				IStreamableContentImplementor __obj = GLib.Object.GetObject (inst, false) as IStreamableContentImplementor;
+				string __result;
+				__result = __obj.GetUri (GLib.Marshaller.Utf8PtrToString (mime_type));
+				return GLib.Marshaller.StringToPtrGStrdup(__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);
+			AtkStreamableContentIface native_iface = (AtkStreamableContentIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkStreamableContentIface));
+			native_iface.GetNMimeTypes = iface.GetNMimeTypes;
+			native_iface.GetMimeType = iface.GetMimeType;
+			native_iface.GetStream = iface.GetStream;
+			native_iface.GetUri = iface.GetUri;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public StreamableContentAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public StreamableContentAdapter (IStreamableContentImplementor 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 StreamableContentAdapter (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_atk_streamable_content_get_type();
+		static d_atk_streamable_content_get_type atk_streamable_content_get_type = FuncLoader.LoadFunction<d_atk_streamable_content_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_streamable_content_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_streamable_content_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 IStreamableContent GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IStreamableContent GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IStreamableContentImplementor)
+				return new StreamableContentAdapter (obj as IStreamableContentImplementor);
+			else if (obj as IStreamableContent == null)
+				return new StreamableContentAdapter (obj.Handle);
+			else
+				return obj as IStreamableContent;
+		}
+
+		public IStreamableContentImplementor Implementor {
+			get {
+				return implementor as IStreamableContentImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_streamable_content_get_mime_type(IntPtr raw, int i);
+		static d_atk_streamable_content_get_mime_type atk_streamable_content_get_mime_type = FuncLoader.LoadFunction<d_atk_streamable_content_get_mime_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_streamable_content_get_mime_type"));
+
+		public string GetMimeType(int i) {
+			IntPtr raw_ret = atk_streamable_content_get_mime_type(Handle, i);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_streamable_content_get_n_mime_types(IntPtr raw);
+		static d_atk_streamable_content_get_n_mime_types atk_streamable_content_get_n_mime_types = FuncLoader.LoadFunction<d_atk_streamable_content_get_n_mime_types>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_streamable_content_get_n_mime_types"));
+
+		public int NMimeTypes { 
+			get {
+				int raw_ret = atk_streamable_content_get_n_mime_types(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_streamable_content_get_stream(IntPtr raw, IntPtr mime_type);
+		static d_atk_streamable_content_get_stream atk_streamable_content_get_stream = FuncLoader.LoadFunction<d_atk_streamable_content_get_stream>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_streamable_content_get_stream"));
+
+		public IntPtr GetStream(string mime_type) {
+			IntPtr native_mime_type = GLib.Marshaller.StringToPtrGStrdup (mime_type);
+			IntPtr raw_ret = atk_streamable_content_get_stream(Handle, native_mime_type);
+			IntPtr ret = raw_ret;
+			GLib.Marshaller.Free (native_mime_type);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_streamable_content_get_uri(IntPtr raw, IntPtr mime_type);
+		static d_atk_streamable_content_get_uri atk_streamable_content_get_uri = FuncLoader.LoadFunction<d_atk_streamable_content_get_uri>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_streamable_content_get_uri"));
+
+		public string GetUri(string mime_type) {
+			IntPtr native_mime_type = GLib.Marshaller.StringToPtrGStrdup (mime_type);
+			IntPtr raw_ret = atk_streamable_content_get_uri(Handle, native_mime_type);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			GLib.Marshaller.Free (native_mime_type);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TableCellAdapter.cs

@@ -0,0 +1,331 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class TableCellAdapter : GLib.GInterfaceAdapter, Atk.ITableCell {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkTableCellIface {
+			public GetColumnSpanNativeDelegate GetColumnSpan;
+			public GetColumnHeaderCellsNativeDelegate GetColumnHeaderCells;
+			public GetPositionNativeDelegate GetPosition;
+			public GetRowSpanNativeDelegate GetRowSpan;
+			public GetRowHeaderCellsNativeDelegate GetRowHeaderCells;
+			public GetRowColumnSpanNativeDelegate GetRowColumnSpan;
+			public GetTableNativeDelegate GetTable;
+		}
+
+		static AtkTableCellIface iface;
+
+		static TableCellAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (TableCellAdapter));
+			iface.GetColumnSpan = new GetColumnSpanNativeDelegate (GetColumnSpan_cb);
+			iface.GetColumnHeaderCells = new GetColumnHeaderCellsNativeDelegate (GetColumnHeaderCells_cb);
+			iface.GetPosition = new GetPositionNativeDelegate (GetPosition_cb);
+			iface.GetRowSpan = new GetRowSpanNativeDelegate (GetRowSpan_cb);
+			iface.GetRowHeaderCells = new GetRowHeaderCellsNativeDelegate (GetRowHeaderCells_cb);
+			iface.GetRowColumnSpan = new GetRowColumnSpanNativeDelegate (GetRowColumnSpan_cb);
+			iface.GetTable = new GetTableNativeDelegate (GetTable_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetColumnSpanNativeDelegate (IntPtr inst);
+
+		static int GetColumnSpan_cb (IntPtr inst)
+		{
+			try {
+				ITableCellImplementor __obj = GLib.Object.GetObject (inst, false) as ITableCellImplementor;
+				int __result;
+				__result = __obj.ColumnSpan;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetColumnHeaderCellsNativeDelegate (IntPtr inst);
+
+		static IntPtr GetColumnHeaderCells_cb (IntPtr inst)
+		{
+			try {
+				ITableCellImplementor __obj = GLib.Object.GetObject (inst, false) as ITableCellImplementor;
+				GLib.PtrArray __result;
+				__result = __obj.ColumnHeaderCells;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool GetPositionNativeDelegate (IntPtr inst, out int row, out int column);
+
+		static bool GetPosition_cb (IntPtr inst, out int row, out int column)
+		{
+			try {
+				ITableCellImplementor __obj = GLib.Object.GetObject (inst, false) as ITableCellImplementor;
+				bool __result;
+				__result = __obj.GetPosition (out row, out column);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetRowSpanNativeDelegate (IntPtr inst);
+
+		static int GetRowSpan_cb (IntPtr inst)
+		{
+			try {
+				ITableCellImplementor __obj = GLib.Object.GetObject (inst, false) as ITableCellImplementor;
+				int __result;
+				__result = __obj.RowSpan;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetRowHeaderCellsNativeDelegate (IntPtr inst);
+
+		static IntPtr GetRowHeaderCells_cb (IntPtr inst)
+		{
+			try {
+				ITableCellImplementor __obj = GLib.Object.GetObject (inst, false) as ITableCellImplementor;
+				GLib.PtrArray __result;
+				__result = __obj.RowHeaderCells;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool GetRowColumnSpanNativeDelegate (IntPtr inst, out int row, out int column, out int row_span, out int column_span);
+
+		static bool GetRowColumnSpan_cb (IntPtr inst, out int row, out int column, out int row_span, out int column_span)
+		{
+			try {
+				ITableCellImplementor __obj = GLib.Object.GetObject (inst, false) as ITableCellImplementor;
+				bool __result;
+				__result = __obj.GetRowColumnSpan (out row, out column, out row_span, out column_span);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetTableNativeDelegate (IntPtr inst);
+
+		static IntPtr GetTable_cb (IntPtr inst)
+		{
+			try {
+				ITableCellImplementor __obj = GLib.Object.GetObject (inst, false) as ITableCellImplementor;
+				Atk.Object __result;
+				__result = __obj.Table;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} 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);
+			AtkTableCellIface native_iface = (AtkTableCellIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkTableCellIface));
+			native_iface.GetColumnSpan = iface.GetColumnSpan;
+			native_iface.GetColumnHeaderCells = iface.GetColumnHeaderCells;
+			native_iface.GetPosition = iface.GetPosition;
+			native_iface.GetRowSpan = iface.GetRowSpan;
+			native_iface.GetRowHeaderCells = iface.GetRowHeaderCells;
+			native_iface.GetRowColumnSpan = iface.GetRowColumnSpan;
+			native_iface.GetTable = iface.GetTable;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public TableCellAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public TableCellAdapter (ITableCellImplementor 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 TableCellAdapter (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_atk_table_cell_get_type();
+		static d_atk_table_cell_get_type atk_table_cell_get_type = FuncLoader.LoadFunction<d_atk_table_cell_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_table_cell_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 ITableCell GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static ITableCell GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is ITableCellImplementor)
+				return new TableCellAdapter (obj as ITableCellImplementor);
+			else if (obj as ITableCell == null)
+				return new TableCellAdapter (obj.Handle);
+			else
+				return obj as ITableCell;
+		}
+
+		public ITableCellImplementor Implementor {
+			get {
+				return implementor as ITableCellImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_table_cell_get_column_header_cells(IntPtr raw);
+		static d_atk_table_cell_get_column_header_cells atk_table_cell_get_column_header_cells = FuncLoader.LoadFunction<d_atk_table_cell_get_column_header_cells>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_column_header_cells"));
+
+		public GLib.PtrArray ColumnHeaderCells { 
+			get {
+				IntPtr raw_ret = atk_table_cell_get_column_header_cells(Handle);
+				GLib.PtrArray ret = new GLib.PtrArray(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_table_cell_get_column_span(IntPtr raw);
+		static d_atk_table_cell_get_column_span atk_table_cell_get_column_span = FuncLoader.LoadFunction<d_atk_table_cell_get_column_span>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_column_span"));
+
+		public int ColumnSpan { 
+			get {
+				int raw_ret = atk_table_cell_get_column_span(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_table_cell_get_position(IntPtr raw, out int row, out int column);
+		static d_atk_table_cell_get_position atk_table_cell_get_position = FuncLoader.LoadFunction<d_atk_table_cell_get_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_position"));
+
+		public bool GetPosition(out int row, out int column) {
+			bool raw_ret = atk_table_cell_get_position(Handle, out row, out column);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_table_cell_get_row_column_span(IntPtr raw, out int row, out int column, out int row_span, out int column_span);
+		static d_atk_table_cell_get_row_column_span atk_table_cell_get_row_column_span = FuncLoader.LoadFunction<d_atk_table_cell_get_row_column_span>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_row_column_span"));
+
+		public bool GetRowColumnSpan(out int row, out int column, out int row_span, out int column_span) {
+			bool raw_ret = atk_table_cell_get_row_column_span(Handle, out row, out column, out row_span, out column_span);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_table_cell_get_row_header_cells(IntPtr raw);
+		static d_atk_table_cell_get_row_header_cells atk_table_cell_get_row_header_cells = FuncLoader.LoadFunction<d_atk_table_cell_get_row_header_cells>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_row_header_cells"));
+
+		public GLib.PtrArray RowHeaderCells { 
+			get {
+				IntPtr raw_ret = atk_table_cell_get_row_header_cells(Handle);
+				GLib.PtrArray ret = new GLib.PtrArray(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_table_cell_get_row_span(IntPtr raw);
+		static d_atk_table_cell_get_row_span atk_table_cell_get_row_span = FuncLoader.LoadFunction<d_atk_table_cell_get_row_span>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_row_span"));
+
+		public int RowSpan { 
+			get {
+				int raw_ret = atk_table_cell_get_row_span(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_table_cell_get_table(IntPtr raw);
+		static d_atk_table_cell_get_table atk_table_cell_get_table = FuncLoader.LoadFunction<d_atk_table_cell_get_table>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_cell_get_table"));
+
+		public Atk.Object Table { 
+			get {
+				IntPtr raw_ret = atk_table_cell_get_table(Handle);
+				Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextAdapter.cs

@@ -0,0 +1,841 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class TextAdapter : GLib.GInterfaceAdapter, Atk.IText {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkTextIface {
+			public GetTextNativeDelegate GetText;
+			public GetTextAfterOffsetNativeDelegate GetTextAfterOffset;
+			public GetTextAtOffsetNativeDelegate GetTextAtOffset;
+			public GetCharacterAtOffsetNativeDelegate GetCharacterAtOffset;
+			public GetTextBeforeOffsetNativeDelegate GetTextBeforeOffset;
+			public GetCaretOffsetNativeDelegate GetCaretOffset;
+			public GetRunAttributesNativeDelegate GetRunAttributes;
+			public GetDefaultAttributesNativeDelegate GetDefaultAttributes;
+			public GetCharacterExtentsNativeDelegate GetCharacterExtents;
+			public GetCharacterCountNativeDelegate GetCharacterCount;
+			public GetOffsetAtPointNativeDelegate GetOffsetAtPoint;
+			public GetNSelectionsNativeDelegate GetNSelections;
+			public GetSelectionNativeDelegate GetSelection;
+			public AddSelectionNativeDelegate AddSelection;
+			public RemoveSelectionNativeDelegate RemoveSelection;
+			public SetSelectionNativeDelegate SetSelection;
+			public SetCaretOffsetNativeDelegate SetCaretOffset;
+			IntPtr TextChanged;
+			IntPtr TextCaretMoved;
+			IntPtr TextSelectionChanged;
+			IntPtr TextAttributesChanged;
+			public GetRangeExtentsNativeDelegate GetRangeExtents;
+			public GetBoundedRangesNativeDelegate GetBoundedRanges;
+			public GetStringAtOffsetNativeDelegate GetStringAtOffset;
+		}
+
+		static AtkTextIface iface;
+
+		static TextAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (TextAdapter));
+			iface.GetText = new GetTextNativeDelegate (GetText_cb);
+			iface.GetTextAfterOffset = new GetTextAfterOffsetNativeDelegate (GetTextAfterOffset_cb);
+			iface.GetTextAtOffset = new GetTextAtOffsetNativeDelegate (GetTextAtOffset_cb);
+			iface.GetCharacterAtOffset = new GetCharacterAtOffsetNativeDelegate (GetCharacterAtOffset_cb);
+			iface.GetTextBeforeOffset = new GetTextBeforeOffsetNativeDelegate (GetTextBeforeOffset_cb);
+			iface.GetCaretOffset = new GetCaretOffsetNativeDelegate (GetCaretOffset_cb);
+			iface.GetRunAttributes = new GetRunAttributesNativeDelegate (GetRunAttributes_cb);
+			iface.GetDefaultAttributes = new GetDefaultAttributesNativeDelegate (GetDefaultAttributes_cb);
+			iface.GetCharacterExtents = new GetCharacterExtentsNativeDelegate (GetCharacterExtents_cb);
+			iface.GetCharacterCount = new GetCharacterCountNativeDelegate (GetCharacterCount_cb);
+			iface.GetOffsetAtPoint = new GetOffsetAtPointNativeDelegate (GetOffsetAtPoint_cb);
+			iface.GetNSelections = new GetNSelectionsNativeDelegate (GetNSelections_cb);
+			iface.GetSelection = new GetSelectionNativeDelegate (GetSelection_cb);
+			iface.AddSelection = new AddSelectionNativeDelegate (AddSelection_cb);
+			iface.RemoveSelection = new RemoveSelectionNativeDelegate (RemoveSelection_cb);
+			iface.SetSelection = new SetSelectionNativeDelegate (SetSelection_cb);
+			iface.SetCaretOffset = new SetCaretOffsetNativeDelegate (SetCaretOffset_cb);
+			iface.GetRangeExtents = new GetRangeExtentsNativeDelegate (GetRangeExtents_cb);
+			iface.GetBoundedRanges = new GetBoundedRangesNativeDelegate (GetBoundedRanges_cb);
+			iface.GetStringAtOffset = new GetStringAtOffsetNativeDelegate (GetStringAtOffset_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetTextNativeDelegate (IntPtr inst, int start_offset, int end_offset);
+
+		static IntPtr GetText_cb (IntPtr inst, int start_offset, int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				string __result;
+				__result = __obj.GetText (start_offset, end_offset);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetTextAfterOffsetNativeDelegate (IntPtr inst, int offset, int boundary_type, out int start_offset, out int end_offset);
+
+		static IntPtr GetTextAfterOffset_cb (IntPtr inst, int offset, int boundary_type, out int start_offset, out int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				string __result;
+				__result = __obj.GetTextAfterOffset (offset, (Atk.TextBoundary) boundary_type, out start_offset, out end_offset);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetTextAtOffsetNativeDelegate (IntPtr inst, int offset, int boundary_type, out int start_offset, out int end_offset);
+
+		static IntPtr GetTextAtOffset_cb (IntPtr inst, int offset, int boundary_type, out int start_offset, out int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				string __result;
+				__result = __obj.GetTextAtOffset (offset, (Atk.TextBoundary) boundary_type, out start_offset, out end_offset);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint GetCharacterAtOffsetNativeDelegate (IntPtr inst, int offset);
+
+		static uint GetCharacterAtOffset_cb (IntPtr inst, int offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				char __result;
+				__result = __obj.GetCharacterAtOffset (offset);
+				return GLib.Marshaller.CharToGUnichar (__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetTextBeforeOffsetNativeDelegate (IntPtr inst, int offset, int boundary_type, out int start_offset, out int end_offset);
+
+		static IntPtr GetTextBeforeOffset_cb (IntPtr inst, int offset, int boundary_type, out int start_offset, out int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				string __result;
+				__result = __obj.GetTextBeforeOffset (offset, (Atk.TextBoundary) boundary_type, out start_offset, out end_offset);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetCaretOffsetNativeDelegate (IntPtr inst);
+
+		static int GetCaretOffset_cb (IntPtr inst)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				int __result;
+				__result = __obj.CaretOffset;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetRunAttributesNativeDelegate (IntPtr inst, int offset, out int start_offset, out int end_offset);
+
+		static IntPtr GetRunAttributes_cb (IntPtr inst, int offset, out int start_offset, out int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				Atk.Attribute[] __result;
+				__result = __obj.GetRunAttributes (offset, out start_offset, out end_offset);
+				return new GLib.SList(__result, typeof (Atk.Attribute), false, false) == null ? IntPtr.Zero : new GLib.SList(__result, typeof (Atk.Attribute), false, false).Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetDefaultAttributesNativeDelegate (IntPtr inst);
+
+		static IntPtr GetDefaultAttributes_cb (IntPtr inst)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				Atk.Attribute[] __result;
+				__result = __obj.DefaultAttributes;
+				return new GLib.SList(__result, typeof (Atk.Attribute), false, false) == null ? IntPtr.Zero : new GLib.SList(__result, typeof (Atk.Attribute), false, false).Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetCharacterExtentsNativeDelegate (IntPtr inst, int offset, out int x, out int y, out int width, out int height, int coords);
+
+		static void GetCharacterExtents_cb (IntPtr inst, int offset, out int x, out int y, out int width, out int height, int coords)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				__obj.GetCharacterExtents (offset, out x, out y, out width, out height, (Atk.CoordType) coords);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetCharacterCountNativeDelegate (IntPtr inst);
+
+		static int GetCharacterCount_cb (IntPtr inst)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				int __result;
+				__result = __obj.CharacterCount;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetOffsetAtPointNativeDelegate (IntPtr inst, int x, int y, int coords);
+
+		static int GetOffsetAtPoint_cb (IntPtr inst, int x, int y, int coords)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				int __result;
+				__result = __obj.GetOffsetAtPoint (x, y, (Atk.CoordType) coords);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetNSelectionsNativeDelegate (IntPtr inst);
+
+		static int GetNSelections_cb (IntPtr inst)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				int __result;
+				__result = __obj.NSelections;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetSelectionNativeDelegate (IntPtr inst, int selection_num, out int start_offset, out int end_offset);
+
+		static IntPtr GetSelection_cb (IntPtr inst, int selection_num, out int start_offset, out int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				string __result;
+				__result = __obj.GetSelection (selection_num, out start_offset, out end_offset);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool AddSelectionNativeDelegate (IntPtr inst, int start_offset, int end_offset);
+
+		static bool AddSelection_cb (IntPtr inst, int start_offset, int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				bool __result;
+				__result = __obj.AddSelection (start_offset, end_offset);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool RemoveSelectionNativeDelegate (IntPtr inst, int selection_num);
+
+		static bool RemoveSelection_cb (IntPtr inst, int selection_num)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				bool __result;
+				__result = __obj.RemoveSelection (selection_num);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetSelectionNativeDelegate (IntPtr inst, int selection_num, int start_offset, int end_offset);
+
+		static bool SetSelection_cb (IntPtr inst, int selection_num, int start_offset, int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				bool __result;
+				__result = __obj.SetSelection (selection_num, start_offset, end_offset);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetCaretOffsetNativeDelegate (IntPtr inst, int offset);
+
+		static bool SetCaretOffset_cb (IntPtr inst, int offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				bool __result;
+				__result = __obj.SetCaretOffset (offset);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetRangeExtentsNativeDelegate (IntPtr inst, int start_offset, int end_offset, int coord_type, IntPtr rect);
+
+		static void GetRangeExtents_cb (IntPtr inst, int start_offset, int end_offset, int coord_type, IntPtr rect)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				Atk.TextRectangle myrect;
+				__obj.GetRangeExtents (start_offset, end_offset, (Atk.CoordType) coord_type, out myrect);
+				if (rect != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (myrect, rect, false);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetBoundedRangesNativeDelegate (IntPtr inst, IntPtr rect, int coord_type, int x_clip_type, int y_clip_type);
+
+		static IntPtr GetBoundedRanges_cb (IntPtr inst, IntPtr rect, int coord_type, int x_clip_type, int y_clip_type)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				Atk.TextRange __result;
+				__result = __obj.GetBoundedRanges (Atk.TextRectangle.New (rect), (Atk.CoordType) coord_type, (Atk.TextClipType) x_clip_type, (Atk.TextClipType) y_clip_type);
+				return GLib.Marshaller.StructureToPtrAlloc (__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetStringAtOffsetNativeDelegate (IntPtr inst, int offset, int granularity, out int start_offset, out int end_offset);
+
+		static IntPtr GetStringAtOffset_cb (IntPtr inst, int offset, int granularity, out int start_offset, out int end_offset)
+		{
+			try {
+				ITextImplementor __obj = GLib.Object.GetObject (inst, false) as ITextImplementor;
+				string __result;
+				__result = __obj.GetStringAtOffset (offset, (Atk.TextGranularity) granularity, out start_offset, out end_offset);
+				return GLib.Marshaller.StringToPtrGStrdup(__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);
+			AtkTextIface native_iface = (AtkTextIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkTextIface));
+			native_iface.GetText = iface.GetText;
+			native_iface.GetTextAfterOffset = iface.GetTextAfterOffset;
+			native_iface.GetTextAtOffset = iface.GetTextAtOffset;
+			native_iface.GetCharacterAtOffset = iface.GetCharacterAtOffset;
+			native_iface.GetTextBeforeOffset = iface.GetTextBeforeOffset;
+			native_iface.GetCaretOffset = iface.GetCaretOffset;
+			native_iface.GetRunAttributes = iface.GetRunAttributes;
+			native_iface.GetDefaultAttributes = iface.GetDefaultAttributes;
+			native_iface.GetCharacterExtents = iface.GetCharacterExtents;
+			native_iface.GetCharacterCount = iface.GetCharacterCount;
+			native_iface.GetOffsetAtPoint = iface.GetOffsetAtPoint;
+			native_iface.GetNSelections = iface.GetNSelections;
+			native_iface.GetSelection = iface.GetSelection;
+			native_iface.AddSelection = iface.AddSelection;
+			native_iface.RemoveSelection = iface.RemoveSelection;
+			native_iface.SetSelection = iface.SetSelection;
+			native_iface.SetCaretOffset = iface.SetCaretOffset;
+			native_iface.GetRangeExtents = iface.GetRangeExtents;
+			native_iface.GetBoundedRanges = iface.GetBoundedRanges;
+			native_iface.GetStringAtOffset = iface.GetStringAtOffset;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public TextAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public TextAdapter (ITextImplementor 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 TextAdapter (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_atk_text_get_type();
+		static d_atk_text_get_type atk_text_get_type = FuncLoader.LoadFunction<d_atk_text_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_text_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 IText GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IText GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is ITextImplementor)
+				return new TextAdapter (obj as ITextImplementor);
+			else if (obj as IText == null)
+				return new TextAdapter (obj.Handle);
+			else
+				return obj as IText;
+		}
+
+		public ITextImplementor Implementor {
+			get {
+				return implementor as ITextImplementor;
+			}
+		}
+
+		[GLib.Signal("text_insert")]
+		public event Atk.TextInsertHandler TextInsert {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("text_insert", value, typeof (Atk.TextInsertArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("text_insert", value);
+			}
+		}
+
+		[GLib.Signal("text_remove")]
+		public event Atk.TextRemoveHandler TextRemove {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("text_remove", value, typeof (Atk.TextRemoveArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("text_remove", value);
+			}
+		}
+
+		[GLib.Signal("text_attributes_changed")]
+		public event System.EventHandler TextAttributesChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("text_attributes_changed", value);
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("text_attributes_changed", value);
+			}
+		}
+
+		[GLib.Signal("text_caret_moved")]
+		public event Atk.TextCaretMovedHandler TextCaretMoved {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("text_caret_moved", value, typeof (Atk.TextCaretMovedArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("text_caret_moved", value);
+			}
+		}
+
+		[GLib.Signal("text_changed")]
+		public event Atk.TextChangedHandler TextChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("text_changed", value, typeof (Atk.TextChangedArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("text_changed", value);
+			}
+		}
+
+		[GLib.Signal("text_selection_changed")]
+		public event System.EventHandler TextSelectionChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("text_selection_changed", value);
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("text_selection_changed", value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_text_add_selection(IntPtr raw, int start_offset, int end_offset);
+		static d_atk_text_add_selection atk_text_add_selection = FuncLoader.LoadFunction<d_atk_text_add_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_add_selection"));
+
+		public bool AddSelection(int start_offset, int end_offset) {
+			bool raw_ret = atk_text_add_selection(Handle, start_offset, end_offset);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_text_attribute_for_name(IntPtr name);
+		static d_atk_text_attribute_for_name atk_text_attribute_for_name = FuncLoader.LoadFunction<d_atk_text_attribute_for_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_attribute_for_name"));
+
+		public static Atk.TextAttribute AttributeForName(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_text_attribute_for_name(native_name);
+			Atk.TextAttribute ret = (Atk.TextAttribute) raw_ret;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_attribute_get_name(int attr);
+		static d_atk_text_attribute_get_name atk_text_attribute_get_name = FuncLoader.LoadFunction<d_atk_text_attribute_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_attribute_get_name"));
+
+		public static string AttributeGetName(Atk.TextAttribute attr) {
+			IntPtr raw_ret = atk_text_attribute_get_name((int) attr);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_attribute_get_value(int attr, int index_);
+		static d_atk_text_attribute_get_value atk_text_attribute_get_value = FuncLoader.LoadFunction<d_atk_text_attribute_get_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_attribute_get_value"));
+
+		public static string AttributeGetValue(Atk.TextAttribute attr, int index_) {
+			IntPtr raw_ret = atk_text_attribute_get_value((int) attr, index_);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_text_attribute_register(IntPtr name);
+		static d_atk_text_attribute_register atk_text_attribute_register = FuncLoader.LoadFunction<d_atk_text_attribute_register>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_attribute_register"));
+
+		public static Atk.TextAttribute AttributeRegister(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			int raw_ret = atk_text_attribute_register(native_name);
+			Atk.TextAttribute ret = (Atk.TextAttribute) raw_ret;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_text_free_ranges(IntPtr ranges);
+		static d_atk_text_free_ranges atk_text_free_ranges = FuncLoader.LoadFunction<d_atk_text_free_ranges>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_free_ranges"));
+
+		public static void FreeRanges(Atk.TextRange ranges) {
+			IntPtr native_ranges = GLib.Marshaller.StructureToPtrAlloc (ranges);
+			atk_text_free_ranges(native_ranges);
+			Marshal.FreeHGlobal (native_ranges);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_bounded_ranges(IntPtr raw, IntPtr rect, int coord_type, int x_clip_type, int y_clip_type);
+		static d_atk_text_get_bounded_ranges atk_text_get_bounded_ranges = FuncLoader.LoadFunction<d_atk_text_get_bounded_ranges>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_bounded_ranges"));
+
+		public Atk.TextRange GetBoundedRanges(Atk.TextRectangle rect, Atk.CoordType coord_type, Atk.TextClipType x_clip_type, Atk.TextClipType y_clip_type) {
+			IntPtr native_rect = GLib.Marshaller.StructureToPtrAlloc (rect);
+			IntPtr raw_ret = atk_text_get_bounded_ranges(Handle, native_rect, (int) coord_type, (int) x_clip_type, (int) y_clip_type);
+			Atk.TextRange ret = Atk.TextRange.New (raw_ret);
+			Marshal.FreeHGlobal (native_rect);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_text_get_caret_offset(IntPtr raw);
+		static d_atk_text_get_caret_offset atk_text_get_caret_offset = FuncLoader.LoadFunction<d_atk_text_get_caret_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_caret_offset"));
+
+		public int CaretOffset { 
+			get {
+				int raw_ret = atk_text_get_caret_offset(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_atk_text_get_character_at_offset(IntPtr raw, int offset);
+		static d_atk_text_get_character_at_offset atk_text_get_character_at_offset = FuncLoader.LoadFunction<d_atk_text_get_character_at_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_character_at_offset"));
+
+		public char GetCharacterAtOffset(int offset) {
+			uint raw_ret = atk_text_get_character_at_offset(Handle, offset);
+			char ret = GLib.Marshaller.GUnicharToChar (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_text_get_character_count(IntPtr raw);
+		static d_atk_text_get_character_count atk_text_get_character_count = FuncLoader.LoadFunction<d_atk_text_get_character_count>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_character_count"));
+
+		public int CharacterCount { 
+			get {
+				int raw_ret = atk_text_get_character_count(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_text_get_character_extents(IntPtr raw, int offset, out int x, out int y, out int width, out int height, int coords);
+		static d_atk_text_get_character_extents atk_text_get_character_extents = FuncLoader.LoadFunction<d_atk_text_get_character_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_character_extents"));
+
+		public void GetCharacterExtents(int offset, out int x, out int y, out int width, out int height, Atk.CoordType coords) {
+			atk_text_get_character_extents(Handle, offset, out x, out y, out width, out height, (int) coords);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_default_attributes(IntPtr raw);
+		static d_atk_text_get_default_attributes atk_text_get_default_attributes = FuncLoader.LoadFunction<d_atk_text_get_default_attributes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_default_attributes"));
+
+		public Atk.Attribute[] DefaultAttributes { 
+			get {
+				IntPtr raw_ret = atk_text_get_default_attributes(Handle);
+				Atk.Attribute[] ret = GLib.Marshaller.SListPtrToArray<Atk.Attribute, Atk.Attribute> (raw_ret, false, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_text_get_n_selections(IntPtr raw);
+		static d_atk_text_get_n_selections atk_text_get_n_selections = FuncLoader.LoadFunction<d_atk_text_get_n_selections>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_n_selections"));
+
+		public int NSelections { 
+			get {
+				int raw_ret = atk_text_get_n_selections(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_atk_text_get_offset_at_point(IntPtr raw, int x, int y, int coords);
+		static d_atk_text_get_offset_at_point atk_text_get_offset_at_point = FuncLoader.LoadFunction<d_atk_text_get_offset_at_point>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_offset_at_point"));
+
+		public int GetOffsetAtPoint(int x, int y, Atk.CoordType coords) {
+			int raw_ret = atk_text_get_offset_at_point(Handle, x, y, (int) coords);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_text_get_range_extents(IntPtr raw, int start_offset, int end_offset, int coord_type, IntPtr rect);
+		static d_atk_text_get_range_extents atk_text_get_range_extents = FuncLoader.LoadFunction<d_atk_text_get_range_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_range_extents"));
+
+		public Atk.TextRectangle GetRangeExtents(int start_offset, int end_offset, Atk.CoordType coord_type) {
+			Atk.TextRectangle rect;
+			IntPtr native_rect = Marshal.AllocHGlobal (Marshal.SizeOf<Atk.TextRectangle>());
+			atk_text_get_range_extents(Handle, start_offset, end_offset, (int) coord_type, native_rect);
+			rect = Atk.TextRectangle.New (native_rect);
+			Marshal.FreeHGlobal (native_rect);
+			return rect;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_run_attributes(IntPtr raw, int offset, out int start_offset, out int end_offset);
+		static d_atk_text_get_run_attributes atk_text_get_run_attributes = FuncLoader.LoadFunction<d_atk_text_get_run_attributes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_run_attributes"));
+
+		public Atk.Attribute[] GetRunAttributes(int offset, out int start_offset, out int end_offset) {
+			IntPtr raw_ret = atk_text_get_run_attributes(Handle, offset, out start_offset, out end_offset);
+			Atk.Attribute[] ret = GLib.Marshaller.SListPtrToArray<Atk.Attribute, Atk.Attribute> (raw_ret, false, false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_selection(IntPtr raw, int selection_num, out int start_offset, out int end_offset);
+		static d_atk_text_get_selection atk_text_get_selection = FuncLoader.LoadFunction<d_atk_text_get_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_selection"));
+
+		public string GetSelection(int selection_num, out int start_offset, out int end_offset) {
+			IntPtr raw_ret = atk_text_get_selection(Handle, selection_num, out start_offset, out end_offset);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_string_at_offset(IntPtr raw, int offset, int granularity, out int start_offset, out int end_offset);
+		static d_atk_text_get_string_at_offset atk_text_get_string_at_offset = FuncLoader.LoadFunction<d_atk_text_get_string_at_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_string_at_offset"));
+
+		public string GetStringAtOffset(int offset, Atk.TextGranularity granularity, out int start_offset, out int end_offset) {
+			IntPtr raw_ret = atk_text_get_string_at_offset(Handle, offset, (int) granularity, out start_offset, out end_offset);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_text(IntPtr raw, int start_offset, int end_offset);
+		static d_atk_text_get_text atk_text_get_text = FuncLoader.LoadFunction<d_atk_text_get_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_text"));
+
+		public string GetText(int start_offset, int end_offset) {
+			IntPtr raw_ret = atk_text_get_text(Handle, start_offset, end_offset);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_text_after_offset(IntPtr raw, int offset, int boundary_type, out int start_offset, out int end_offset);
+		static d_atk_text_get_text_after_offset atk_text_get_text_after_offset = FuncLoader.LoadFunction<d_atk_text_get_text_after_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_text_after_offset"));
+
+		[Obsolete]
+		public string GetTextAfterOffset(int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset) {
+			IntPtr raw_ret = atk_text_get_text_after_offset(Handle, offset, (int) boundary_type, out start_offset, out end_offset);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_text_at_offset(IntPtr raw, int offset, int boundary_type, out int start_offset, out int end_offset);
+		static d_atk_text_get_text_at_offset atk_text_get_text_at_offset = FuncLoader.LoadFunction<d_atk_text_get_text_at_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_text_at_offset"));
+
+		[Obsolete]
+		public string GetTextAtOffset(int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset) {
+			IntPtr raw_ret = atk_text_get_text_at_offset(Handle, offset, (int) boundary_type, out start_offset, out end_offset);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_get_text_before_offset(IntPtr raw, int offset, int boundary_type, out int start_offset, out int end_offset);
+		static d_atk_text_get_text_before_offset atk_text_get_text_before_offset = FuncLoader.LoadFunction<d_atk_text_get_text_before_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_get_text_before_offset"));
+
+		[Obsolete]
+		public string GetTextBeforeOffset(int offset, Atk.TextBoundary boundary_type, out int start_offset, out int end_offset) {
+			IntPtr raw_ret = atk_text_get_text_before_offset(Handle, offset, (int) boundary_type, out start_offset, out end_offset);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_text_remove_selection(IntPtr raw, int selection_num);
+		static d_atk_text_remove_selection atk_text_remove_selection = FuncLoader.LoadFunction<d_atk_text_remove_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_remove_selection"));
+
+		public bool RemoveSelection(int selection_num) {
+			bool raw_ret = atk_text_remove_selection(Handle, selection_num);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_text_set_caret_offset(IntPtr raw, int offset);
+		static d_atk_text_set_caret_offset atk_text_set_caret_offset = FuncLoader.LoadFunction<d_atk_text_set_caret_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_set_caret_offset"));
+
+		public bool SetCaretOffset(int offset) {
+			bool raw_ret = atk_text_set_caret_offset(Handle, offset);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_text_set_selection(IntPtr raw, int selection_num, int start_offset, int end_offset);
+		static d_atk_text_set_selection atk_text_set_selection = FuncLoader.LoadFunction<d_atk_text_set_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_set_selection"));
+
+		public bool SetSelection(int selection_num, int start_offset, int end_offset) {
+			bool raw_ret = atk_text_set_selection(Handle, selection_num, start_offset, end_offset);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextAttribute.cs

@@ -0,0 +1,56 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.TextAttributeGType))]
+	public enum TextAttribute {
+
+		Invalid,
+		LeftMargin,
+		RightMargin,
+		Indent,
+		Invisible,
+		Editable,
+		PixelsAboveLines,
+		PixelsBelowLines,
+		PixelsInsideWrap,
+		BgFullHeight,
+		Rise,
+		Underline,
+		Strikethrough,
+		Size,
+		Scale,
+		Weight,
+		Language,
+		FamilyName,
+		BgColor,
+		FgColor,
+		BgStipple,
+		FgStipple,
+		WrapMode,
+		Direction,
+		Justification,
+		Stretch,
+		Variant,
+		Style,
+		LastDefined,
+	}
+
+	internal class TextAttributeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_attribute_get_type();
+		static d_atk_text_attribute_get_type atk_text_attribute_get_type = FuncLoader.LoadFunction<d_atk_text_attribute_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_attribute_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_text_attribute_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextBoundary.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.TextBoundaryGType))]
+	public enum TextBoundary {
+
+		Char,
+		WordStart,
+		WordEnd,
+		SentenceStart,
+		SentenceEnd,
+		LineStart,
+		LineEnd,
+	}
+
+	internal class TextBoundaryGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_boundary_get_type();
+		static d_atk_text_boundary_get_type atk_text_boundary_get_type = FuncLoader.LoadFunction<d_atk_text_boundary_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_boundary_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_text_boundary_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextCaretMovedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextChangedHandler.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextClipType.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextGranularity.cs

@@ -0,0 +1,32 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.TextGranularityGType))]
+	public enum TextGranularity {
+
+		Char,
+		Word,
+		Sentence,
+		Line,
+		Paragraph,
+	}
+
+	internal class TextGranularityGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_granularity_get_type();
+		static d_atk_text_granularity_get_type atk_text_granularity_get_type = FuncLoader.LoadFunction<d_atk_text_granularity_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_granularity_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_text_granularity_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextInsertHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+	public delegate void TextInsertHandler(object o, TextInsertArgs args);
+
+	public class TextInsertArgs : GLib.SignalArgs {
+		public int P0{
+			get {
+				return (int) Args [0];
+			}
+		}
+
+		public int P1{
+			get {
+				return (int) Args [1];
+			}
+		}
+
+		public string P2{
+			get {
+				return (string) Args [2];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextRange.cs

@@ -0,0 +1,69 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct TextRange : IEquatable<TextRange> {
+
+		public Atk.TextRectangle Bounds;
+		public int StartOffset;
+		public int EndOffset;
+		public string Content;
+
+		public static Atk.TextRange Zero = new Atk.TextRange ();
+
+		public static Atk.TextRange New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Atk.TextRange.Zero;
+			return (Atk.TextRange) Marshal.PtrToStructure (raw, typeof (Atk.TextRange));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_text_range_get_type();
+		static d_atk_text_range_get_type atk_text_range_get_type = FuncLoader.LoadFunction<d_atk_text_range_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_text_range_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_text_range_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		public bool Equals (TextRange other)
+		{
+			return true && Bounds.Equals (other.Bounds) && StartOffset.Equals (other.StartOffset) && EndOffset.Equals (other.EndOffset) && Content.Equals (other.Content);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is TextRange && Equals ((TextRange) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Bounds.GetHashCode () ^ StartOffset.GetHashCode () ^ EndOffset.GetHashCode () ^ Content.GetHashCode ();
+		}
+
+		public static explicit operator GLib.Value (Atk.TextRange boxed)
+		{
+			GLib.Value val = GLib.Value.Empty;
+			val.Init (Atk.TextRange.GType);
+			val.Val = boxed;
+			return val;
+		}
+
+		public static explicit operator Atk.TextRange (GLib.Value val)
+		{
+			return (Atk.TextRange) val.Val;
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextRectangle.cs

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

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/TextRemoveHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+	public delegate void TextRemoveHandler(object o, TextRemoveArgs args);
+
+	public class TextRemoveArgs : GLib.SignalArgs {
+		public int P0{
+			get {
+				return (int) Args [0];
+			}
+		}
+
+		public int P1{
+			get {
+				return (int) Args [1];
+			}
+		}
+
+		public string P2{
+			get {
+				return (string) Args [2];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/Util.cs

@@ -0,0 +1,296 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Util : GLib.Object {
+
+		public Util (IntPtr raw) : base(raw) {}
+
+		protected Util() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		static AddKeyEventListenerNativeDelegate AddKeyEventListener_cb_delegate;
+		static AddKeyEventListenerNativeDelegate AddKeyEventListenerVMCallback {
+			get {
+				if (AddKeyEventListener_cb_delegate == null)
+					AddKeyEventListener_cb_delegate = new AddKeyEventListenerNativeDelegate (AddKeyEventListener_cb);
+				return AddKeyEventListener_cb_delegate;
+			}
+		}
+
+		public delegate uint AddKeyEventListenerDelegate (Atk.KeySnoopFunc listener);
+		static AddKeyEventListenerDelegate add_key_event_listener_handler;
+
+		public static AddKeyEventListenerDelegate AddKeyEventListenerHandler {
+			set {
+				add_key_event_listener_handler = value;
+				OverrideAddKeyEventListener ((GLib.GType) typeof (Util), value == null ? null : AddKeyEventListenerVMCallback);
+			}
+		}
+
+		static void OverrideAddKeyEventListener (GLib.GType gtype, AddKeyEventListenerNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("add_key_event_listener"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint AddKeyEventListenerNativeDelegate (AtkSharp.KeySnoopFuncNative listener, IntPtr data);
+
+		static uint AddKeyEventListener_cb (AtkSharp.KeySnoopFuncNative listener, IntPtr data)
+		{
+			try {
+				uint __result;
+				AtkSharp.KeySnoopFuncInvoker listener_invoker = new AtkSharp.KeySnoopFuncInvoker (listener, data);
+				__result = add_key_event_listener_handler (listener_invoker.Handler);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		static GetRootNativeDelegate GetRoot_cb_delegate;
+		static GetRootNativeDelegate GetRootVMCallback {
+			get {
+				if (GetRoot_cb_delegate == null)
+					GetRoot_cb_delegate = new GetRootNativeDelegate (GetRoot_cb);
+				return GetRoot_cb_delegate;
+			}
+		}
+
+		public delegate Atk.Object GetRootDelegate ();
+		static GetRootDelegate get_root_handler;
+
+		public static GetRootDelegate GetRootHandler {
+			set {
+				get_root_handler = value;
+				OverrideGetRoot ((GLib.GType) typeof (Util), value == null ? null : GetRootVMCallback);
+			}
+		}
+
+		static void OverrideGetRoot (GLib.GType gtype, GetRootNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_root"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetRootNativeDelegate ();
+
+		static IntPtr GetRoot_cb ()
+		{
+			try {
+				Atk.Object __result;
+				__result = get_root_handler ();
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		static GetToolkitNameNativeDelegate GetToolkitName_cb_delegate;
+		static GetToolkitNameNativeDelegate GetToolkitNameVMCallback {
+			get {
+				if (GetToolkitName_cb_delegate == null)
+					GetToolkitName_cb_delegate = new GetToolkitNameNativeDelegate (GetToolkitName_cb);
+				return GetToolkitName_cb_delegate;
+			}
+		}
+
+		public delegate string GetToolkitNameDelegate ();
+		static GetToolkitNameDelegate get_toolkit_name_handler;
+
+		public static GetToolkitNameDelegate GetToolkitNameHandler {
+			set {
+				get_toolkit_name_handler = value;
+				OverrideGetToolkitName ((GLib.GType) typeof (Util), value == null ? null : GetToolkitNameVMCallback);
+			}
+		}
+
+		static void OverrideGetToolkitName (GLib.GType gtype, GetToolkitNameNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_toolkit_name"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetToolkitNameNativeDelegate ();
+
+		static IntPtr GetToolkitName_cb ()
+		{
+			try {
+				string __result;
+				__result = get_toolkit_name_handler ();
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		static GetToolkitVersionNativeDelegate GetToolkitVersion_cb_delegate;
+		static GetToolkitVersionNativeDelegate GetToolkitVersionVMCallback {
+			get {
+				if (GetToolkitVersion_cb_delegate == null)
+					GetToolkitVersion_cb_delegate = new GetToolkitVersionNativeDelegate (GetToolkitVersion_cb);
+				return GetToolkitVersion_cb_delegate;
+			}
+		}
+
+		public delegate string GetToolkitVersionDelegate ();
+		static GetToolkitVersionDelegate get_toolkit_version_handler;
+
+		public static GetToolkitVersionDelegate GetToolkitVersionHandler {
+			set {
+				get_toolkit_version_handler = value;
+				OverrideGetToolkitVersion ((GLib.GType) typeof (Util), value == null ? null : GetToolkitVersionVMCallback);
+			}
+		}
+
+		static void OverrideGetToolkitVersion (GLib.GType gtype, GetToolkitVersionNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_toolkit_version"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetToolkitVersionNativeDelegate ();
+
+		static IntPtr GetToolkitVersion_cb ()
+		{
+			try {
+				string __result;
+				__result = get_toolkit_version_handler ();
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+
+		// 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("add_global_event_listener"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // add_global_event_listener
+							, null
+							, "remove_global_event_listener"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("remove_global_event_listener"
+							, -1
+							, (uint) sizeof( IntPtr ) // remove_global_event_listener
+							, "add_global_event_listener"
+							, "add_key_event_listener"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("add_key_event_listener"
+							, -1
+							, (uint) sizeof( IntPtr ) // add_key_event_listener
+							, "remove_global_event_listener"
+							, "remove_key_event_listener"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("remove_key_event_listener"
+							, -1
+							, (uint) sizeof( IntPtr ) // remove_key_event_listener
+							, "add_key_event_listener"
+							, "get_root"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_root"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_root
+							, "remove_key_event_listener"
+							, "get_toolkit_name"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_toolkit_name"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_toolkit_name
+							, "get_root"
+							, "get_toolkit_version"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("get_toolkit_version"
+							, -1
+							, (uint) sizeof( IntPtr ) // get_toolkit_version
+							, "get_toolkit_name"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_util_get_type();
+		static d_atk_util_get_type atk_util_get_type = FuncLoader.LoadFunction<d_atk_util_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_util_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = atk_util_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/AtkSharp/Generated/Atk/UtilListenerInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class UtilListenerInfo : GLib.Opaque {
+
+		public UtilListenerInfo(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/AtkSharp/Generated/Atk/ValueAdapter.cs

@@ -0,0 +1,444 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ValueAdapter : GLib.GInterfaceAdapter, Atk.IValue {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct AtkValueIface {
+			public GetCurrentValueNativeDelegate GetCurrentValue;
+			public GetMaximumValueNativeDelegate GetMaximumValue;
+			public GetMinimumValueNativeDelegate GetMinimumValue;
+			public SetCurrentValueNativeDelegate SetCurrentValue;
+			public GetMinimumIncrementNativeDelegate GetMinimumIncrement;
+			public GetValueAndTextNativeDelegate GetValueAndText;
+			public GetRangeNativeDelegate GetRange;
+			public GetIncrementNativeDelegate GetIncrement;
+			public GetSubRangesNativeDelegate GetSubRanges;
+			public SetValueNativeDelegate SetValue;
+		}
+
+		static AtkValueIface iface;
+
+		static ValueAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (ValueAdapter));
+			iface.GetCurrentValue = new GetCurrentValueNativeDelegate (GetCurrentValue_cb);
+			iface.GetMaximumValue = new GetMaximumValueNativeDelegate (GetMaximumValue_cb);
+			iface.GetMinimumValue = new GetMinimumValueNativeDelegate (GetMinimumValue_cb);
+			iface.SetCurrentValue = new SetCurrentValueNativeDelegate (SetCurrentValue_cb);
+			iface.GetMinimumIncrement = new GetMinimumIncrementNativeDelegate (GetMinimumIncrement_cb);
+			iface.GetValueAndText = new GetValueAndTextNativeDelegate (GetValueAndText_cb);
+			iface.GetRange = new GetRangeNativeDelegate (GetRange_cb);
+			iface.GetIncrement = new GetIncrementNativeDelegate (GetIncrement_cb);
+			iface.GetSubRanges = new GetSubRangesNativeDelegate (GetSubRanges_cb);
+			iface.SetValue = new SetValueNativeDelegate (SetValue_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetCurrentValueNativeDelegate (IntPtr inst, IntPtr value);
+
+		static void GetCurrentValue_cb (IntPtr inst, IntPtr value)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				GLib.Value myvalue = (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value));
+				__obj.GetCurrentValue (ref myvalue);
+				if (value != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (myvalue, value, false);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetMaximumValueNativeDelegate (IntPtr inst, IntPtr value);
+
+		static void GetMaximumValue_cb (IntPtr inst, IntPtr value)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				GLib.Value myvalue = (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value));
+				__obj.GetMaximumValue (ref myvalue);
+				if (value != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (myvalue, value, false);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetMinimumValueNativeDelegate (IntPtr inst, IntPtr value);
+
+		static void GetMinimumValue_cb (IntPtr inst, IntPtr value)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				GLib.Value myvalue = (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value));
+				__obj.GetMinimumValue (ref myvalue);
+				if (value != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (myvalue, value, false);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool SetCurrentValueNativeDelegate (IntPtr inst, IntPtr value);
+
+		static bool SetCurrentValue_cb (IntPtr inst, IntPtr value)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				bool __result;
+				__result = __obj.SetCurrentValue ((GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetMinimumIncrementNativeDelegate (IntPtr inst, IntPtr value);
+
+		static void GetMinimumIncrement_cb (IntPtr inst, IntPtr value)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				GLib.Value myvalue = (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value));
+				__obj.GetMinimumIncrement (ref myvalue);
+				if (value != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (myvalue, value, false);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void GetValueAndTextNativeDelegate (IntPtr inst, out double value, IntPtr text);
+
+		static void GetValueAndText_cb (IntPtr inst, out double value, IntPtr text)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				__obj.GetValueAndText (out value, GLib.Marshaller.PtrToStringGFree(text));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetRangeNativeDelegate (IntPtr inst);
+
+		static IntPtr GetRange_cb (IntPtr inst)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				Atk.Range __result;
+				__result = __obj.Range;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double GetIncrementNativeDelegate (IntPtr inst);
+
+		static double GetIncrement_cb (IntPtr inst)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				double __result;
+				__result = __obj.Increment;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetSubRangesNativeDelegate (IntPtr inst);
+
+		static IntPtr GetSubRanges_cb (IntPtr inst)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				GLib.SList __result;
+				__result = __obj.SubRanges;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void SetValueNativeDelegate (IntPtr inst, double new_value);
+
+		static void SetValue_cb (IntPtr inst, double new_value)
+		{
+			try {
+				IValueImplementor __obj = GLib.Object.GetObject (inst, false) as IValueImplementor;
+				__obj.Value = new_value;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		static int class_offset = 2 * IntPtr.Size;
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
+			AtkValueIface native_iface = (AtkValueIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkValueIface));
+			native_iface.GetCurrentValue = iface.GetCurrentValue;
+			native_iface.GetMaximumValue = iface.GetMaximumValue;
+			native_iface.GetMinimumValue = iface.GetMinimumValue;
+			native_iface.SetCurrentValue = iface.SetCurrentValue;
+			native_iface.GetMinimumIncrement = iface.GetMinimumIncrement;
+			native_iface.GetValueAndText = iface.GetValueAndText;
+			native_iface.GetRange = iface.GetRange;
+			native_iface.GetIncrement = iface.GetIncrement;
+			native_iface.GetSubRanges = iface.GetSubRanges;
+			native_iface.SetValue = iface.SetValue;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public ValueAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public ValueAdapter (IValueImplementor 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 ValueAdapter (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_atk_value_get_type();
+		static d_atk_value_get_type atk_value_get_type = FuncLoader.LoadFunction<d_atk_value_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (atk_value_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 IValue GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IValue GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IValueImplementor)
+				return new ValueAdapter (obj as IValueImplementor);
+			else if (obj as IValue == null)
+				return new ValueAdapter (obj.Handle);
+			else
+				return obj as IValue;
+		}
+
+		public IValueImplementor Implementor {
+			get {
+				return implementor as IValueImplementor;
+			}
+		}
+
+		[GLib.Signal("value_changed")]
+		public event Atk.ValueChangedHandler ValueChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("value_changed", value, typeof (Atk.ValueChangedArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("value_changed", value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_value_get_current_value(IntPtr raw, IntPtr value);
+		static d_atk_value_get_current_value atk_value_get_current_value = FuncLoader.LoadFunction<d_atk_value_get_current_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_current_value"));
+
+		[Obsolete]
+		public void GetCurrentValue(ref GLib.Value value) {
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			atk_value_get_current_value(Handle, native_value);
+			value = (GLib.Value) Marshal.PtrToStructure (native_value, typeof (GLib.Value));
+			Marshal.FreeHGlobal (native_value);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_atk_value_get_increment(IntPtr raw);
+		static d_atk_value_get_increment atk_value_get_increment = FuncLoader.LoadFunction<d_atk_value_get_increment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_increment"));
+
+		public double Increment { 
+			get {
+				double raw_ret = atk_value_get_increment(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_value_get_maximum_value(IntPtr raw, IntPtr value);
+		static d_atk_value_get_maximum_value atk_value_get_maximum_value = FuncLoader.LoadFunction<d_atk_value_get_maximum_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_maximum_value"));
+
+		[Obsolete]
+		public void GetMaximumValue(ref GLib.Value value) {
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			atk_value_get_maximum_value(Handle, native_value);
+			value = (GLib.Value) Marshal.PtrToStructure (native_value, typeof (GLib.Value));
+			Marshal.FreeHGlobal (native_value);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_value_get_minimum_increment(IntPtr raw, IntPtr value);
+		static d_atk_value_get_minimum_increment atk_value_get_minimum_increment = FuncLoader.LoadFunction<d_atk_value_get_minimum_increment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_minimum_increment"));
+
+		[Obsolete]
+		public void GetMinimumIncrement(ref GLib.Value value) {
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			atk_value_get_minimum_increment(Handle, native_value);
+			value = (GLib.Value) Marshal.PtrToStructure (native_value, typeof (GLib.Value));
+			Marshal.FreeHGlobal (native_value);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_value_get_minimum_value(IntPtr raw, IntPtr value);
+		static d_atk_value_get_minimum_value atk_value_get_minimum_value = FuncLoader.LoadFunction<d_atk_value_get_minimum_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_minimum_value"));
+
+		[Obsolete]
+		public void GetMinimumValue(ref GLib.Value value) {
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			atk_value_get_minimum_value(Handle, native_value);
+			value = (GLib.Value) Marshal.PtrToStructure (native_value, typeof (GLib.Value));
+			Marshal.FreeHGlobal (native_value);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_value_get_range(IntPtr raw);
+		static d_atk_value_get_range atk_value_get_range = FuncLoader.LoadFunction<d_atk_value_get_range>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_range"));
+
+		public Atk.Range Range { 
+			get {
+				IntPtr raw_ret = atk_value_get_range(Handle);
+				Atk.Range ret = raw_ret == IntPtr.Zero ? null : (Atk.Range) GLib.Opaque.GetOpaque (raw_ret, typeof (Atk.Range), false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_value_get_sub_ranges(IntPtr raw);
+		static d_atk_value_get_sub_ranges atk_value_get_sub_ranges = FuncLoader.LoadFunction<d_atk_value_get_sub_ranges>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_sub_ranges"));
+
+		public GLib.SList SubRanges { 
+			get {
+				IntPtr raw_ret = atk_value_get_sub_ranges(Handle);
+				GLib.SList ret = new GLib.SList(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_value_get_value_and_text(IntPtr raw, out double value, IntPtr text);
+		static d_atk_value_get_value_and_text atk_value_get_value_and_text = FuncLoader.LoadFunction<d_atk_value_get_value_and_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_get_value_and_text"));
+
+		public double GetValueAndText(string text) {
+			double value;
+			atk_value_get_value_and_text(Handle, out value, GLib.Marshaller.StringToPtrGStrdup(text));
+			return value;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_atk_value_set_current_value(IntPtr raw, IntPtr value);
+		static d_atk_value_set_current_value atk_value_set_current_value = FuncLoader.LoadFunction<d_atk_value_set_current_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_set_current_value"));
+
+		[Obsolete]
+		public bool SetCurrentValue(GLib.Value value) {
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			bool raw_ret = atk_value_set_current_value(Handle, native_value);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_value);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_atk_value_set_value(IntPtr raw, double new_value);
+		static d_atk_value_set_value atk_value_set_value = FuncLoader.LoadFunction<d_atk_value_set_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_set_value"));
+
+		public double Value { 
+			set {
+				atk_value_set_value(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_value_type_get_localized_name(int value_type);
+		static d_atk_value_type_get_localized_name atk_value_type_get_localized_name = FuncLoader.LoadFunction<d_atk_value_type_get_localized_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_type_get_localized_name"));
+
+		public static string TypeGetLocalizedName(Atk.ValueType value_type) {
+			IntPtr raw_ret = atk_value_type_get_localized_name((int) value_type);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_value_type_get_name(int value_type);
+		static d_atk_value_type_get_name atk_value_type_get_name = FuncLoader.LoadFunction<d_atk_value_type_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_type_get_name"));
+
+		public static string TypeGetName(Atk.ValueType value_type) {
+			IntPtr raw_ret = atk_value_type_get_name((int) value_type);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ValueChangedHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+
+	public delegate void ValueChangedHandler(object o, ValueChangedArgs args);
+
+	public class ValueChangedArgs : GLib.SignalArgs {
+		public double P0{
+			get {
+				return (double) Args [0];
+			}
+		}
+
+		public string P1{
+			get {
+				return (string) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/AtkSharp/Generated/Atk/ValueType.cs

@@ -0,0 +1,43 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Atk {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Atk.ValueTypeGType))]
+	public enum ValueType {
+
+		VeryWeak,
+		Weak,
+		Acceptable,
+		Strong,
+		VeryStrong,
+		VeryLow,
+		Low,
+		Medium,
+		High,
+		VeryHigh,
+		VeryBad,
+		Bad,
+		Good,
+		VeryGood,
+		Best,
+		LastDefined,
+	}
+
+	internal class ValueTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_atk_value_type_get_type();
+		static d_atk_value_type_get_type atk_value_type_get_type = FuncLoader.LoadFunction<d_atk_value_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_value_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (atk_value_type_get_type ());
+			}
+		}
+	}
+#endregion
+}