// 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 Object : GLib.Object {

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

		protected Object() : base(IntPtr.Zero)
		{
			CreateNativeObject (new string [0], new GLib.Value [0]);
		}

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

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

		[GLib.Property ("atk_object_name_property_parent")]
		public Atk.Object AtkObjectNamePropertyParent {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_parent");
				Atk.Object ret = (Atk.Object) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("atk_object_name_property_parent", val);
				val.Dispose ();
			}
		}

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

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

		[GLib.Property ("atk_object_name_property_component_layer")]
		public int AtkObjectNamePropertyComponentLayer {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_component_layer");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("atk_object_name_property_component_mdi_zorder")]
		public int AtkObjectNamePropertyComponentMdiZorder {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_component_mdi_zorder");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Property ("atk_object_name_property_table_column_header")]
		public Atk.Object AtkObjectNamePropertyTableColumnHeader {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_table_column_header");
				Atk.Object ret = (Atk.Object) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("atk_object_name_property_table_column_header", val);
				val.Dispose ();
			}
		}

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

		[GLib.Property ("atk_object_name_property_table_row_header")]
		public Atk.Object AtkObjectNamePropertyTableRowHeader {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_table_row_header");
				Atk.Object ret = (Atk.Object) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("atk_object_name_property_table_row_header", val);
				val.Dispose ();
			}
		}

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

		[GLib.Property ("atk_object_name_property_table_summary")]
		public Atk.Object AtkObjectNamePropertyTableSummary {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_table_summary");
				Atk.Object ret = (Atk.Object) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("atk_object_name_property_table_summary", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("atk_object_name_property_table_caption_object")]
		public Atk.Object AtkObjectNamePropertyTableCaptionObject {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_table_caption_object");
				Atk.Object ret = (Atk.Object) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("atk_object_name_property_table_caption_object", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("atk_object_name_property_hypertext_num_links")]
		public int AtkObjectNamePropertyHypertextNumLinks {
			get {
				GLib.Value val = GetProperty ("atk_object_name_property_hypertext_num_links");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_get_description(IntPtr raw);

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void atk_object_set_description(IntPtr raw, IntPtr description);

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

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_get_name(IntPtr raw);

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void atk_object_set_name(IntPtr raw, IntPtr name);

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

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int atk_object_get_role(IntPtr raw);

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void atk_object_set_role(IntPtr raw, int role);

		public Atk.Role Role {
			get  {
				int raw_ret = atk_object_get_role(Handle);
				Atk.Role ret = (Atk.Role) raw_ret;
				return ret;
			}
			set  {
				atk_object_set_role(Handle, (int) value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ActiveDescendantChangedSignalDelegate (IntPtr inst, IntPtr arg0, IntPtr gch);

		static void ActiveDescendantChangedSignalCallback (IntPtr inst, IntPtr arg0, IntPtr gch)
		{
			Atk.ActiveDescendantChangedArgs args = new Atk.ActiveDescendantChangedArgs ();
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[1];
				args.Args[0] = arg0;
				Atk.ActiveDescendantChangedHandler handler = (Atk.ActiveDescendantChangedHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.Signal("active_descendant_changed")]
		public event Atk.ActiveDescendantChangedHandler ActiveDescendantChanged {
			add {
				this.AddSignalHandler ("active_descendant_changed", value, new ActiveDescendantChangedSignalDelegate(ActiveDescendantChangedSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("active_descendant_changed", value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChildrenChangedSignalDelegate (IntPtr inst, uint arg0, IntPtr arg1, IntPtr gch);

		static void ChildrenChangedSignalCallback (IntPtr inst, uint arg0, IntPtr arg1, IntPtr gch)
		{
			Atk.ChildrenChangedArgs args = new Atk.ChildrenChangedArgs ();
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[2];
				args.Args[0] = arg0;
				args.Args[1] = arg1;
				Atk.ChildrenChangedHandler handler = (Atk.ChildrenChangedHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.Signal("children_changed")]
		public event Atk.ChildrenChangedHandler ChildrenChanged {
			add {
				this.AddSignalHandler ("children_changed", value, new ChildrenChangedSignalDelegate(ChildrenChangedSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("children_changed", value);
			}
		}

		[GLib.Signal("state_change")]
		public event Atk.StateChangeHandler StateChange {
			add {
				this.AddSignalHandler ("state_change", value, typeof (Atk.StateChangeArgs));
			}
			remove {
				this.RemoveSignalHandler ("state_change", value);
			}
		}

		[GLib.Signal("focus_event")]
		public event Atk.FocusEventHandler FocusEvent {
			add {
				this.AddSignalHandler ("focus_event", value, typeof (Atk.FocusEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("focus_event", value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PropertyChangeSignalDelegate (IntPtr inst, IntPtr arg0, IntPtr gch);

		static void PropertyChangeSignalCallback (IntPtr inst, IntPtr arg0, IntPtr gch)
		{
			Atk.PropertyChangeArgs args = new Atk.PropertyChangeArgs ();
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[1];
				args.Args[0] = Atk.PropertyValues.New (arg0);
				Atk.PropertyChangeEventHandler handler = (Atk.PropertyChangeEventHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.Signal("property_change")]
		public event Atk.PropertyChangeEventHandler PropertyChange {
			add {
				this.AddSignalHandler ("property_change", value, new PropertyChangeSignalDelegate(PropertyChangeSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("property_change", value);
			}
		}

		static GetNameNativeDelegate GetName_cb_delegate;
		static GetNameNativeDelegate GetNameVMCallback {
			get {
				if (GetName_cb_delegate == null)
					GetName_cb_delegate = new GetNameNativeDelegate (GetName_cb);
				return GetName_cb_delegate;
			}
		}

		static void OverrideGetName (GLib.GType gtype)
		{
			OverrideGetName (gtype, GetNameVMCallback);
		}

		static void OverrideGetName (GLib.GType gtype, GetNameNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_name"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetName_cb (IntPtr inst)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				string __result;
				__result = __obj.OnGetName ();
				return GLib.Marshaller.StringToPtrGStrdup(__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetName")]
		protected virtual string OnGetName ()
		{
			return InternalGetName ();
		}

		private string InternalGetName ()
		{
			GetNameNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_name"));
				unmanaged = (GetNameNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetNameNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return GLib.Marshaller.PtrToStringGFree(__result);
		}

		static GetDescriptionNativeDelegate GetDescription_cb_delegate;
		static GetDescriptionNativeDelegate GetDescriptionVMCallback {
			get {
				if (GetDescription_cb_delegate == null)
					GetDescription_cb_delegate = new GetDescriptionNativeDelegate (GetDescription_cb);
				return GetDescription_cb_delegate;
			}
		}

		static void OverrideGetDescription (GLib.GType gtype)
		{
			OverrideGetDescription (gtype, GetDescriptionVMCallback);
		}

		static void OverrideGetDescription (GLib.GType gtype, GetDescriptionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_description"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetDescription_cb (IntPtr inst)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				string __result;
				__result = __obj.OnGetDescription ();
				return GLib.Marshaller.StringToPtrGStrdup(__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetDescription")]
		protected virtual string OnGetDescription ()
		{
			return InternalGetDescription ();
		}

		private string InternalGetDescription ()
		{
			GetDescriptionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_description"));
				unmanaged = (GetDescriptionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetDescriptionNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return GLib.Marshaller.PtrToStringGFree(__result);
		}

		static GetParentNativeDelegate GetParent_cb_delegate;
		static GetParentNativeDelegate GetParentVMCallback {
			get {
				if (GetParent_cb_delegate == null)
					GetParent_cb_delegate = new GetParentNativeDelegate (GetParent_cb);
				return GetParent_cb_delegate;
			}
		}

		static void OverrideGetParent (GLib.GType gtype)
		{
			OverrideGetParent (gtype, GetParentVMCallback);
		}

		static void OverrideGetParent (GLib.GType gtype, GetParentNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_parent"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetParent")]
		protected virtual Atk.Object OnGetParent ()
		{
			return InternalGetParent ();
		}

		private Atk.Object InternalGetParent ()
		{
			GetParentNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_parent"));
				unmanaged = (GetParentNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetParentNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetNChildrenNativeDelegate GetNChildren_cb_delegate;
		static GetNChildrenNativeDelegate GetNChildrenVMCallback {
			get {
				if (GetNChildren_cb_delegate == null)
					GetNChildren_cb_delegate = new GetNChildrenNativeDelegate (GetNChildren_cb);
				return GetNChildren_cb_delegate;
			}
		}

		static void OverrideGetNChildren (GLib.GType gtype)
		{
			OverrideGetNChildren (gtype, GetNChildrenVMCallback);
		}

		static void OverrideGetNChildren (GLib.GType gtype, GetNChildrenNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_n_children"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetNChildren")]
		protected virtual int OnGetNChildren ()
		{
			return InternalGetNChildren ();
		}

		private int InternalGetNChildren ()
		{
			GetNChildrenNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_n_children"));
				unmanaged = (GetNChildrenNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetNChildrenNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static RefChildNativeDelegate RefChild_cb_delegate;
		static RefChildNativeDelegate RefChildVMCallback {
			get {
				if (RefChild_cb_delegate == null)
					RefChild_cb_delegate = new RefChildNativeDelegate (RefChild_cb);
				return RefChild_cb_delegate;
			}
		}

		static void OverrideRefChild (GLib.GType gtype)
		{
			OverrideRefChild (gtype, RefChildVMCallback);
		}

		static void OverrideRefChild (GLib.GType gtype, RefChildNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("ref_child"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr RefChildNativeDelegate (IntPtr inst, int i);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideRefChild")]
		protected virtual Atk.Object OnRefChild (int i)
		{
			return InternalRefChild (i);
		}

		private Atk.Object InternalRefChild (int i)
		{
			RefChildNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("ref_child"));
				unmanaged = (RefChildNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RefChildNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetIndexInParentNativeDelegate GetIndexInParent_cb_delegate;
		static GetIndexInParentNativeDelegate GetIndexInParentVMCallback {
			get {
				if (GetIndexInParent_cb_delegate == null)
					GetIndexInParent_cb_delegate = new GetIndexInParentNativeDelegate (GetIndexInParent_cb);
				return GetIndexInParent_cb_delegate;
			}
		}

		static void OverrideGetIndexInParent (GLib.GType gtype)
		{
			OverrideGetIndexInParent (gtype, GetIndexInParentVMCallback);
		}

		static void OverrideGetIndexInParent (GLib.GType gtype, GetIndexInParentNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_index_in_parent"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetIndexInParent")]
		protected virtual int OnGetIndexInParent ()
		{
			return InternalGetIndexInParent ();
		}

		private int InternalGetIndexInParent ()
		{
			GetIndexInParentNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_index_in_parent"));
				unmanaged = (GetIndexInParentNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetIndexInParentNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static RefRelationSetNativeDelegate RefRelationSet_cb_delegate;
		static RefRelationSetNativeDelegate RefRelationSetVMCallback {
			get {
				if (RefRelationSet_cb_delegate == null)
					RefRelationSet_cb_delegate = new RefRelationSetNativeDelegate (RefRelationSet_cb);
				return RefRelationSet_cb_delegate;
			}
		}

		static void OverrideRefRelationSet (GLib.GType gtype)
		{
			OverrideRefRelationSet (gtype, RefRelationSetVMCallback);
		}

		static void OverrideRefRelationSet (GLib.GType gtype, RefRelationSetNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("ref_relation_set"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideRefRelationSet")]
		protected virtual Atk.RelationSet OnRefRelationSet ()
		{
			return InternalRefRelationSet ();
		}

		private Atk.RelationSet InternalRefRelationSet ()
		{
			RefRelationSetNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("ref_relation_set"));
				unmanaged = (RefRelationSetNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RefRelationSetNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetRoleNativeDelegate GetRole_cb_delegate;
		static GetRoleNativeDelegate GetRoleVMCallback {
			get {
				if (GetRole_cb_delegate == null)
					GetRole_cb_delegate = new GetRoleNativeDelegate (GetRole_cb);
				return GetRole_cb_delegate;
			}
		}

		static void OverrideGetRole (GLib.GType gtype)
		{
			OverrideGetRole (gtype, GetRoleVMCallback);
		}

		static void OverrideGetRole (GLib.GType gtype, GetRoleNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_role"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static int GetRole_cb (IntPtr inst)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				Atk.Role __result;
				__result = __obj.OnGetRole ();
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetRole")]
		protected virtual Atk.Role OnGetRole ()
		{
			return InternalGetRole ();
		}

		private Atk.Role InternalGetRole ()
		{
			GetRoleNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_role"));
				unmanaged = (GetRoleNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetRoleNativeDelegate));
			}
			if (unmanaged == null) return (Atk.Role) 0;

			int __result = unmanaged (this.Handle);
			return (Atk.Role) __result;
		}

		static GetLayerNativeDelegate GetLayer_cb_delegate;
		static GetLayerNativeDelegate GetLayerVMCallback {
			get {
				if (GetLayer_cb_delegate == null)
					GetLayer_cb_delegate = new GetLayerNativeDelegate (GetLayer_cb);
				return GetLayer_cb_delegate;
			}
		}

		static void OverrideGetLayer (GLib.GType gtype)
		{
			OverrideGetLayer (gtype, GetLayerVMCallback);
		}

		static void OverrideGetLayer (GLib.GType gtype, GetLayerNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_layer"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static int GetLayer_cb (IntPtr inst)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				Atk.Layer __result;
				__result = __obj.OnGetLayer ();
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetLayer")]
		protected virtual Atk.Layer OnGetLayer ()
		{
			return InternalGetLayer ();
		}

		private Atk.Layer InternalGetLayer ()
		{
			GetLayerNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_layer"));
				unmanaged = (GetLayerNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetLayerNativeDelegate));
			}
			if (unmanaged == null) return (Atk.Layer) 0;

			int __result = unmanaged (this.Handle);
			return (Atk.Layer) __result;
		}

		static GetMdiZorderNativeDelegate GetMdiZorder_cb_delegate;
		static GetMdiZorderNativeDelegate GetMdiZorderVMCallback {
			get {
				if (GetMdiZorder_cb_delegate == null)
					GetMdiZorder_cb_delegate = new GetMdiZorderNativeDelegate (GetMdiZorder_cb);
				return GetMdiZorder_cb_delegate;
			}
		}

		static void OverrideGetMdiZorder (GLib.GType gtype)
		{
			OverrideGetMdiZorder (gtype, GetMdiZorderVMCallback);
		}

		static void OverrideGetMdiZorder (GLib.GType gtype, GetMdiZorderNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_mdi_zorder"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetMdiZorder")]
		protected virtual int OnGetMdiZorder ()
		{
			return InternalGetMdiZorder ();
		}

		private int InternalGetMdiZorder ()
		{
			GetMdiZorderNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_mdi_zorder"));
				unmanaged = (GetMdiZorderNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMdiZorderNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static RefStateSetNativeDelegate RefStateSet_cb_delegate;
		static RefStateSetNativeDelegate RefStateSetVMCallback {
			get {
				if (RefStateSet_cb_delegate == null)
					RefStateSet_cb_delegate = new RefStateSetNativeDelegate (RefStateSet_cb);
				return RefStateSet_cb_delegate;
			}
		}

		static void OverrideRefStateSet (GLib.GType gtype)
		{
			OverrideRefStateSet (gtype, RefStateSetVMCallback);
		}

		static void OverrideRefStateSet (GLib.GType gtype, RefStateSetNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("ref_state_set"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideRefStateSet")]
		protected virtual Atk.StateSet OnRefStateSet ()
		{
			return InternalRefStateSet ();
		}

		private Atk.StateSet InternalRefStateSet ()
		{
			RefStateSetNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("ref_state_set"));
				unmanaged = (RefStateSetNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RefStateSetNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static SetNameNativeDelegate SetName_cb_delegate;
		static SetNameNativeDelegate SetNameVMCallback {
			get {
				if (SetName_cb_delegate == null)
					SetName_cb_delegate = new SetNameNativeDelegate (SetName_cb);
				return SetName_cb_delegate;
			}
		}

		static void OverrideSetName (GLib.GType gtype)
		{
			OverrideSetName (gtype, SetNameVMCallback);
		}

		static void OverrideSetName (GLib.GType gtype, SetNameNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_name"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetNameNativeDelegate (IntPtr inst, IntPtr name);

		static void SetName_cb (IntPtr inst, IntPtr name)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnSetName (GLib.Marshaller.Utf8PtrToString (name));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideSetName")]
		protected virtual void OnSetName (string name)
		{
			InternalSetName (name);
		}

		private void InternalSetName (string name)
		{
			SetNameNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_name"));
				unmanaged = (SetNameNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetNameNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			unmanaged (this.Handle, native_name);
			GLib.Marshaller.Free (native_name);
		}

		static SetDescriptionNativeDelegate SetDescription_cb_delegate;
		static SetDescriptionNativeDelegate SetDescriptionVMCallback {
			get {
				if (SetDescription_cb_delegate == null)
					SetDescription_cb_delegate = new SetDescriptionNativeDelegate (SetDescription_cb);
				return SetDescription_cb_delegate;
			}
		}

		static void OverrideSetDescription (GLib.GType gtype)
		{
			OverrideSetDescription (gtype, SetDescriptionVMCallback);
		}

		static void OverrideSetDescription (GLib.GType gtype, SetDescriptionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_description"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetDescriptionNativeDelegate (IntPtr inst, IntPtr description);

		static void SetDescription_cb (IntPtr inst, IntPtr description)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnSetDescription (GLib.Marshaller.Utf8PtrToString (description));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideSetDescription")]
		protected virtual void OnSetDescription (string description)
		{
			InternalSetDescription (description);
		}

		private void InternalSetDescription (string description)
		{
			SetDescriptionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_description"));
				unmanaged = (SetDescriptionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetDescriptionNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_description = GLib.Marshaller.StringToPtrGStrdup (description);
			unmanaged (this.Handle, native_description);
			GLib.Marshaller.Free (native_description);
		}

		static SetParentNativeDelegate SetParent_cb_delegate;
		static SetParentNativeDelegate SetParentVMCallback {
			get {
				if (SetParent_cb_delegate == null)
					SetParent_cb_delegate = new SetParentNativeDelegate (SetParent_cb);
				return SetParent_cb_delegate;
			}
		}

		static void OverrideSetParent (GLib.GType gtype)
		{
			OverrideSetParent (gtype, SetParentVMCallback);
		}

		static void OverrideSetParent (GLib.GType gtype, SetParentNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parent"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetParentNativeDelegate (IntPtr inst, IntPtr parent);

		static void SetParent_cb (IntPtr inst, IntPtr parent)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnSetParent (GLib.Object.GetObject(parent) as Atk.Object);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideSetParent")]
		protected virtual void OnSetParent (Atk.Object parent)
		{
			InternalSetParent (parent);
		}

		private void InternalSetParent (Atk.Object parent)
		{
			SetParentNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parent"));
				unmanaged = (SetParentNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetParentNativeDelegate));
			}
			if (unmanaged == null) return;

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

		static SetRoleNativeDelegate SetRole_cb_delegate;
		static SetRoleNativeDelegate SetRoleVMCallback {
			get {
				if (SetRole_cb_delegate == null)
					SetRole_cb_delegate = new SetRoleNativeDelegate (SetRole_cb);
				return SetRole_cb_delegate;
			}
		}

		static void OverrideSetRole (GLib.GType gtype)
		{
			OverrideSetRole (gtype, SetRoleVMCallback);
		}

		static void OverrideSetRole (GLib.GType gtype, SetRoleNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_role"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetRoleNativeDelegate (IntPtr inst, int role);

		static void SetRole_cb (IntPtr inst, int role)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnSetRole ((Atk.Role) role);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideSetRole")]
		protected virtual void OnSetRole (Atk.Role role)
		{
			InternalSetRole (role);
		}

		private void InternalSetRole (Atk.Role role)
		{
			SetRoleNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_role"));
				unmanaged = (SetRoleNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetRoleNativeDelegate));
			}
			if (unmanaged == null) return;

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

		static InitializeNativeDelegate Initialize_cb_delegate;
		static InitializeNativeDelegate InitializeVMCallback {
			get {
				if (Initialize_cb_delegate == null)
					Initialize_cb_delegate = new InitializeNativeDelegate (Initialize_cb);
				return Initialize_cb_delegate;
			}
		}

		static void OverrideInitialize (GLib.GType gtype)
		{
			OverrideInitialize (gtype, InitializeVMCallback);
		}

		static void OverrideInitialize (GLib.GType gtype, InitializeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("initialize"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void InitializeNativeDelegate (IntPtr inst, IntPtr data);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideInitialize")]
		protected virtual void OnInitialize (IntPtr data)
		{
			InternalInitialize (data);
		}

		private void InternalInitialize (IntPtr data)
		{
			InitializeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("initialize"));
				unmanaged = (InitializeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(InitializeNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, data);
		}

		static ChildrenChangedNativeDelegate ChildrenChanged_cb_delegate;
		static ChildrenChangedNativeDelegate ChildrenChangedVMCallback {
			get {
				if (ChildrenChanged_cb_delegate == null)
					ChildrenChanged_cb_delegate = new ChildrenChangedNativeDelegate (ChildrenChanged_cb);
				return ChildrenChanged_cb_delegate;
			}
		}

		static void OverrideChildrenChanged (GLib.GType gtype)
		{
			OverrideChildrenChanged (gtype, ChildrenChangedVMCallback);
		}

		static void OverrideChildrenChanged (GLib.GType gtype, ChildrenChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("children_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChildrenChangedNativeDelegate (IntPtr inst, uint change_index, IntPtr changed_child);

		static void ChildrenChanged_cb (IntPtr inst, uint change_index, IntPtr changed_child)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnChildrenChanged (change_index, changed_child);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideChildrenChanged")]
		protected virtual void OnChildrenChanged (uint change_index, IntPtr changed_child)
		{
			InternalChildrenChanged (change_index, changed_child);
		}

		private void InternalChildrenChanged (uint change_index, IntPtr changed_child)
		{
			ChildrenChangedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("children_changed"));
				unmanaged = (ChildrenChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChildrenChangedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, change_index, changed_child);
		}

		static FocusEventNativeDelegate FocusEvent_cb_delegate;
		static FocusEventNativeDelegate FocusEventVMCallback {
			get {
				if (FocusEvent_cb_delegate == null)
					FocusEvent_cb_delegate = new FocusEventNativeDelegate (FocusEvent_cb);
				return FocusEvent_cb_delegate;
			}
		}

		static void OverrideFocusEvent (GLib.GType gtype)
		{
			OverrideFocusEvent (gtype, FocusEventVMCallback);
		}

		static void OverrideFocusEvent (GLib.GType gtype, FocusEventNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("focus_event"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void FocusEventNativeDelegate (IntPtr inst, bool focus_in);

		static void FocusEvent_cb (IntPtr inst, bool focus_in)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnFocusEvent (focus_in);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideFocusEvent")]
		protected virtual void OnFocusEvent (bool focus_in)
		{
			InternalFocusEvent (focus_in);
		}

		private void InternalFocusEvent (bool focus_in)
		{
			FocusEventNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("focus_event"));
				unmanaged = (FocusEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FocusEventNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, focus_in);
		}

		static PropertyChangeNativeDelegate PropertyChange_cb_delegate;
		static PropertyChangeNativeDelegate PropertyChangeVMCallback {
			get {
				if (PropertyChange_cb_delegate == null)
					PropertyChange_cb_delegate = new PropertyChangeNativeDelegate (PropertyChange_cb);
				return PropertyChange_cb_delegate;
			}
		}

		static void OverridePropertyChange (GLib.GType gtype)
		{
			OverridePropertyChange (gtype, PropertyChangeVMCallback);
		}

		static void OverridePropertyChange (GLib.GType gtype, PropertyChangeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("property_change"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PropertyChangeNativeDelegate (IntPtr inst, IntPtr values);

		static void PropertyChange_cb (IntPtr inst, IntPtr values)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnPropertyChange (Atk.PropertyValues.New (values));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverridePropertyChange")]
		protected virtual void OnPropertyChange (Atk.PropertyValues values)
		{
			InternalPropertyChange (values);
		}

		private void InternalPropertyChange (Atk.PropertyValues values)
		{
			PropertyChangeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("property_change"));
				unmanaged = (PropertyChangeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PropertyChangeNativeDelegate));
			}
			if (unmanaged == null) return;

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

		static StateChangeNativeDelegate StateChange_cb_delegate;
		static StateChangeNativeDelegate StateChangeVMCallback {
			get {
				if (StateChange_cb_delegate == null)
					StateChange_cb_delegate = new StateChangeNativeDelegate (StateChange_cb);
				return StateChange_cb_delegate;
			}
		}

		static void OverrideStateChange (GLib.GType gtype)
		{
			OverrideStateChange (gtype, StateChangeVMCallback);
		}

		static void OverrideStateChange (GLib.GType gtype, StateChangeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("state_change"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void StateChangeNativeDelegate (IntPtr inst, IntPtr name, bool state_set);

		static void StateChange_cb (IntPtr inst, IntPtr name, bool state_set)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				__obj.OnStateChange (GLib.Marshaller.Utf8PtrToString (name), state_set);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideStateChange")]
		protected virtual void OnStateChange (string name, bool state_set)
		{
			InternalStateChange (name, state_set);
		}

		private void InternalStateChange (string name, bool state_set)
		{
			StateChangeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("state_change"));
				unmanaged = (StateChangeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StateChangeNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			unmanaged (this.Handle, native_name, state_set);
			GLib.Marshaller.Free (native_name);
		}

		static VisibleDataChangedNativeDelegate VisibleDataChanged_cb_delegate;
		static VisibleDataChangedNativeDelegate VisibleDataChangedVMCallback {
			get {
				if (VisibleDataChanged_cb_delegate == null)
					VisibleDataChanged_cb_delegate = new VisibleDataChangedNativeDelegate (VisibleDataChanged_cb);
				return VisibleDataChanged_cb_delegate;
			}
		}

		static void OverrideVisibleDataChanged (GLib.GType gtype)
		{
			OverrideVisibleDataChanged (gtype, VisibleDataChangedVMCallback);
		}

		static void OverrideVisibleDataChanged (GLib.GType gtype, VisibleDataChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("visible_data_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideVisibleDataChanged")]
		protected virtual void OnVisibleDataChanged ()
		{
			InternalVisibleDataChanged ();
		}

		private void InternalVisibleDataChanged ()
		{
			VisibleDataChangedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("visible_data_changed"));
				unmanaged = (VisibleDataChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(VisibleDataChangedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ActiveDescendantChangedNativeDelegate ActiveDescendantChanged_cb_delegate;
		static ActiveDescendantChangedNativeDelegate ActiveDescendantChangedVMCallback {
			get {
				if (ActiveDescendantChanged_cb_delegate == null)
					ActiveDescendantChanged_cb_delegate = new ActiveDescendantChangedNativeDelegate (ActiveDescendantChanged_cb);
				return ActiveDescendantChanged_cb_delegate;
			}
		}

		static void OverrideActiveDescendantChanged (GLib.GType gtype)
		{
			OverrideActiveDescendantChanged (gtype, ActiveDescendantChangedVMCallback);
		}

		static void OverrideActiveDescendantChanged (GLib.GType gtype, ActiveDescendantChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("active_descendant_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ActiveDescendantChangedNativeDelegate (IntPtr inst, IntPtr child);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideActiveDescendantChanged")]
		protected virtual void OnActiveDescendantChanged (IntPtr child)
		{
			InternalActiveDescendantChanged (child);
		}

		private void InternalActiveDescendantChanged (IntPtr child)
		{
			ActiveDescendantChangedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("active_descendant_changed"));
				unmanaged = (ActiveDescendantChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ActiveDescendantChangedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, child);
		}

		static GetAttributesNativeDelegate GetAttributes_cb_delegate;
		static GetAttributesNativeDelegate GetAttributesVMCallback {
			get {
				if (GetAttributes_cb_delegate == null)
					GetAttributes_cb_delegate = new GetAttributesNativeDelegate (GetAttributes_cb);
				return GetAttributes_cb_delegate;
			}
		}

		static void OverrideGetAttributes (GLib.GType gtype)
		{
			OverrideGetAttributes (gtype, GetAttributesVMCallback);
		}

		static void OverrideGetAttributes (GLib.GType gtype, GetAttributesNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_attributes"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetAttributes")]
		protected virtual GLib.SList OnGetAttributes ()
		{
			return InternalGetAttributes ();
		}

		private GLib.SList InternalGetAttributes ()
		{
			GetAttributesNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_attributes"));
				unmanaged = (GetAttributesNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetAttributesNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return new GLib.SList(__result);
		}

		static GetObjectLocaleNativeDelegate GetObjectLocale_cb_delegate;
		static GetObjectLocaleNativeDelegate GetObjectLocaleVMCallback {
			get {
				if (GetObjectLocale_cb_delegate == null)
					GetObjectLocale_cb_delegate = new GetObjectLocaleNativeDelegate (GetObjectLocale_cb);
				return GetObjectLocale_cb_delegate;
			}
		}

		static void OverrideGetObjectLocale (GLib.GType gtype)
		{
			OverrideGetObjectLocale (gtype, GetObjectLocaleVMCallback);
		}

		static void OverrideGetObjectLocale (GLib.GType gtype, GetObjectLocaleNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_object_locale"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetObjectLocale_cb (IntPtr inst)
		{
			try {
				Object __obj = GLib.Object.GetObject (inst, false) as Object;
				string __result;
				__result = __obj.OnGetObjectLocale ();
				return GLib.Marshaller.StringToPtrGStrdup(__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.Object), ConnectionMethod="OverrideGetObjectLocale")]
		protected virtual string OnGetObjectLocale ()
		{
			return InternalGetObjectLocale ();
		}

		private string InternalGetObjectLocale ()
		{
			GetObjectLocaleNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_object_locale"));
				unmanaged = (GetObjectLocaleNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetObjectLocaleNativeDelegate));
			}
			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 new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("get_name"
							, GLib.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_name
							, null
							, "get_description"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_description"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_description
							, "get_name"
							, "get_parent"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_parent"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_parent
							, "get_description"
							, "get_n_children"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_n_children"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_n_children
							, "get_parent"
							, "ref_child"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("ref_child"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // ref_child
							, "get_n_children"
							, "get_index_in_parent"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_index_in_parent"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_index_in_parent
							, "ref_child"
							, "ref_relation_set"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("ref_relation_set"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // ref_relation_set
							, "get_index_in_parent"
							, "get_role"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_role"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_role
							, "ref_relation_set"
							, "get_layer"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_layer"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_layer
							, "get_role"
							, "get_mdi_zorder"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_mdi_zorder"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_mdi_zorder
							, "get_layer"
							, "ref_state_set"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("ref_state_set"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // ref_state_set
							, "get_mdi_zorder"
							, "set_name"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_name"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_name
							, "ref_state_set"
							, "set_description"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_description"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_description
							, "set_name"
							, "set_parent"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_parent"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_parent
							, "set_description"
							, "set_role"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_role"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_role
							, "set_parent"
							, "connect_property_change_handler"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("connect_property_change_handler"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // connect_property_change_handler
							, "set_role"
							, "remove_property_change_handler"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("remove_property_change_handler"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // remove_property_change_handler
							, "connect_property_change_handler"
							, "initialize"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("initialize"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // initialize
							, "remove_property_change_handler"
							, "children_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("children_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // children_changed
							, "initialize"
							, "focus_event"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("focus_event"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // focus_event
							, "children_changed"
							, "property_change"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("property_change"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // property_change
							, "focus_event"
							, "state_change"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("state_change"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // state_change
							, "property_change"
							, "visible_data_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("visible_data_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // visible_data_changed
							, "state_change"
							, "active_descendant_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("active_descendant_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // active_descendant_changed
							, "visible_data_changed"
							, "get_attributes"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_attributes"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_attributes
							, "active_descendant_changed"
							, "get_object_locale"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_object_locale"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_object_locale
							, "get_attributes"
							, "pad1"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pad1"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pad1
							, "get_object_locale"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool atk_object_add_relationship(IntPtr raw, int relationship, IntPtr target);

		public bool AddRelationship(Atk.RelationType relationship, Atk.Object target) {
			bool raw_ret = atk_object_add_relationship(Handle, (int) relationship, target == null ? IntPtr.Zero : target.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint atk_object_connect_property_change_handler(IntPtr raw, AtkSharp.PropertyChangeHandlerNative handler);

		[Obsolete]
		public uint ConnectPropertyChangeHandler(Atk.PropertyChangeHandler handler) {
			AtkSharp.PropertyChangeHandlerWrapper handler_wrapper = new AtkSharp.PropertyChangeHandlerWrapper (handler);
			uint raw_ret = atk_object_connect_property_change_handler(Handle, handler_wrapper.NativeDelegate);
			uint ret = raw_ret;
			return ret;
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_get_attributes(IntPtr raw);

		public Atk.Attribute[] Attributes { 
			get {
				IntPtr raw_ret = atk_object_get_attributes(Handle);
				Atk.Attribute[] ret = (Atk.Attribute[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.SList), false, false, typeof(Atk.Attribute));
				return ret;
			}
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int atk_object_get_index_in_parent(IntPtr raw);

		public int IndexInParent { 
			get {
				int raw_ret = atk_object_get_index_in_parent(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int atk_object_get_n_accessible_children(IntPtr raw);

		public int NAccessibleChildren { 
			get {
				int raw_ret = atk_object_get_n_accessible_children(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_get_object_locale(IntPtr raw);

		public string ObjectLocale { 
			get {
				IntPtr raw_ret = atk_object_get_object_locale(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_get_parent(IntPtr raw);

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void atk_object_set_parent(IntPtr raw, IntPtr parent);

		public Atk.Object Parent { 
			get {
				IntPtr raw_ret = atk_object_get_parent(Handle);
				Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
				return ret;
			}
			set {
				atk_object_set_parent(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_get_type();

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

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void atk_object_initialize(IntPtr raw, IntPtr data);

		public void Initialize(IntPtr data) {
			atk_object_initialize(Handle, data);
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void atk_object_notify_state_change(IntPtr raw, ulong state, bool value);

		public void NotifyStateChange(ulong state, bool value) {
			atk_object_notify_state_change(Handle, state, value);
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_peek_parent(IntPtr raw);

		public Atk.Object PeekParent() {
			IntPtr raw_ret = atk_object_peek_parent(Handle);
			Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
			return ret;
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_ref_accessible_child(IntPtr raw, int i);

		public Atk.Object RefAccessibleChild(int i) {
			IntPtr raw_ret = atk_object_ref_accessible_child(Handle, i);
			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
			return ret;
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_ref_relation_set(IntPtr raw);

		public Atk.RelationSet RefRelationSet() {
			IntPtr raw_ret = atk_object_ref_relation_set(Handle);
			Atk.RelationSet ret = GLib.Object.GetObject(raw_ret, true) as Atk.RelationSet;
			return ret;
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr atk_object_ref_state_set(IntPtr raw);

		public Atk.StateSet RefStateSet() {
			IntPtr raw_ret = atk_object_ref_state_set(Handle);
			Atk.StateSet ret = GLib.Object.GetObject(raw_ret, true) as Atk.StateSet;
			return ret;
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void atk_object_remove_property_change_handler(IntPtr raw, uint handler_id);

		[Obsolete]
		public void RemovePropertyChangeHandler(uint handler_id) {
			atk_object_remove_property_change_handler(Handle, handler_id);
		}

		[DllImport("atk-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool atk_object_remove_relationship(IntPtr raw, int relationship, IntPtr target);

		public bool RemoveRelationship(Atk.RelationType relationship, Atk.Object target) {
			bool raw_ret = atk_object_remove_relationship(Handle, (int) relationship, target == null ? IntPtr.Zero : target.Handle);
			bool ret = raw_ret;
			return ret;
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("description"
							, GLib.Object.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // description
							, null
							, "name"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("name"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // name
							, "description"
							, "accessible_parent"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("accessible_parent"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // accessible_parent
							, "name"
							, "role"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("role"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Atk.Role))) // role
							, "accessible_parent"
							, "relation_set"
							, (long) Marshal.OffsetOf(typeof(AtkObject_roleAlign), "role")
							, 0
							),
						new GLib.AbiField("relation_set"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // relation_set
							, "role"
							, "layer"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("layer"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Atk.Layer))) // layer
							, "relation_set"
							, null
							, (long) Marshal.OffsetOf(typeof(AtkObject_layerAlign), "layer")
							, 0
							),
					});

				return _abi_info;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct AtkObject_roleAlign
		{
			sbyte f1;
			private Atk.Role role;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct AtkObject_layerAlign
		{
			sbyte f1;
			private Atk.Layer layer;
		}


		// End of the ABI representation.

#endregion
	}
}