KioskApp/GtkSharp/Source/Libs/AtkSharp/Generated/Atk/NoOpObject.cs

// 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 NoOpObject : Atk.Object, Atk.IComponent, Atk.IAction, Atk.IEditableText, Atk.IImage, Atk.ISelection, Atk.ITable, Atk.ITableCell, Atk.IText, Atk.IHypertext, Atk.IValue, Atk.IDocument, Atk.IWindow {

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_atk_no_op_object_new(IntPtr obj);
		static d_atk_no_op_object_new atk_no_op_object_new = FuncLoader.LoadFunction<d_atk_no_op_object_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_no_op_object_new"));

		public NoOpObject (GLib.Object obj) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (NoOpObject)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = atk_no_op_object_new(obj == null ? IntPtr.Zero : obj.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 (Atk.Object.class_abi.Fields);

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_atk_no_op_object_get_type();
		static d_atk_no_op_object_get_type atk_no_op_object_get_type = FuncLoader.LoadFunction<d_atk_no_op_object_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_no_op_object_get_type"));

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = atk_no_op_object_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.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnBoundsChanged (Atk.Rectangle.New (bounds));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), 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 ();
		}

		[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;
		}

		[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);
			}
		}

		[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;
		}

		[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"));

		bool Atk.ISelection.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;
		}

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

		static SelectionChangedNativeDelegate SelectionChanged_cb_delegate;
		static SelectionChangedNativeDelegate SelectionChangedVMCallback {
			get {
				if (SelectionChanged_cb_delegate == null)
					SelectionChanged_cb_delegate = new SelectionChangedNativeDelegate (SelectionChanged_cb);
				return SelectionChanged_cb_delegate;
			}
		}

		static void OverrideSelectionChanged (GLib.GType gtype)
		{
			OverrideSelectionChanged (gtype, SelectionChangedVMCallback);
		}

		static void OverrideSelectionChanged (GLib.GType gtype, SelectionChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "selection_changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SelectionChangedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideSelectionChanged")]
		protected virtual void OnSelectionChanged ()
		{
			InternalSelectionChanged ();
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_atk_table_add_column_selection(IntPtr raw, int column);
		static d_atk_table_add_column_selection atk_table_add_column_selection = FuncLoader.LoadFunction<d_atk_table_add_column_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_add_column_selection"));

		public bool AddColumnSelection(int column) {
			bool raw_ret = atk_table_add_column_selection(Handle, column);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_atk_table_add_row_selection(IntPtr raw, int row);
		static d_atk_table_add_row_selection atk_table_add_row_selection = FuncLoader.LoadFunction<d_atk_table_add_row_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_add_row_selection"));

		public bool AddRowSelection(int row) {
			bool raw_ret = atk_table_add_row_selection(Handle, row);
			bool ret = raw_ret;
			return ret;
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_atk_table_set_caption(IntPtr raw, IntPtr caption);
		static d_atk_table_set_caption atk_table_set_caption = FuncLoader.LoadFunction<d_atk_table_set_caption>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_set_caption"));

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_atk_table_get_column_at_index(IntPtr raw, int index_);
		static d_atk_table_get_column_at_index atk_table_get_column_at_index = FuncLoader.LoadFunction<d_atk_table_get_column_at_index>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_column_at_index"));

		[Obsolete]
		public int GetColumnAtIndex(int index_) {
			int raw_ret = atk_table_get_column_at_index(Handle, index_);
			int ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_atk_table_get_column_description(IntPtr raw, int column);
		static d_atk_table_get_column_description atk_table_get_column_description = FuncLoader.LoadFunction<d_atk_table_get_column_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_column_description"));

		public string GetColumnDescription(int column) {
			IntPtr raw_ret = atk_table_get_column_description(Handle, column);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_atk_table_get_column_extent_at(IntPtr raw, int row, int column);
		static d_atk_table_get_column_extent_at atk_table_get_column_extent_at = FuncLoader.LoadFunction<d_atk_table_get_column_extent_at>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_column_extent_at"));

		public int GetColumnExtentAt(int row, int column) {
			int raw_ret = atk_table_get_column_extent_at(Handle, row, column);
			int ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_atk_table_get_column_header(IntPtr raw, int column);
		static d_atk_table_get_column_header atk_table_get_column_header = FuncLoader.LoadFunction<d_atk_table_get_column_header>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_column_header"));

		public Atk.Object GetColumnHeader(int column) {
			IntPtr raw_ret = atk_table_get_column_header(Handle, column);
			Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_atk_table_get_index_at(IntPtr raw, int row, int column);
		static d_atk_table_get_index_at atk_table_get_index_at = FuncLoader.LoadFunction<d_atk_table_get_index_at>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_index_at"));

		[Obsolete]
		public int GetIndexAt(int row, int column) {
			int raw_ret = atk_table_get_index_at(Handle, row, column);
			int ret = raw_ret;
			return ret;
		}

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

		public int NColumns { 
			get {
				int raw_ret = atk_table_get_n_columns(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

		public int NRows { 
			get {
				int raw_ret = atk_table_get_n_rows(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_atk_table_get_row_at_index(IntPtr raw, int index_);
		static d_atk_table_get_row_at_index atk_table_get_row_at_index = FuncLoader.LoadFunction<d_atk_table_get_row_at_index>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_row_at_index"));

		[Obsolete]
		public int GetRowAtIndex(int index_) {
			int raw_ret = atk_table_get_row_at_index(Handle, index_);
			int ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_atk_table_get_row_description(IntPtr raw, int row);
		static d_atk_table_get_row_description atk_table_get_row_description = FuncLoader.LoadFunction<d_atk_table_get_row_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_row_description"));

		public string GetRowDescription(int row) {
			IntPtr raw_ret = atk_table_get_row_description(Handle, row);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_atk_table_get_row_extent_at(IntPtr raw, int row, int column);
		static d_atk_table_get_row_extent_at atk_table_get_row_extent_at = FuncLoader.LoadFunction<d_atk_table_get_row_extent_at>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_row_extent_at"));

		public int GetRowExtentAt(int row, int column) {
			int raw_ret = atk_table_get_row_extent_at(Handle, row, column);
			int ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_atk_table_get_row_header(IntPtr raw, int row);
		static d_atk_table_get_row_header atk_table_get_row_header = FuncLoader.LoadFunction<d_atk_table_get_row_header>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_row_header"));

		public Atk.Object GetRowHeader(int row) {
			IntPtr raw_ret = atk_table_get_row_header(Handle, row);
			Atk.Object ret = GLib.Object.GetObject(raw_ret) as Atk.Object;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_atk_table_get_selected_columns(IntPtr raw, out int selected);
		static d_atk_table_get_selected_columns atk_table_get_selected_columns = FuncLoader.LoadFunction<d_atk_table_get_selected_columns>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_selected_columns"));

		public int GetSelectedColumns(out int selected) {
			int raw_ret = atk_table_get_selected_columns(Handle, out selected);
			int ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_atk_table_get_selected_rows(IntPtr raw, out int selected);
		static d_atk_table_get_selected_rows atk_table_get_selected_rows = FuncLoader.LoadFunction<d_atk_table_get_selected_rows>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_get_selected_rows"));

		public int GetSelectedRows(out int selected) {
			int raw_ret = atk_table_get_selected_rows(Handle, out selected);
			int ret = raw_ret;
			return ret;
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_atk_table_set_summary(IntPtr raw, IntPtr accessible);
		static d_atk_table_set_summary atk_table_set_summary = FuncLoader.LoadFunction<d_atk_table_set_summary>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_set_summary"));

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_atk_table_is_column_selected(IntPtr raw, int column);
		static d_atk_table_is_column_selected atk_table_is_column_selected = FuncLoader.LoadFunction<d_atk_table_is_column_selected>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_is_column_selected"));

		public bool IsColumnSelected(int column) {
			bool raw_ret = atk_table_is_column_selected(Handle, column);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_atk_table_is_row_selected(IntPtr raw, int row);
		static d_atk_table_is_row_selected atk_table_is_row_selected = FuncLoader.LoadFunction<d_atk_table_is_row_selected>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_is_row_selected"));

		public bool IsRowSelected(int row) {
			bool raw_ret = atk_table_is_row_selected(Handle, row);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_atk_table_is_selected(IntPtr raw, int row, int column);
		static d_atk_table_is_selected atk_table_is_selected = FuncLoader.LoadFunction<d_atk_table_is_selected>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_is_selected"));

		public bool IsSelected(int row, int column) {
			bool raw_ret = atk_table_is_selected(Handle, row, column);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_atk_table_ref_at(IntPtr raw, int row, int column);
		static d_atk_table_ref_at atk_table_ref_at = FuncLoader.LoadFunction<d_atk_table_ref_at>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_ref_at"));

		public Atk.Object RefAt(int row, int column) {
			IntPtr raw_ret = atk_table_ref_at(Handle, row, column);
			Atk.Object ret = GLib.Object.GetObject(raw_ret, true) as Atk.Object;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_atk_table_remove_column_selection(IntPtr raw, int column);
		static d_atk_table_remove_column_selection atk_table_remove_column_selection = FuncLoader.LoadFunction<d_atk_table_remove_column_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_remove_column_selection"));

		public bool RemoveColumnSelection(int column) {
			bool raw_ret = atk_table_remove_column_selection(Handle, column);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_atk_table_remove_row_selection(IntPtr raw, int row);
		static d_atk_table_remove_row_selection atk_table_remove_row_selection = FuncLoader.LoadFunction<d_atk_table_remove_row_selection>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_remove_row_selection"));

		public bool RemoveRowSelection(int row) {
			bool raw_ret = atk_table_remove_row_selection(Handle, row);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_atk_table_set_column_description(IntPtr raw, int column, IntPtr description);
		static d_atk_table_set_column_description atk_table_set_column_description = FuncLoader.LoadFunction<d_atk_table_set_column_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_set_column_description"));

		public void SetColumnDescription(int column, string description) {
			IntPtr native_description = GLib.Marshaller.StringToPtrGStrdup (description);
			atk_table_set_column_description(Handle, column, native_description);
			GLib.Marshaller.Free (native_description);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_atk_table_set_column_header(IntPtr raw, int column, IntPtr header);
		static d_atk_table_set_column_header atk_table_set_column_header = FuncLoader.LoadFunction<d_atk_table_set_column_header>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_set_column_header"));

		public void SetColumnHeader(int column, Atk.Object header) {
			atk_table_set_column_header(Handle, column, header == null ? IntPtr.Zero : header.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_atk_table_set_row_description(IntPtr raw, int row, IntPtr description);
		static d_atk_table_set_row_description atk_table_set_row_description = FuncLoader.LoadFunction<d_atk_table_set_row_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_set_row_description"));

		public void SetRowDescription(int row, string description) {
			IntPtr native_description = GLib.Marshaller.StringToPtrGStrdup (description);
			atk_table_set_row_description(Handle, row, native_description);
			GLib.Marshaller.Free (native_description);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_atk_table_set_row_header(IntPtr raw, int row, IntPtr header);
		static d_atk_table_set_row_header atk_table_set_row_header = FuncLoader.LoadFunction<d_atk_table_set_row_header>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_table_set_row_header"));

		public void SetRowHeader(int row, Atk.Object header) {
			atk_table_set_row_header(Handle, row, header == null ? IntPtr.Zero : header.Handle);
		}

		[GLib.Signal("column_inserted")]
		public event Atk.ColumnInsertedHandler ColumnInserted {
			add {
				this.AddSignalHandler ("column_inserted", value, typeof (Atk.ColumnInsertedArgs));
			}
			remove {
				this.RemoveSignalHandler ("column_inserted", value);
			}
		}

		[GLib.Signal("row_deleted")]
		public event Atk.RowDeletedHandler RowDeleted {
			add {
				this.AddSignalHandler ("row_deleted", value, typeof (Atk.RowDeletedArgs));
			}
			remove {
				this.RemoveSignalHandler ("row_deleted", value);
			}
		}

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

		[GLib.Signal("column_deleted")]
		public event Atk.ColumnDeletedHandler ColumnDeleted {
			add {
				this.AddSignalHandler ("column_deleted", value, typeof (Atk.ColumnDeletedArgs));
			}
			remove {
				this.RemoveSignalHandler ("column_deleted", value);
			}
		}

		[GLib.Signal("row_inserted")]
		public event Atk.RowInsertedHandler RowInserted {
			add {
				this.AddSignalHandler ("row_inserted", value, typeof (Atk.RowInsertedArgs));
			}
			remove {
				this.RemoveSignalHandler ("row_inserted", value);
			}
		}

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

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

		static RowInsertedNativeDelegate RowInserted_cb_delegate;
		static RowInsertedNativeDelegate RowInsertedVMCallback {
			get {
				if (RowInserted_cb_delegate == null)
					RowInserted_cb_delegate = new RowInsertedNativeDelegate (RowInserted_cb);
				return RowInserted_cb_delegate;
			}
		}

		static void OverrideRowInserted (GLib.GType gtype)
		{
			OverrideRowInserted (gtype, RowInsertedVMCallback);
		}

		static void OverrideRowInserted (GLib.GType gtype, RowInsertedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "row_inserted", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RowInsertedNativeDelegate (IntPtr inst, int row, int num_inserted);

		static void RowInserted_cb (IntPtr inst, int row, int num_inserted)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnRowInserted (row, num_inserted);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideRowInserted")]
		protected virtual void OnRowInserted (int row, int num_inserted)
		{
			InternalRowInserted (row, num_inserted);
		}

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

		static ColumnInsertedNativeDelegate ColumnInserted_cb_delegate;
		static ColumnInsertedNativeDelegate ColumnInsertedVMCallback {
			get {
				if (ColumnInserted_cb_delegate == null)
					ColumnInserted_cb_delegate = new ColumnInsertedNativeDelegate (ColumnInserted_cb);
				return ColumnInserted_cb_delegate;
			}
		}

		static void OverrideColumnInserted (GLib.GType gtype)
		{
			OverrideColumnInserted (gtype, ColumnInsertedVMCallback);
		}

		static void OverrideColumnInserted (GLib.GType gtype, ColumnInsertedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "column_inserted", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ColumnInsertedNativeDelegate (IntPtr inst, int column, int num_inserted);

		static void ColumnInserted_cb (IntPtr inst, int column, int num_inserted)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnColumnInserted (column, num_inserted);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideColumnInserted")]
		protected virtual void OnColumnInserted (int column, int num_inserted)
		{
			InternalColumnInserted (column, num_inserted);
		}

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

		static RowDeletedNativeDelegate RowDeleted_cb_delegate;
		static RowDeletedNativeDelegate RowDeletedVMCallback {
			get {
				if (RowDeleted_cb_delegate == null)
					RowDeleted_cb_delegate = new RowDeletedNativeDelegate (RowDeleted_cb);
				return RowDeleted_cb_delegate;
			}
		}

		static void OverrideRowDeleted (GLib.GType gtype)
		{
			OverrideRowDeleted (gtype, RowDeletedVMCallback);
		}

		static void OverrideRowDeleted (GLib.GType gtype, RowDeletedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "row_deleted", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RowDeletedNativeDelegate (IntPtr inst, int row, int num_deleted);

		static void RowDeleted_cb (IntPtr inst, int row, int num_deleted)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnRowDeleted (row, num_deleted);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideRowDeleted")]
		protected virtual void OnRowDeleted (int row, int num_deleted)
		{
			InternalRowDeleted (row, num_deleted);
		}

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

		static ColumnDeletedNativeDelegate ColumnDeleted_cb_delegate;
		static ColumnDeletedNativeDelegate ColumnDeletedVMCallback {
			get {
				if (ColumnDeleted_cb_delegate == null)
					ColumnDeleted_cb_delegate = new ColumnDeletedNativeDelegate (ColumnDeleted_cb);
				return ColumnDeleted_cb_delegate;
			}
		}

		static void OverrideColumnDeleted (GLib.GType gtype)
		{
			OverrideColumnDeleted (gtype, ColumnDeletedVMCallback);
		}

		static void OverrideColumnDeleted (GLib.GType gtype, ColumnDeletedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "column_deleted", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ColumnDeletedNativeDelegate (IntPtr inst, int column, int num_deleted);

		static void ColumnDeleted_cb (IntPtr inst, int column, int num_deleted)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnColumnDeleted (column, num_deleted);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideColumnDeleted")]
		protected virtual void OnColumnDeleted (int column, int num_deleted)
		{
			InternalColumnDeleted (column, num_deleted);
		}

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

		static RowReorderedNativeDelegate RowReordered_cb_delegate;
		static RowReorderedNativeDelegate RowReorderedVMCallback {
			get {
				if (RowReordered_cb_delegate == null)
					RowReordered_cb_delegate = new RowReorderedNativeDelegate (RowReordered_cb);
				return RowReordered_cb_delegate;
			}
		}

		static void OverrideRowReordered (GLib.GType gtype)
		{
			OverrideRowReordered (gtype, RowReorderedVMCallback);
		}

		static void OverrideRowReordered (GLib.GType gtype, RowReorderedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "row_reordered", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RowReorderedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideRowReordered")]
		protected virtual void OnRowReordered ()
		{
			InternalRowReordered ();
		}

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

		static ColumnReorderedNativeDelegate ColumnReordered_cb_delegate;
		static ColumnReorderedNativeDelegate ColumnReorderedVMCallback {
			get {
				if (ColumnReordered_cb_delegate == null)
					ColumnReordered_cb_delegate = new ColumnReorderedNativeDelegate (ColumnReordered_cb);
				return ColumnReordered_cb_delegate;
			}
		}

		static void OverrideColumnReordered (GLib.GType gtype)
		{
			OverrideColumnReordered (gtype, ColumnReorderedVMCallback);
		}

		static void OverrideColumnReordered (GLib.GType gtype, ColumnReorderedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "column_reordered", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ColumnReorderedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideColumnReordered")]
		protected virtual void OnColumnReordered ()
		{
			InternalColumnReordered ();
		}

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

		static ModelChangedNativeDelegate ModelChanged_cb_delegate;
		static ModelChangedNativeDelegate ModelChangedVMCallback {
			get {
				if (ModelChanged_cb_delegate == null)
					ModelChanged_cb_delegate = new ModelChangedNativeDelegate (ModelChanged_cb);
				return ModelChanged_cb_delegate;
			}
		}

		static void OverrideModelChanged (GLib.GType gtype)
		{
			OverrideModelChanged (gtype, ModelChangedVMCallback);
		}

		static void OverrideModelChanged (GLib.GType gtype, ModelChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "model_changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ModelChangedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideModelChanged")]
		protected virtual void OnModelChanged ()
		{
			InternalModelChanged ();
		}

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

		[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;
			}
		}

		[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 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"));

		bool Atk.IText.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;
		}

		[GLib.Signal("text_insert")]
		public event Atk.TextInsertHandler TextInsert {
			add {
				this.AddSignalHandler ("text_insert", value, typeof (Atk.TextInsertArgs));
			}
			remove {
				this.RemoveSignalHandler ("text_insert", value);
			}
		}

		[GLib.Signal("text_remove")]
		public event Atk.TextRemoveHandler TextRemove {
			add {
				this.AddSignalHandler ("text_remove", value, typeof (Atk.TextRemoveArgs));
			}
			remove {
				this.RemoveSignalHandler ("text_remove", value);
			}
		}

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

		[GLib.Signal("text_caret_moved")]
		public event Atk.TextCaretMovedHandler TextCaretMoved {
			add {
				this.AddSignalHandler ("text_caret_moved", value, typeof (Atk.TextCaretMovedArgs));
			}
			remove {
				this.RemoveSignalHandler ("text_caret_moved", value);
			}
		}

		[GLib.Signal("text_changed")]
		public event Atk.TextChangedHandler TextChanged {
			add {
				this.AddSignalHandler ("text_changed", value, typeof (Atk.TextChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("text_changed", value);
			}
		}

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

		static TextInsertNativeDelegate TextInsert_cb_delegate;
		static TextInsertNativeDelegate TextInsertVMCallback {
			get {
				if (TextInsert_cb_delegate == null)
					TextInsert_cb_delegate = new TextInsertNativeDelegate (TextInsert_cb);
				return TextInsert_cb_delegate;
			}
		}

		static void OverrideTextInsert (GLib.GType gtype)
		{
			OverrideTextInsert (gtype, TextInsertVMCallback);
		}

		static void OverrideTextInsert (GLib.GType gtype, TextInsertNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "text_insert", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextInsertNativeDelegate (IntPtr inst, int p0, int p1, IntPtr p2);

		static void TextInsert_cb (IntPtr inst, int p0, int p1, IntPtr p2)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnTextInsert (p0, p1, GLib.Marshaller.PtrToStringGFree(p2));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideTextInsert")]
		protected virtual void OnTextInsert (int p0, int p1, string p2)
		{
			InternalTextInsert (p0, p1, p2);
		}

		private void InternalTextInsert (int p0, int p1, string p2)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (4);
			GLib.Value[] vals = new GLib.Value [4];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (p0);
			inst_and_params.Append (vals [1]);
			vals [2] = new GLib.Value (p1);
			inst_and_params.Append (vals [2]);
			vals [3] = new GLib.Value (p2);
			inst_and_params.Append (vals [3]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static TextRemoveNativeDelegate TextRemove_cb_delegate;
		static TextRemoveNativeDelegate TextRemoveVMCallback {
			get {
				if (TextRemove_cb_delegate == null)
					TextRemove_cb_delegate = new TextRemoveNativeDelegate (TextRemove_cb);
				return TextRemove_cb_delegate;
			}
		}

		static void OverrideTextRemove (GLib.GType gtype)
		{
			OverrideTextRemove (gtype, TextRemoveVMCallback);
		}

		static void OverrideTextRemove (GLib.GType gtype, TextRemoveNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "text_remove", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextRemoveNativeDelegate (IntPtr inst, int p0, int p1, IntPtr p2);

		static void TextRemove_cb (IntPtr inst, int p0, int p1, IntPtr p2)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnTextRemove (p0, p1, GLib.Marshaller.PtrToStringGFree(p2));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideTextRemove")]
		protected virtual void OnTextRemove (int p0, int p1, string p2)
		{
			InternalTextRemove (p0, p1, p2);
		}

		private void InternalTextRemove (int p0, int p1, string p2)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (4);
			GLib.Value[] vals = new GLib.Value [4];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (p0);
			inst_and_params.Append (vals [1]);
			vals [2] = new GLib.Value (p1);
			inst_and_params.Append (vals [2]);
			vals [3] = new GLib.Value (p2);
			inst_and_params.Append (vals [3]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static TextChangedNativeDelegate TextChanged_cb_delegate;
		static TextChangedNativeDelegate TextChangedVMCallback {
			get {
				if (TextChanged_cb_delegate == null)
					TextChanged_cb_delegate = new TextChangedNativeDelegate (TextChanged_cb);
				return TextChanged_cb_delegate;
			}
		}

		static void OverrideTextChanged (GLib.GType gtype)
		{
			OverrideTextChanged (gtype, TextChangedVMCallback);
		}

		static void OverrideTextChanged (GLib.GType gtype, TextChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "text_changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextChangedNativeDelegate (IntPtr inst, int position, int length);

		static void TextChanged_cb (IntPtr inst, int position, int length)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnTextChanged (position, length);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideTextChanged")]
		protected virtual void OnTextChanged (int position, int length)
		{
			InternalTextChanged (position, length);
		}

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

		static TextCaretMovedNativeDelegate TextCaretMoved_cb_delegate;
		static TextCaretMovedNativeDelegate TextCaretMovedVMCallback {
			get {
				if (TextCaretMoved_cb_delegate == null)
					TextCaretMoved_cb_delegate = new TextCaretMovedNativeDelegate (TextCaretMoved_cb);
				return TextCaretMoved_cb_delegate;
			}
		}

		static void OverrideTextCaretMoved (GLib.GType gtype)
		{
			OverrideTextCaretMoved (gtype, TextCaretMovedVMCallback);
		}

		static void OverrideTextCaretMoved (GLib.GType gtype, TextCaretMovedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "text_caret_moved", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextCaretMovedNativeDelegate (IntPtr inst, int location);

		static void TextCaretMoved_cb (IntPtr inst, int location)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnTextCaretMoved (location);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideTextCaretMoved")]
		protected virtual void OnTextCaretMoved (int location)
		{
			InternalTextCaretMoved (location);
		}

		private void InternalTextCaretMoved (int location)
		{
			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 (location);
			inst_and_params.Append (vals [1]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static TextSelectionChangedNativeDelegate TextSelectionChanged_cb_delegate;
		static TextSelectionChangedNativeDelegate TextSelectionChangedVMCallback {
			get {
				if (TextSelectionChanged_cb_delegate == null)
					TextSelectionChanged_cb_delegate = new TextSelectionChangedNativeDelegate (TextSelectionChanged_cb);
				return TextSelectionChanged_cb_delegate;
			}
		}

		static void OverrideTextSelectionChanged (GLib.GType gtype)
		{
			OverrideTextSelectionChanged (gtype, TextSelectionChangedVMCallback);
		}

		static void OverrideTextSelectionChanged (GLib.GType gtype, TextSelectionChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "text_selection_changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextSelectionChangedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideTextSelectionChanged")]
		protected virtual void OnTextSelectionChanged ()
		{
			InternalTextSelectionChanged ();
		}

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

		static TextAttributesChangedNativeDelegate TextAttributesChanged_cb_delegate;
		static TextAttributesChangedNativeDelegate TextAttributesChangedVMCallback {
			get {
				if (TextAttributesChanged_cb_delegate == null)
					TextAttributesChanged_cb_delegate = new TextAttributesChangedNativeDelegate (TextAttributesChanged_cb);
				return TextAttributesChanged_cb_delegate;
			}
		}

		static void OverrideTextAttributesChanged (GLib.GType gtype)
		{
			OverrideTextAttributesChanged (gtype, TextAttributesChangedVMCallback);
		}

		static void OverrideTextAttributesChanged (GLib.GType gtype, TextAttributesChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "text_attributes_changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextAttributesChangedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideTextAttributesChanged")]
		protected virtual void OnTextAttributesChanged ()
		{
			InternalTextAttributesChanged ();
		}

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

		[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;
			}
		}

		[GLib.Signal("link_selected")]
		public event Atk.LinkSelectedHandler LinkSelected {
			add {
				this.AddSignalHandler ("link_selected", value, typeof (Atk.LinkSelectedArgs));
			}
			remove {
				this.RemoveSignalHandler ("link_selected", value);
			}
		}

		static LinkSelectedNativeDelegate LinkSelected_cb_delegate;
		static LinkSelectedNativeDelegate LinkSelectedVMCallback {
			get {
				if (LinkSelected_cb_delegate == null)
					LinkSelected_cb_delegate = new LinkSelectedNativeDelegate (LinkSelected_cb);
				return LinkSelected_cb_delegate;
			}
		}

		static void OverrideLinkSelected (GLib.GType gtype)
		{
			OverrideLinkSelected (gtype, LinkSelectedVMCallback);
		}

		static void OverrideLinkSelected (GLib.GType gtype, LinkSelectedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "link_selected", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void LinkSelectedNativeDelegate (IntPtr inst, int link_index);

		static void LinkSelected_cb (IntPtr inst, int link_index)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnLinkSelected (link_index);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideLinkSelected")]
		protected virtual void OnLinkSelected (int link_index)
		{
			InternalLinkSelected (link_index);
		}

		private void InternalLinkSelected (int link_index)
		{
			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 (link_index);
			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 ();
		}

		[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);
			}
		}

		[GLib.Signal("value_changed")]
		public event Atk.ValueChangedHandler ValueChanged {
			add {
				this.AddSignalHandler ("value_changed", value, typeof (Atk.ValueChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("value_changed", value);
			}
		}

		static ValueChangedNativeDelegate ValueChanged_cb_delegate;
		static ValueChangedNativeDelegate ValueChangedVMCallback {
			get {
				if (ValueChanged_cb_delegate == null)
					ValueChanged_cb_delegate = new ValueChangedNativeDelegate (ValueChanged_cb);
				return ValueChanged_cb_delegate;
			}
		}

		static void OverrideValueChanged (GLib.GType gtype)
		{
			OverrideValueChanged (gtype, ValueChangedVMCallback);
		}

		static void OverrideValueChanged (GLib.GType gtype, ValueChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "value_changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ValueChangedNativeDelegate (IntPtr inst, double p0, IntPtr p1);

		static void ValueChanged_cb (IntPtr inst, double p0, IntPtr p1)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnValueChanged (p0, GLib.Marshaller.PtrToStringGFree(p1));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideValueChanged")]
		protected virtual void OnValueChanged (double p0, string p1)
		{
			InternalValueChanged (p0, p1);
		}

		private void InternalValueChanged (double p0, string p1)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
			GLib.Value[] vals = new GLib.Value [3];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (p0);
			inst_and_params.Append (vals [1]);
			vals [2] = new GLib.Value (p1);
			inst_and_params.Append (vals [2]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		[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 new 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;
		}

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

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

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

		[GLib.Signal("page_changed")]
		public event Atk.PageChangedHandler PageChanged {
			add {
				this.AddSignalHandler ("page_changed", value, typeof (Atk.PageChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("page_changed", value);
			}
		}

		static LoadCompleteNativeDelegate LoadComplete_cb_delegate;
		static LoadCompleteNativeDelegate LoadCompleteVMCallback {
			get {
				if (LoadComplete_cb_delegate == null)
					LoadComplete_cb_delegate = new LoadCompleteNativeDelegate (LoadComplete_cb);
				return LoadComplete_cb_delegate;
			}
		}

		static void OverrideLoadComplete (GLib.GType gtype)
		{
			OverrideLoadComplete (gtype, LoadCompleteVMCallback);
		}

		static void OverrideLoadComplete (GLib.GType gtype, LoadCompleteNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "load_complete", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void LoadCompleteNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideLoadComplete")]
		protected virtual void OnLoadComplete ()
		{
			InternalLoadComplete ();
		}

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

		static ReloadNativeDelegate Reload_cb_delegate;
		static ReloadNativeDelegate ReloadVMCallback {
			get {
				if (Reload_cb_delegate == null)
					Reload_cb_delegate = new ReloadNativeDelegate (Reload_cb);
				return Reload_cb_delegate;
			}
		}

		static void OverrideReload (GLib.GType gtype)
		{
			OverrideReload (gtype, ReloadVMCallback);
		}

		static void OverrideReload (GLib.GType gtype, ReloadNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "reload", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ReloadNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideReload")]
		protected virtual void OnReload ()
		{
			InternalReload ();
		}

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

		static LoadStoppedNativeDelegate LoadStopped_cb_delegate;
		static LoadStoppedNativeDelegate LoadStoppedVMCallback {
			get {
				if (LoadStopped_cb_delegate == null)
					LoadStopped_cb_delegate = new LoadStoppedNativeDelegate (LoadStopped_cb);
				return LoadStopped_cb_delegate;
			}
		}

		static void OverrideLoadStopped (GLib.GType gtype)
		{
			OverrideLoadStopped (gtype, LoadStoppedVMCallback);
		}

		static void OverrideLoadStopped (GLib.GType gtype, LoadStoppedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "load_stopped", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void LoadStoppedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverrideLoadStopped")]
		protected virtual void OnLoadStopped ()
		{
			InternalLoadStopped ();
		}

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

		static PageChangedNativeDelegate PageChanged_cb_delegate;
		static PageChangedNativeDelegate PageChangedVMCallback {
			get {
				if (PageChanged_cb_delegate == null)
					PageChanged_cb_delegate = new PageChangedNativeDelegate (PageChanged_cb);
				return PageChanged_cb_delegate;
			}
		}

		static void OverridePageChanged (GLib.GType gtype)
		{
			OverridePageChanged (gtype, PageChangedVMCallback);
		}

		static void OverridePageChanged (GLib.GType gtype, PageChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "page_changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PageChangedNativeDelegate (IntPtr inst, int p0);

		static void PageChanged_cb (IntPtr inst, int p0)
		{
			try {
				Atk.NoOpObject __obj = GLib.Object.GetObject (inst, false) as Atk.NoOpObject;
				__obj.OnPageChanged (p0);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Atk.NoOpObject), ConnectionMethod="OverridePageChanged")]
		protected virtual void OnPageChanged (int p0)
		{
			InternalPageChanged (p0);
		}

		private void InternalPageChanged (int p0)
		{
			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 (p0);
			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
	}
}