// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

namespace Gtk {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;
	using static GLib.AbiStructExtension;

#region Autogenerated code
	public partial class IMContext : GLib.Object {

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

		protected IMContext() : base(IntPtr.Zero)
		{
			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
		}

		[GLib.Property ("input-purpose")]
		public Gtk.InputPurpose InputPurpose {
			get {
				GLib.Value val = GetProperty ("input-purpose");
				Gtk.InputPurpose ret = (Gtk.InputPurpose) (Enum) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value((Enum) value);
				SetProperty("input-purpose", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("input-hints")]
		public Gtk.InputHints InputHints {
			get {
				GLib.Value val = GetProperty ("input-hints");
				Gtk.InputHints ret = (Gtk.InputHints) (Enum) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value((Enum) value);
				SetProperty("input-hints", val);
				val.Dispose ();
			}
		}

		[GLib.Signal("commit")]
		public event Gtk.CommitHandler Commit {
			add {
				this.AddSignalHandler ("commit", value, typeof (Gtk.CommitArgs));
			}
			remove {
				this.RemoveSignalHandler ("commit", value);
			}
		}

		[GLib.Signal("preedit-start")]
		public event System.EventHandler PreeditStart {
			add {
				this.AddSignalHandler ("preedit-start", value);
			}
			remove {
				this.RemoveSignalHandler ("preedit-start", value);
			}
		}

		[GLib.Signal("delete-surrounding")]
		public event Gtk.SurroundingDeletedHandler SurroundingDeleted {
			add {
				this.AddSignalHandler ("delete-surrounding", value, typeof (Gtk.SurroundingDeletedArgs));
			}
			remove {
				this.RemoveSignalHandler ("delete-surrounding", value);
			}
		}

		[GLib.Signal("retrieve-surrounding")]
		public event Gtk.RetrieveSurroundingHandler RetrieveSurrounding {
			add {
				this.AddSignalHandler ("retrieve-surrounding", value, typeof (Gtk.RetrieveSurroundingArgs));
			}
			remove {
				this.RemoveSignalHandler ("retrieve-surrounding", value);
			}
		}

		[GLib.Signal("preedit-end")]
		public event System.EventHandler PreeditEnd {
			add {
				this.AddSignalHandler ("preedit-end", value);
			}
			remove {
				this.RemoveSignalHandler ("preedit-end", value);
			}
		}

		[GLib.Signal("preedit-changed")]
		public event System.EventHandler PreeditChanged {
			add {
				this.AddSignalHandler ("preedit-changed", value);
			}
			remove {
				this.RemoveSignalHandler ("preedit-changed", value);
			}
		}

		static PreeditStartNativeDelegate PreeditStart_cb_delegate;
		static PreeditStartNativeDelegate PreeditStartVMCallback {
			get {
				if (PreeditStart_cb_delegate == null)
					PreeditStart_cb_delegate = new PreeditStartNativeDelegate (PreeditStart_cb);
				return PreeditStart_cb_delegate;
			}
		}

		static void OverridePreeditStart (GLib.GType gtype)
		{
			OverridePreeditStart (gtype, PreeditStartVMCallback);
		}

		static void OverridePreeditStart (GLib.GType gtype, PreeditStartNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("preedit_start"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverridePreeditStart")]
		protected virtual void OnPreeditStart ()
		{
			InternalPreeditStart ();
		}

		private void InternalPreeditStart ()
		{
			PreeditStartNativeDelegate unmanaged = class_abi.BaseOverride<PreeditStartNativeDelegate>(this.LookupGType(), "preedit_start");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static PreeditEndNativeDelegate PreeditEnd_cb_delegate;
		static PreeditEndNativeDelegate PreeditEndVMCallback {
			get {
				if (PreeditEnd_cb_delegate == null)
					PreeditEnd_cb_delegate = new PreeditEndNativeDelegate (PreeditEnd_cb);
				return PreeditEnd_cb_delegate;
			}
		}

		static void OverridePreeditEnd (GLib.GType gtype)
		{
			OverridePreeditEnd (gtype, PreeditEndVMCallback);
		}

		static void OverridePreeditEnd (GLib.GType gtype, PreeditEndNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("preedit_end"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverridePreeditEnd")]
		protected virtual void OnPreeditEnd ()
		{
			InternalPreeditEnd ();
		}

		private void InternalPreeditEnd ()
		{
			PreeditEndNativeDelegate unmanaged = class_abi.BaseOverride<PreeditEndNativeDelegate>(this.LookupGType(), "preedit_end");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static PreeditChangedNativeDelegate PreeditChanged_cb_delegate;
		static PreeditChangedNativeDelegate PreeditChangedVMCallback {
			get {
				if (PreeditChanged_cb_delegate == null)
					PreeditChanged_cb_delegate = new PreeditChangedNativeDelegate (PreeditChanged_cb);
				return PreeditChanged_cb_delegate;
			}
		}

		static void OverridePreeditChanged (GLib.GType gtype)
		{
			OverridePreeditChanged (gtype, PreeditChangedVMCallback);
		}

		static void OverridePreeditChanged (GLib.GType gtype, PreeditChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("preedit_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverridePreeditChanged")]
		protected virtual void OnPreeditChanged ()
		{
			InternalPreeditChanged ();
		}

		private void InternalPreeditChanged ()
		{
			PreeditChangedNativeDelegate unmanaged = class_abi.BaseOverride<PreeditChangedNativeDelegate>(this.LookupGType(), "preedit_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static CommitNativeDelegate Commit_cb_delegate;
		static CommitNativeDelegate CommitVMCallback {
			get {
				if (Commit_cb_delegate == null)
					Commit_cb_delegate = new CommitNativeDelegate (Commit_cb);
				return Commit_cb_delegate;
			}
		}

		static void OverrideCommit (GLib.GType gtype)
		{
			OverrideCommit (gtype, CommitVMCallback);
		}

		static void OverrideCommit (GLib.GType gtype, CommitNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("commit"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void CommitNativeDelegate (IntPtr inst, IntPtr str);

		static void Commit_cb (IntPtr inst, IntPtr str)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				__obj.OnCommit (GLib.Marshaller.Utf8PtrToString (str));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideCommit")]
		protected virtual void OnCommit (string str)
		{
			InternalCommit (str);
		}

		private void InternalCommit (string str)
		{
			CommitNativeDelegate unmanaged = class_abi.BaseOverride<CommitNativeDelegate>(this.LookupGType(), "commit");
			if (unmanaged == null) return;

			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
			unmanaged (this.Handle, native_str);
			GLib.Marshaller.Free (native_str);
		}

		static RetrieveSurroundingNativeDelegate RetrieveSurrounding_cb_delegate;
		static RetrieveSurroundingNativeDelegate RetrieveSurroundingVMCallback {
			get {
				if (RetrieveSurrounding_cb_delegate == null)
					RetrieveSurrounding_cb_delegate = new RetrieveSurroundingNativeDelegate (RetrieveSurrounding_cb);
				return RetrieveSurrounding_cb_delegate;
			}
		}

		static void OverrideRetrieveSurrounding (GLib.GType gtype)
		{
			OverrideRetrieveSurrounding (gtype, RetrieveSurroundingVMCallback);
		}

		static void OverrideRetrieveSurrounding (GLib.GType gtype, RetrieveSurroundingNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("retrieve_surrounding"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideRetrieveSurrounding")]
		protected virtual bool OnRetrieveSurrounding ()
		{
			return InternalRetrieveSurrounding ();
		}

		private bool InternalRetrieveSurrounding ()
		{
			RetrieveSurroundingNativeDelegate unmanaged = class_abi.BaseOverride<RetrieveSurroundingNativeDelegate>(this.LookupGType(), "retrieve_surrounding");
			if (unmanaged == null) return false;

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

		static SurroundingDeletedNativeDelegate SurroundingDeleted_cb_delegate;
		static SurroundingDeletedNativeDelegate SurroundingDeletedVMCallback {
			get {
				if (SurroundingDeleted_cb_delegate == null)
					SurroundingDeleted_cb_delegate = new SurroundingDeletedNativeDelegate (SurroundingDeleted_cb);
				return SurroundingDeleted_cb_delegate;
			}
		}

		static void OverrideSurroundingDeleted (GLib.GType gtype)
		{
			OverrideSurroundingDeleted (gtype, SurroundingDeletedVMCallback);
		}

		static void OverrideSurroundingDeleted (GLib.GType gtype, SurroundingDeletedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("delete_surrounding"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SurroundingDeletedNativeDelegate (IntPtr inst, int offset, int n_chars);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideSurroundingDeleted")]
		protected virtual bool OnSurroundingDeleted (int offset, int n_chars)
		{
			return InternalSurroundingDeleted (offset, n_chars);
		}

		private bool InternalSurroundingDeleted (int offset, int n_chars)
		{
			SurroundingDeletedNativeDelegate unmanaged = class_abi.BaseOverride<SurroundingDeletedNativeDelegate>(this.LookupGType(), "delete_surrounding");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, offset, n_chars);
			return __result;
		}

		static SetClientWindowNativeDelegate SetClientWindow_cb_delegate;
		static SetClientWindowNativeDelegate SetClientWindowVMCallback {
			get {
				if (SetClientWindow_cb_delegate == null)
					SetClientWindow_cb_delegate = new SetClientWindowNativeDelegate (SetClientWindow_cb);
				return SetClientWindow_cb_delegate;
			}
		}

		static void OverrideSetClientWindow (GLib.GType gtype)
		{
			OverrideSetClientWindow (gtype, SetClientWindowVMCallback);
		}

		static void OverrideSetClientWindow (GLib.GType gtype, SetClientWindowNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_client_window"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetClientWindowNativeDelegate (IntPtr inst, IntPtr window);

		static void SetClientWindow_cb (IntPtr inst, IntPtr window)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				__obj.OnSetClientWindow (GLib.Object.GetObject(window) as Gdk.Window);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideSetClientWindow")]
		protected virtual void OnSetClientWindow (Gdk.Window window)
		{
			InternalSetClientWindow (window);
		}

		private void InternalSetClientWindow (Gdk.Window window)
		{
			SetClientWindowNativeDelegate unmanaged = class_abi.BaseOverride<SetClientWindowNativeDelegate>(this.LookupGType(), "set_client_window");
			if (unmanaged == null) return;

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

		static GetPreeditStringNativeDelegate GetPreeditString_cb_delegate;
		static GetPreeditStringNativeDelegate GetPreeditStringVMCallback {
			get {
				if (GetPreeditString_cb_delegate == null)
					GetPreeditString_cb_delegate = new GetPreeditStringNativeDelegate (GetPreeditString_cb);
				return GetPreeditString_cb_delegate;
			}
		}

		static void OverrideGetPreeditString (GLib.GType gtype)
		{
			OverrideGetPreeditString (gtype, GetPreeditStringVMCallback);
		}

		static void OverrideGetPreeditString (GLib.GType gtype, GetPreeditStringNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_preedit_string"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetPreeditStringNativeDelegate (IntPtr inst, IntPtr str, IntPtr attrs, out int cursor_pos);

		static void GetPreeditString_cb (IntPtr inst, IntPtr str, IntPtr attrs, out int cursor_pos)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				__obj.OnGetPreeditString (GLib.Marshaller.PtrToStringGFree(str), attrs == IntPtr.Zero ? null : (Pango.AttrList) GLib.Opaque.GetOpaque (attrs, typeof (Pango.AttrList), false), out cursor_pos);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideGetPreeditString")]
		protected virtual void OnGetPreeditString (string str, Pango.AttrList attrs, out int cursor_pos)
		{
			InternalGetPreeditString (str, attrs, out cursor_pos);
		}

		private void InternalGetPreeditString (string str, Pango.AttrList attrs, out int cursor_pos)
		{
			GetPreeditStringNativeDelegate unmanaged = class_abi.BaseOverride<GetPreeditStringNativeDelegate>(this.LookupGType(), "get_preedit_string");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, GLib.Marshaller.StringToPtrGStrdup(str), attrs == null ? IntPtr.Zero : attrs.Handle, out cursor_pos);
		}

		static FilterKeypressNativeDelegate FilterKeypress_cb_delegate;
		static FilterKeypressNativeDelegate FilterKeypressVMCallback {
			get {
				if (FilterKeypress_cb_delegate == null)
					FilterKeypress_cb_delegate = new FilterKeypressNativeDelegate (FilterKeypress_cb);
				return FilterKeypress_cb_delegate;
			}
		}

		static void OverrideFilterKeypress (GLib.GType gtype)
		{
			OverrideFilterKeypress (gtype, FilterKeypressVMCallback);
		}

		static void OverrideFilterKeypress (GLib.GType gtype, FilterKeypressNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("filter_keypress"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool FilterKeypressNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool FilterKeypress_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				bool __result;
				__result = __obj.OnFilterKeypress (new Gdk.EventKey(evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideFilterKeypress")]
		protected virtual bool OnFilterKeypress (Gdk.EventKey evnt)
		{
			return InternalFilterKeypress (evnt);
		}

		private bool InternalFilterKeypress (Gdk.EventKey evnt)
		{
			FilterKeypressNativeDelegate unmanaged = class_abi.BaseOverride<FilterKeypressNativeDelegate>(this.LookupGType(), "filter_keypress");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			return __result;
		}

		static FocusInNativeDelegate FocusIn_cb_delegate;
		static FocusInNativeDelegate FocusInVMCallback {
			get {
				if (FocusIn_cb_delegate == null)
					FocusIn_cb_delegate = new FocusInNativeDelegate (FocusIn_cb);
				return FocusIn_cb_delegate;
			}
		}

		static void OverrideFocusIn (GLib.GType gtype)
		{
			OverrideFocusIn (gtype, FocusInVMCallback);
		}

		static void OverrideFocusIn (GLib.GType gtype, FocusInNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("focus_in"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideFocusIn")]
		protected virtual void OnFocusIn ()
		{
			InternalFocusIn ();
		}

		private void InternalFocusIn ()
		{
			FocusInNativeDelegate unmanaged = class_abi.BaseOverride<FocusInNativeDelegate>(this.LookupGType(), "focus_in");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static FocusOutNativeDelegate FocusOut_cb_delegate;
		static FocusOutNativeDelegate FocusOutVMCallback {
			get {
				if (FocusOut_cb_delegate == null)
					FocusOut_cb_delegate = new FocusOutNativeDelegate (FocusOut_cb);
				return FocusOut_cb_delegate;
			}
		}

		static void OverrideFocusOut (GLib.GType gtype)
		{
			OverrideFocusOut (gtype, FocusOutVMCallback);
		}

		static void OverrideFocusOut (GLib.GType gtype, FocusOutNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("focus_out"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideFocusOut")]
		protected virtual void OnFocusOut ()
		{
			InternalFocusOut ();
		}

		private void InternalFocusOut ()
		{
			FocusOutNativeDelegate unmanaged = class_abi.BaseOverride<FocusOutNativeDelegate>(this.LookupGType(), "focus_out");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ResetNativeDelegate Reset_cb_delegate;
		static ResetNativeDelegate ResetVMCallback {
			get {
				if (Reset_cb_delegate == null)
					Reset_cb_delegate = new ResetNativeDelegate (Reset_cb);
				return Reset_cb_delegate;
			}
		}

		static void OverrideReset (GLib.GType gtype)
		{
			OverrideReset (gtype, ResetVMCallback);
		}

		static void OverrideReset (GLib.GType gtype, ResetNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("reset"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideReset")]
		protected virtual void OnReset ()
		{
			InternalReset ();
		}

		private void InternalReset ()
		{
			ResetNativeDelegate unmanaged = class_abi.BaseOverride<ResetNativeDelegate>(this.LookupGType(), "reset");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static SetCursorLocationNativeDelegate SetCursorLocation_cb_delegate;
		static SetCursorLocationNativeDelegate SetCursorLocationVMCallback {
			get {
				if (SetCursorLocation_cb_delegate == null)
					SetCursorLocation_cb_delegate = new SetCursorLocationNativeDelegate (SetCursorLocation_cb);
				return SetCursorLocation_cb_delegate;
			}
		}

		static void OverrideSetCursorLocation (GLib.GType gtype)
		{
			OverrideSetCursorLocation (gtype, SetCursorLocationVMCallback);
		}

		static void OverrideSetCursorLocation (GLib.GType gtype, SetCursorLocationNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_cursor_location"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetCursorLocationNativeDelegate (IntPtr inst, IntPtr area);

		static void SetCursorLocation_cb (IntPtr inst, IntPtr area)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				__obj.OnSetCursorLocation ((Gdk.Rectangle) Marshal.PtrToStructure (area, typeof (Gdk.Rectangle)));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideSetCursorLocation")]
		protected virtual void OnSetCursorLocation (Gdk.Rectangle area)
		{
			InternalSetCursorLocation (area);
		}

		private void InternalSetCursorLocation (Gdk.Rectangle area)
		{
			SetCursorLocationNativeDelegate unmanaged = class_abi.BaseOverride<SetCursorLocationNativeDelegate>(this.LookupGType(), "set_cursor_location");
			if (unmanaged == null) return;

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

		static SetUsePreeditNativeDelegate SetUsePreedit_cb_delegate;
		static SetUsePreeditNativeDelegate SetUsePreeditVMCallback {
			get {
				if (SetUsePreedit_cb_delegate == null)
					SetUsePreedit_cb_delegate = new SetUsePreeditNativeDelegate (SetUsePreedit_cb);
				return SetUsePreedit_cb_delegate;
			}
		}

		static void OverrideSetUsePreedit (GLib.GType gtype)
		{
			OverrideSetUsePreedit (gtype, SetUsePreeditVMCallback);
		}

		static void OverrideSetUsePreedit (GLib.GType gtype, SetUsePreeditNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_use_preedit"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetUsePreeditNativeDelegate (IntPtr inst, bool use_preedit);

		static void SetUsePreedit_cb (IntPtr inst, bool use_preedit)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				__obj.OnSetUsePreedit (use_preedit);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideSetUsePreedit")]
		protected virtual void OnSetUsePreedit (bool use_preedit)
		{
			InternalSetUsePreedit (use_preedit);
		}

		private void InternalSetUsePreedit (bool use_preedit)
		{
			SetUsePreeditNativeDelegate unmanaged = class_abi.BaseOverride<SetUsePreeditNativeDelegate>(this.LookupGType(), "set_use_preedit");
			if (unmanaged == null) return;

			unmanaged (this.Handle, use_preedit);
		}

		static SetSurroundingNativeDelegate SetSurrounding_cb_delegate;
		static SetSurroundingNativeDelegate SetSurroundingVMCallback {
			get {
				if (SetSurrounding_cb_delegate == null)
					SetSurrounding_cb_delegate = new SetSurroundingNativeDelegate (SetSurrounding_cb);
				return SetSurrounding_cb_delegate;
			}
		}

		static void OverrideSetSurrounding (GLib.GType gtype)
		{
			OverrideSetSurrounding (gtype, SetSurroundingVMCallback);
		}

		static void OverrideSetSurrounding (GLib.GType gtype, SetSurroundingNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_surrounding"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetSurroundingNativeDelegate (IntPtr inst, IntPtr text, int len, int cursor_index);

		static void SetSurrounding_cb (IntPtr inst, IntPtr text, int len, int cursor_index)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				__obj.OnSetSurrounding (GLib.Marshaller.Utf8PtrToString (text), cursor_index);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideSetSurrounding")]
		protected virtual void OnSetSurrounding (string text, int cursor_index)
		{
			InternalSetSurrounding (text, cursor_index);
		}

		private void InternalSetSurrounding (string text, int cursor_index)
		{
			SetSurroundingNativeDelegate unmanaged = class_abi.BaseOverride<SetSurroundingNativeDelegate>(this.LookupGType(), "set_surrounding");
			if (unmanaged == null) return;

			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
			unmanaged (this.Handle, native_text, System.Text.Encoding.UTF8.GetByteCount (text), cursor_index);
			GLib.Marshaller.Free (native_text);
		}

		static GetSurroundingNativeDelegate GetSurrounding_cb_delegate;
		static GetSurroundingNativeDelegate GetSurroundingVMCallback {
			get {
				if (GetSurrounding_cb_delegate == null)
					GetSurrounding_cb_delegate = new GetSurroundingNativeDelegate (GetSurrounding_cb);
				return GetSurrounding_cb_delegate;
			}
		}

		static void OverrideGetSurrounding (GLib.GType gtype)
		{
			OverrideGetSurrounding (gtype, GetSurroundingVMCallback);
		}

		static void OverrideGetSurrounding (GLib.GType gtype, GetSurroundingNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_surrounding"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GetSurroundingNativeDelegate (IntPtr inst, IntPtr text, out int cursor_index);

		static bool GetSurrounding_cb (IntPtr inst, IntPtr text, out int cursor_index)
		{
			try {
				IMContext __obj = GLib.Object.GetObject (inst, false) as IMContext;
				bool __result;
				__result = __obj.OnGetSurrounding (GLib.Marshaller.PtrToStringGFree(text), out cursor_index);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.IMContext), ConnectionMethod="OverrideGetSurrounding")]
		protected virtual bool OnGetSurrounding (string text, out int cursor_index)
		{
			return InternalGetSurrounding (text, out cursor_index);
		}

		private bool InternalGetSurrounding (string text, out int cursor_index)
		{
			GetSurroundingNativeDelegate unmanaged = class_abi.BaseOverride<GetSurroundingNativeDelegate>(this.LookupGType(), "get_surrounding");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			bool __result = unmanaged (this.Handle, GLib.Marshaller.StringToPtrGStrdup(text), out cursor_index);
			return __result;
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public unsafe new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("preedit_start"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // preedit_start
							, null
							, "preedit_end"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("preedit_end"
							, -1
							, (uint) sizeof( IntPtr ) // preedit_end
							, "preedit_start"
							, "preedit_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("preedit_changed"
							, -1
							, (uint) sizeof( IntPtr ) // preedit_changed
							, "preedit_end"
							, "commit"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("commit"
							, -1
							, (uint) sizeof( IntPtr ) // commit
							, "preedit_changed"
							, "retrieve_surrounding"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("retrieve_surrounding"
							, -1
							, (uint) sizeof( IntPtr ) // retrieve_surrounding
							, "commit"
							, "delete_surrounding"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("delete_surrounding"
							, -1
							, (uint) sizeof( IntPtr ) // delete_surrounding
							, "retrieve_surrounding"
							, "set_client_window"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_client_window"
							, -1
							, (uint) sizeof( IntPtr ) // set_client_window
							, "delete_surrounding"
							, "get_preedit_string"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_preedit_string"
							, -1
							, (uint) sizeof( IntPtr ) // get_preedit_string
							, "set_client_window"
							, "filter_keypress"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("filter_keypress"
							, -1
							, (uint) sizeof( IntPtr ) // filter_keypress
							, "get_preedit_string"
							, "focus_in"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("focus_in"
							, -1
							, (uint) sizeof( IntPtr ) // focus_in
							, "filter_keypress"
							, "focus_out"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("focus_out"
							, -1
							, (uint) sizeof( IntPtr ) // focus_out
							, "focus_in"
							, "reset"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("reset"
							, -1
							, (uint) sizeof( IntPtr ) // reset
							, "focus_out"
							, "set_cursor_location"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_cursor_location"
							, -1
							, (uint) sizeof( IntPtr ) // set_cursor_location
							, "reset"
							, "set_use_preedit"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_use_preedit"
							, -1
							, (uint) sizeof( IntPtr ) // set_use_preedit
							, "set_cursor_location"
							, "set_surrounding"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_surrounding"
							, -1
							, (uint) sizeof( IntPtr ) // set_surrounding
							, "set_use_preedit"
							, "get_surrounding"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_surrounding"
							, -1
							, (uint) sizeof( IntPtr ) // get_surrounding
							, "set_surrounding"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "get_surrounding"
							, "_gtk_reserved2"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved3
							, "_gtk_reserved2"
							, "_gtk_reserved4"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved4"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved4
							, "_gtk_reserved3"
							, "_gtk_reserved5"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved5"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved5
							, "_gtk_reserved4"
							, "_gtk_reserved6"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved6"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved6
							, "_gtk_reserved5"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_im_context_delete_surrounding(IntPtr raw, int offset, int n_chars);
		static d_gtk_im_context_delete_surrounding gtk_im_context_delete_surrounding = FuncLoader.LoadFunction<d_gtk_im_context_delete_surrounding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_delete_surrounding"));

		public bool DeleteSurrounding(int offset, int n_chars) {
			bool raw_ret = gtk_im_context_delete_surrounding(Handle, offset, n_chars);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_im_context_filter_keypress(IntPtr raw, IntPtr evnt);
		static d_gtk_im_context_filter_keypress gtk_im_context_filter_keypress = FuncLoader.LoadFunction<d_gtk_im_context_filter_keypress>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_filter_keypress"));

		public bool FilterKeypress(Gdk.EventKey evnt) {
			bool raw_ret = gtk_im_context_filter_keypress(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_focus_in(IntPtr raw);
		static d_gtk_im_context_focus_in gtk_im_context_focus_in = FuncLoader.LoadFunction<d_gtk_im_context_focus_in>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_focus_in"));

		public void FocusIn() {
			gtk_im_context_focus_in(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_focus_out(IntPtr raw);
		static d_gtk_im_context_focus_out gtk_im_context_focus_out = FuncLoader.LoadFunction<d_gtk_im_context_focus_out>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_focus_out"));

		public void FocusOut() {
			gtk_im_context_focus_out(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_get_preedit_string(IntPtr raw, out IntPtr str, out IntPtr attrs, out int cursor_pos);
		static d_gtk_im_context_get_preedit_string gtk_im_context_get_preedit_string = FuncLoader.LoadFunction<d_gtk_im_context_get_preedit_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_get_preedit_string"));

		public void GetPreeditString(out string str, out Pango.AttrList attrs, out int cursor_pos) {
			IntPtr native_str;
			IntPtr native_attrs;
			gtk_im_context_get_preedit_string(Handle, out native_str, out native_attrs, out cursor_pos);
			str = GLib.Marshaller.PtrToStringGFree(native_str);
			attrs = native_attrs == IntPtr.Zero ? null : (Pango.AttrList) GLib.Opaque.GetOpaque (native_attrs, typeof (Pango.AttrList), false);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_im_context_get_surrounding(IntPtr raw, out IntPtr text, out int cursor_index);
		static d_gtk_im_context_get_surrounding gtk_im_context_get_surrounding = FuncLoader.LoadFunction<d_gtk_im_context_get_surrounding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_get_surrounding"));

		public bool GetSurrounding(out string text, out int cursor_index) {
			IntPtr native_text;
			bool raw_ret = gtk_im_context_get_surrounding(Handle, out native_text, out cursor_index);
			bool ret = raw_ret;
			text = GLib.Marshaller.PtrToStringGFree(native_text);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_im_context_get_type();
		static d_gtk_im_context_get_type gtk_im_context_get_type = FuncLoader.LoadFunction<d_gtk_im_context_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_get_type"));

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_reset(IntPtr raw);
		static d_gtk_im_context_reset gtk_im_context_reset = FuncLoader.LoadFunction<d_gtk_im_context_reset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_reset"));

		public void Reset() {
			gtk_im_context_reset(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_set_client_window(IntPtr raw, IntPtr window);
		static d_gtk_im_context_set_client_window gtk_im_context_set_client_window = FuncLoader.LoadFunction<d_gtk_im_context_set_client_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_set_client_window"));

		public Gdk.Window ClientWindow { 
			set {
				gtk_im_context_set_client_window(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_set_cursor_location(IntPtr raw, IntPtr value);
		static d_gtk_im_context_set_cursor_location gtk_im_context_set_cursor_location = FuncLoader.LoadFunction<d_gtk_im_context_set_cursor_location>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_set_cursor_location"));

		public Gdk.Rectangle CursorLocation { 
			set {
				IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
				gtk_im_context_set_cursor_location(Handle, native_value);
				Marshal.FreeHGlobal (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_set_surrounding(IntPtr raw, IntPtr text, int len, int cursor_index);
		static d_gtk_im_context_set_surrounding gtk_im_context_set_surrounding = FuncLoader.LoadFunction<d_gtk_im_context_set_surrounding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_set_surrounding"));

		public void SetSurrounding(string text, int cursor_index) {
			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
			gtk_im_context_set_surrounding(Handle, native_text, System.Text.Encoding.UTF8.GetByteCount (text), cursor_index);
			GLib.Marshaller.Free (native_text);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_im_context_set_use_preedit(IntPtr raw, bool use_preedit);
		static d_gtk_im_context_set_use_preedit gtk_im_context_set_use_preedit = FuncLoader.LoadFunction<d_gtk_im_context_set_use_preedit>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_im_context_set_use_preedit"));

		public bool UsePreedit { 
			set {
				gtk_im_context_set_use_preedit(Handle, value);
			}
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public unsafe new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (GLib.Object.abi_info.Fields);

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
