KioskApp/GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Keymap.cs

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

namespace Gdk {

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

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

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

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

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

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

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

		static GetDirectionNativeDelegate GetDirection_cb_delegate;
		static GetDirectionNativeDelegate GetDirectionVMCallback {
			get {
				if (GetDirection_cb_delegate == null)
					GetDirection_cb_delegate = new GetDirectionNativeDelegate (GetDirection_cb);
				return GetDirection_cb_delegate;
			}
		}

		static void OverrideGetDirection (GLib.GType gtype)
		{
			OverrideGetDirection (gtype, GetDirectionVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetDirection")]
		protected virtual Pango.Direction OnGetDirection ()
		{
			return InternalGetDirection ();
		}

		private Pango.Direction InternalGetDirection ()
		{
			GetDirectionNativeDelegate unmanaged = class_abi.BaseOverride<GetDirectionNativeDelegate>(this.LookupGType(), "get_direction");
			if (unmanaged == null) return (Pango.Direction) 0;

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

		static HaveBidiLayoutsNativeDelegate HaveBidiLayouts_cb_delegate;
		static HaveBidiLayoutsNativeDelegate HaveBidiLayoutsVMCallback {
			get {
				if (HaveBidiLayouts_cb_delegate == null)
					HaveBidiLayouts_cb_delegate = new HaveBidiLayoutsNativeDelegate (HaveBidiLayouts_cb);
				return HaveBidiLayouts_cb_delegate;
			}
		}

		static void OverrideHaveBidiLayouts (GLib.GType gtype)
		{
			OverrideHaveBidiLayouts (gtype, HaveBidiLayoutsVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideHaveBidiLayouts")]
		protected virtual bool OnHaveBidiLayouts ()
		{
			return InternalHaveBidiLayouts ();
		}

		private bool InternalHaveBidiLayouts ()
		{
			HaveBidiLayoutsNativeDelegate unmanaged = class_abi.BaseOverride<HaveBidiLayoutsNativeDelegate>(this.LookupGType(), "have_bidi_layouts");
			if (unmanaged == null) return false;

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

		static GetCapsLockStateNativeDelegate GetCapsLockState_cb_delegate;
		static GetCapsLockStateNativeDelegate GetCapsLockStateVMCallback {
			get {
				if (GetCapsLockState_cb_delegate == null)
					GetCapsLockState_cb_delegate = new GetCapsLockStateNativeDelegate (GetCapsLockState_cb);
				return GetCapsLockState_cb_delegate;
			}
		}

		static void OverrideGetCapsLockState (GLib.GType gtype)
		{
			OverrideGetCapsLockState (gtype, GetCapsLockStateVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetCapsLockState")]
		protected virtual bool OnGetCapsLockState ()
		{
			return InternalGetCapsLockState ();
		}

		private bool InternalGetCapsLockState ()
		{
			GetCapsLockStateNativeDelegate unmanaged = class_abi.BaseOverride<GetCapsLockStateNativeDelegate>(this.LookupGType(), "get_caps_lock_state");
			if (unmanaged == null) return false;

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

		static GetNumLockStateNativeDelegate GetNumLockState_cb_delegate;
		static GetNumLockStateNativeDelegate GetNumLockStateVMCallback {
			get {
				if (GetNumLockState_cb_delegate == null)
					GetNumLockState_cb_delegate = new GetNumLockStateNativeDelegate (GetNumLockState_cb);
				return GetNumLockState_cb_delegate;
			}
		}

		static void OverrideGetNumLockState (GLib.GType gtype)
		{
			OverrideGetNumLockState (gtype, GetNumLockStateVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetNumLockState")]
		protected virtual bool OnGetNumLockState ()
		{
			return InternalGetNumLockState ();
		}

		private bool InternalGetNumLockState ()
		{
			GetNumLockStateNativeDelegate unmanaged = class_abi.BaseOverride<GetNumLockStateNativeDelegate>(this.LookupGType(), "get_num_lock_state");
			if (unmanaged == null) return false;

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

		static GetScrollLockStateNativeDelegate GetScrollLockState_cb_delegate;
		static GetScrollLockStateNativeDelegate GetScrollLockStateVMCallback {
			get {
				if (GetScrollLockState_cb_delegate == null)
					GetScrollLockState_cb_delegate = new GetScrollLockStateNativeDelegate (GetScrollLockState_cb);
				return GetScrollLockState_cb_delegate;
			}
		}

		static void OverrideGetScrollLockState (GLib.GType gtype)
		{
			OverrideGetScrollLockState (gtype, GetScrollLockStateVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetScrollLockState")]
		protected virtual bool OnGetScrollLockState ()
		{
			return InternalGetScrollLockState ();
		}

		private bool InternalGetScrollLockState ()
		{
			GetScrollLockStateNativeDelegate unmanaged = class_abi.BaseOverride<GetScrollLockStateNativeDelegate>(this.LookupGType(), "get_scroll_lock_state");
			if (unmanaged == null) return false;

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

		static GetEntriesForKeyvalNativeDelegate GetEntriesForKeyval_cb_delegate;
		static GetEntriesForKeyvalNativeDelegate GetEntriesForKeyvalVMCallback {
			get {
				if (GetEntriesForKeyval_cb_delegate == null)
					GetEntriesForKeyval_cb_delegate = new GetEntriesForKeyvalNativeDelegate (GetEntriesForKeyval_cb);
				return GetEntriesForKeyval_cb_delegate;
			}
		}

		static void OverrideGetEntriesForKeyval (GLib.GType gtype)
		{
			OverrideGetEntriesForKeyval (gtype, GetEntriesForKeyvalVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GetEntriesForKeyvalNativeDelegate (IntPtr inst, uint keyval, IntPtr keys, out int n_keys);

		static bool GetEntriesForKeyval_cb (IntPtr inst, uint keyval, IntPtr keys, out int n_keys)
		{
			try {
				Keymap __obj = GLib.Object.GetObject (inst, false) as Keymap;
				bool __result;
				__result = __obj.OnGetEntriesForKeyval (keyval, Gdk.KeymapKey.New (keys), out n_keys);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetEntriesForKeyval")]
		protected virtual bool OnGetEntriesForKeyval (uint keyval, Gdk.KeymapKey keys, out int n_keys)
		{
			return InternalGetEntriesForKeyval (keyval, keys, out n_keys);
		}

		private bool InternalGetEntriesForKeyval (uint keyval, Gdk.KeymapKey keys, out int n_keys)
		{
			GetEntriesForKeyvalNativeDelegate unmanaged = class_abi.BaseOverride<GetEntriesForKeyvalNativeDelegate>(this.LookupGType(), "get_entries_for_keyval");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			IntPtr native_keys = GLib.Marshaller.StructureToPtrAlloc (keys);
			bool __result = unmanaged (this.Handle, keyval, native_keys, out n_keys);
			Marshal.FreeHGlobal (native_keys);
			return __result;
		}

		static GetEntriesForKeycodeNativeDelegate GetEntriesForKeycode_cb_delegate;
		static GetEntriesForKeycodeNativeDelegate GetEntriesForKeycodeVMCallback {
			get {
				if (GetEntriesForKeycode_cb_delegate == null)
					GetEntriesForKeycode_cb_delegate = new GetEntriesForKeycodeNativeDelegate (GetEntriesForKeycode_cb);
				return GetEntriesForKeycode_cb_delegate;
			}
		}

		static void OverrideGetEntriesForKeycode (GLib.GType gtype)
		{
			OverrideGetEntriesForKeycode (gtype, GetEntriesForKeycodeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GetEntriesForKeycodeNativeDelegate (IntPtr inst, uint hardware_keycode, IntPtr keys, out uint keyvals, out int n_entries);

		static bool GetEntriesForKeycode_cb (IntPtr inst, uint hardware_keycode, IntPtr keys, out uint keyvals, out int n_entries)
		{
			try {
				Keymap __obj = GLib.Object.GetObject (inst, false) as Keymap;
				bool __result;
				__result = __obj.OnGetEntriesForKeycode (hardware_keycode, Gdk.KeymapKey.New (keys), out keyvals, out n_entries);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetEntriesForKeycode")]
		protected virtual bool OnGetEntriesForKeycode (uint hardware_keycode, Gdk.KeymapKey keys, out uint keyvals, out int n_entries)
		{
			return InternalGetEntriesForKeycode (hardware_keycode, keys, out keyvals, out n_entries);
		}

		private bool InternalGetEntriesForKeycode (uint hardware_keycode, Gdk.KeymapKey keys, out uint keyvals, out int n_entries)
		{
			GetEntriesForKeycodeNativeDelegate unmanaged = class_abi.BaseOverride<GetEntriesForKeycodeNativeDelegate>(this.LookupGType(), "get_entries_for_keycode");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			IntPtr native_keys = GLib.Marshaller.StructureToPtrAlloc (keys);
			bool __result = unmanaged (this.Handle, hardware_keycode, native_keys, out keyvals, out n_entries);
			Marshal.FreeHGlobal (native_keys);
			return __result;
		}

		static LookupKeyNativeDelegate LookupKey_cb_delegate;
		static LookupKeyNativeDelegate LookupKeyVMCallback {
			get {
				if (LookupKey_cb_delegate == null)
					LookupKey_cb_delegate = new LookupKeyNativeDelegate (LookupKey_cb);
				return LookupKey_cb_delegate;
			}
		}

		static void OverrideLookupKey (GLib.GType gtype)
		{
			OverrideLookupKey (gtype, LookupKeyVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint LookupKeyNativeDelegate (IntPtr inst, IntPtr key);

		static uint LookupKey_cb (IntPtr inst, IntPtr key)
		{
			try {
				Keymap __obj = GLib.Object.GetObject (inst, false) as Keymap;
				uint __result;
				__result = __obj.OnLookupKey (Gdk.KeymapKey.New (key));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideLookupKey")]
		protected virtual uint OnLookupKey (Gdk.KeymapKey key)
		{
			return InternalLookupKey (key);
		}

		private uint InternalLookupKey (Gdk.KeymapKey key)
		{
			LookupKeyNativeDelegate unmanaged = class_abi.BaseOverride<LookupKeyNativeDelegate>(this.LookupGType(), "lookup_key");
			if (unmanaged == null) return 0;

			IntPtr native_key = GLib.Marshaller.StructureToPtrAlloc (key);
			uint __result = unmanaged (this.Handle, native_key);
			Marshal.FreeHGlobal (native_key);
			return __result;
		}

		static TranslateKeyboardStateNativeDelegate TranslateKeyboardState_cb_delegate;
		static TranslateKeyboardStateNativeDelegate TranslateKeyboardStateVMCallback {
			get {
				if (TranslateKeyboardState_cb_delegate == null)
					TranslateKeyboardState_cb_delegate = new TranslateKeyboardStateNativeDelegate (TranslateKeyboardState_cb);
				return TranslateKeyboardState_cb_delegate;
			}
		}

		static void OverrideTranslateKeyboardState (GLib.GType gtype)
		{
			OverrideTranslateKeyboardState (gtype, TranslateKeyboardStateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool TranslateKeyboardStateNativeDelegate (IntPtr inst, uint hardware_keycode, int state, int group, out uint keyval, out int effective_group, out int level, out int consumed_modifiers);

		static bool TranslateKeyboardState_cb (IntPtr inst, uint hardware_keycode, int state, int group, out uint keyval, out int effective_group, out int level, out int consumed_modifiers)
		{
			try {
				Keymap __obj = GLib.Object.GetObject (inst, false) as Keymap;
				bool __result;
				Gdk.ModifierType myconsumed_modifiers;
				__result = __obj.OnTranslateKeyboardState (hardware_keycode, (Gdk.ModifierType) state, group, out keyval, out effective_group, out level, out myconsumed_modifiers);
				consumed_modifiers = (int) myconsumed_modifiers;
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideTranslateKeyboardState")]
		protected virtual bool OnTranslateKeyboardState (uint hardware_keycode, Gdk.ModifierType state, int group, out uint keyval, out int effective_group, out int level, out Gdk.ModifierType consumed_modifiers)
		{
			return InternalTranslateKeyboardState (hardware_keycode, state, group, out keyval, out effective_group, out level, out consumed_modifiers);
		}

		private bool InternalTranslateKeyboardState (uint hardware_keycode, Gdk.ModifierType state, int group, out uint keyval, out int effective_group, out int level, out Gdk.ModifierType consumed_modifiers)
		{
			TranslateKeyboardStateNativeDelegate unmanaged = class_abi.BaseOverride<TranslateKeyboardStateNativeDelegate>(this.LookupGType(), "translate_keyboard_state");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_consumed_modifiers;
			bool __result = unmanaged (this.Handle, hardware_keycode, (int) state, group, out keyval, out effective_group, out level, out native_consumed_modifiers);
			consumed_modifiers = (Gdk.ModifierType) native_consumed_modifiers;
			return __result;
		}

		static AddVirtualModifiersNativeDelegate AddVirtualModifiers_cb_delegate;
		static AddVirtualModifiersNativeDelegate AddVirtualModifiersVMCallback {
			get {
				if (AddVirtualModifiers_cb_delegate == null)
					AddVirtualModifiers_cb_delegate = new AddVirtualModifiersNativeDelegate (AddVirtualModifiers_cb);
				return AddVirtualModifiers_cb_delegate;
			}
		}

		static void OverrideAddVirtualModifiers (GLib.GType gtype)
		{
			OverrideAddVirtualModifiers (gtype, AddVirtualModifiersVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AddVirtualModifiersNativeDelegate (IntPtr inst, out int state);

		static void AddVirtualModifiers_cb (IntPtr inst, out int state)
		{
			try {
				Keymap __obj = GLib.Object.GetObject (inst, false) as Keymap;
				Gdk.ModifierType mystate;
				__obj.OnAddVirtualModifiers (out mystate);
				state = (int) mystate;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideAddVirtualModifiers")]
		protected virtual void OnAddVirtualModifiers (out Gdk.ModifierType state)
		{
			InternalAddVirtualModifiers (out state);
		}

		private void InternalAddVirtualModifiers (out Gdk.ModifierType state)
		{
			AddVirtualModifiersNativeDelegate unmanaged = class_abi.BaseOverride<AddVirtualModifiersNativeDelegate>(this.LookupGType(), "add_virtual_modifiers");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_state;
			unmanaged (this.Handle, out native_state);
			state = (Gdk.ModifierType) native_state;
		}

		static MapVirtualModifiersNativeDelegate MapVirtualModifiers_cb_delegate;
		static MapVirtualModifiersNativeDelegate MapVirtualModifiersVMCallback {
			get {
				if (MapVirtualModifiers_cb_delegate == null)
					MapVirtualModifiers_cb_delegate = new MapVirtualModifiersNativeDelegate (MapVirtualModifiers_cb);
				return MapVirtualModifiers_cb_delegate;
			}
		}

		static void OverrideMapVirtualModifiers (GLib.GType gtype)
		{
			OverrideMapVirtualModifiers (gtype, MapVirtualModifiersVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool MapVirtualModifiersNativeDelegate (IntPtr inst, out int state);

		static bool MapVirtualModifiers_cb (IntPtr inst, out int state)
		{
			try {
				Keymap __obj = GLib.Object.GetObject (inst, false) as Keymap;
				bool __result;
				Gdk.ModifierType mystate;
				__result = __obj.OnMapVirtualModifiers (out mystate);
				state = (int) mystate;
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideMapVirtualModifiers")]
		protected virtual bool OnMapVirtualModifiers (out Gdk.ModifierType state)
		{
			return InternalMapVirtualModifiers (out state);
		}

		private bool InternalMapVirtualModifiers (out Gdk.ModifierType state)
		{
			MapVirtualModifiersNativeDelegate unmanaged = class_abi.BaseOverride<MapVirtualModifiersNativeDelegate>(this.LookupGType(), "map_virtual_modifiers");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_state;
			bool __result = unmanaged (this.Handle, out native_state);
			state = (Gdk.ModifierType) native_state;
			return __result;
		}

		static GetModifierMaskNativeDelegate GetModifierMask_cb_delegate;
		static GetModifierMaskNativeDelegate GetModifierMaskVMCallback {
			get {
				if (GetModifierMask_cb_delegate == null)
					GetModifierMask_cb_delegate = new GetModifierMaskNativeDelegate (GetModifierMask_cb);
				return GetModifierMask_cb_delegate;
			}
		}

		static void OverrideGetModifierMask (GLib.GType gtype)
		{
			OverrideGetModifierMask (gtype, GetModifierMaskVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetModifierMaskNativeDelegate (IntPtr inst, int intent);

		static int GetModifierMask_cb (IntPtr inst, int intent)
		{
			try {
				Keymap __obj = GLib.Object.GetObject (inst, false) as Keymap;
				Gdk.ModifierType __result;
				__result = __obj.OnGetModifierMask ((Gdk.ModifierIntent) intent);
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetModifierMask")]
		protected virtual Gdk.ModifierType OnGetModifierMask (Gdk.ModifierIntent intent)
		{
			return InternalGetModifierMask (intent);
		}

		private Gdk.ModifierType InternalGetModifierMask (Gdk.ModifierIntent intent)
		{
			GetModifierMaskNativeDelegate unmanaged = class_abi.BaseOverride<GetModifierMaskNativeDelegate>(this.LookupGType(), "get_modifier_mask");
			if (unmanaged == null) return (Gdk.ModifierType) 0;

			int __result = unmanaged (this.Handle, (int) intent);
			return (Gdk.ModifierType) __result;
		}

		static GetModifierStateNativeDelegate GetModifierState_cb_delegate;
		static GetModifierStateNativeDelegate GetModifierStateVMCallback {
			get {
				if (GetModifierState_cb_delegate == null)
					GetModifierState_cb_delegate = new GetModifierStateNativeDelegate (GetModifierState_cb);
				return GetModifierState_cb_delegate;
			}
		}

		static void OverrideGetModifierState (GLib.GType gtype)
		{
			OverrideGetModifierState (gtype, GetModifierStateVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideGetModifierState")]
		protected virtual uint OnGetModifierState ()
		{
			return InternalGetModifierState ();
		}

		private uint InternalGetModifierState ()
		{
			GetModifierStateNativeDelegate unmanaged = class_abi.BaseOverride<GetModifierStateNativeDelegate>(this.LookupGType(), "get_modifier_state");
			if (unmanaged == null) return 0;

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

		static DirectionChangedNativeDelegate DirectionChanged_cb_delegate;
		static DirectionChangedNativeDelegate DirectionChangedVMCallback {
			get {
				if (DirectionChanged_cb_delegate == null)
					DirectionChanged_cb_delegate = new DirectionChangedNativeDelegate (DirectionChanged_cb);
				return DirectionChanged_cb_delegate;
			}
		}

		static void OverrideDirectionChanged (GLib.GType gtype)
		{
			OverrideDirectionChanged (gtype, DirectionChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideDirectionChanged")]
		protected virtual void OnDirectionChanged ()
		{
			InternalDirectionChanged ();
		}

		private void InternalDirectionChanged ()
		{
			DirectionChangedNativeDelegate unmanaged = class_abi.BaseOverride<DirectionChangedNativeDelegate>(this.LookupGType(), "direction_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static KeysChangedNativeDelegate KeysChanged_cb_delegate;
		static KeysChangedNativeDelegate KeysChangedVMCallback {
			get {
				if (KeysChanged_cb_delegate == null)
					KeysChanged_cb_delegate = new KeysChangedNativeDelegate (KeysChanged_cb);
				return KeysChanged_cb_delegate;
			}
		}

		static void OverrideKeysChanged (GLib.GType gtype)
		{
			OverrideKeysChanged (gtype, KeysChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideKeysChanged")]
		protected virtual void OnKeysChanged ()
		{
			InternalKeysChanged ();
		}

		private void InternalKeysChanged ()
		{
			KeysChangedNativeDelegate unmanaged = class_abi.BaseOverride<KeysChangedNativeDelegate>(this.LookupGType(), "keys_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static StateChangedNativeDelegate StateChanged_cb_delegate;
		static StateChangedNativeDelegate StateChangedVMCallback {
			get {
				if (StateChanged_cb_delegate == null)
					StateChanged_cb_delegate = new StateChangedNativeDelegate (StateChanged_cb);
				return StateChanged_cb_delegate;
			}
		}

		static void OverrideStateChanged (GLib.GType gtype)
		{
			OverrideStateChanged (gtype, StateChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Keymap), ConnectionMethod="OverrideStateChanged")]
		protected virtual void OnStateChanged ()
		{
			InternalStateChanged ();
		}

		private void InternalStateChanged ()
		{
			StateChangedNativeDelegate unmanaged = class_abi.BaseOverride<StateChangedNativeDelegate>(this.LookupGType(), "state_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public unsafe new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("get_direction"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // get_direction
							, null
							, "have_bidi_layouts"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("have_bidi_layouts"
							, -1
							, (uint) sizeof( IntPtr ) // have_bidi_layouts
							, "get_direction"
							, "get_caps_lock_state"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_caps_lock_state"
							, -1
							, (uint) sizeof( IntPtr ) // get_caps_lock_state
							, "have_bidi_layouts"
							, "get_num_lock_state"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_num_lock_state"
							, -1
							, (uint) sizeof( IntPtr ) // get_num_lock_state
							, "get_caps_lock_state"
							, "get_scroll_lock_state"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_scroll_lock_state"
							, -1
							, (uint) sizeof( IntPtr ) // get_scroll_lock_state
							, "get_num_lock_state"
							, "get_entries_for_keyval"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_entries_for_keyval"
							, -1
							, (uint) sizeof( IntPtr ) // get_entries_for_keyval
							, "get_scroll_lock_state"
							, "get_entries_for_keycode"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_entries_for_keycode"
							, -1
							, (uint) sizeof( IntPtr ) // get_entries_for_keycode
							, "get_entries_for_keyval"
							, "lookup_key"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("lookup_key"
							, -1
							, (uint) sizeof( IntPtr ) // lookup_key
							, "get_entries_for_keycode"
							, "translate_keyboard_state"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("translate_keyboard_state"
							, -1
							, (uint) sizeof( IntPtr ) // translate_keyboard_state
							, "lookup_key"
							, "add_virtual_modifiers"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("add_virtual_modifiers"
							, -1
							, (uint) sizeof( IntPtr ) // add_virtual_modifiers
							, "translate_keyboard_state"
							, "map_virtual_modifiers"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("map_virtual_modifiers"
							, -1
							, (uint) sizeof( IntPtr ) // map_virtual_modifiers
							, "add_virtual_modifiers"
							, "get_modifier_mask"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_modifier_mask"
							, -1
							, (uint) sizeof( IntPtr ) // get_modifier_mask
							, "map_virtual_modifiers"
							, "get_modifier_state"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_modifier_state"
							, -1
							, (uint) sizeof( IntPtr ) // get_modifier_state
							, "get_modifier_mask"
							, "direction_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("direction_changed"
							, -1
							, (uint) sizeof( IntPtr ) // direction_changed
							, "get_modifier_state"
							, "keys_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("keys_changed"
							, -1
							, (uint) sizeof( IntPtr ) // keys_changed
							, "direction_changed"
							, "state_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("state_changed"
							, -1
							, (uint) sizeof( IntPtr ) // state_changed
							, "keys_changed"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_keymap_add_virtual_modifiers(IntPtr raw, out int state);
		static d_gdk_keymap_add_virtual_modifiers gdk_keymap_add_virtual_modifiers = FuncLoader.LoadFunction<d_gdk_keymap_add_virtual_modifiers>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_add_virtual_modifiers"));

		public Gdk.ModifierType AddVirtualModifiers() {
			Gdk.ModifierType state;
			int native_state;
			gdk_keymap_add_virtual_modifiers(Handle, out native_state);
			state = (Gdk.ModifierType) native_state;
			return state;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_keymap_get_caps_lock_state(IntPtr raw);
		static d_gdk_keymap_get_caps_lock_state gdk_keymap_get_caps_lock_state = FuncLoader.LoadFunction<d_gdk_keymap_get_caps_lock_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_caps_lock_state"));

		public bool CapsLockState { 
			get {
				bool raw_ret = gdk_keymap_get_caps_lock_state(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_keymap_get_default();
		static d_gdk_keymap_get_default gdk_keymap_get_default = FuncLoader.LoadFunction<d_gdk_keymap_get_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_default"));

		public static Gdk.Keymap Default { 
			get {
				IntPtr raw_ret = gdk_keymap_get_default();
				Gdk.Keymap ret = GLib.Object.GetObject(raw_ret) as Gdk.Keymap;
				return ret;
			}
		}

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

		public Pango.Direction Direction { 
			get {
				int raw_ret = gdk_keymap_get_direction(Handle);
				Pango.Direction ret = (Pango.Direction) raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_keymap_get_for_display(IntPtr display);
		static d_gdk_keymap_get_for_display gdk_keymap_get_for_display = FuncLoader.LoadFunction<d_gdk_keymap_get_for_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_for_display"));

		public static Gdk.Keymap GetForDisplay(Gdk.Display display) {
			IntPtr raw_ret = gdk_keymap_get_for_display(display == null ? IntPtr.Zero : display.Handle);
			Gdk.Keymap ret = GLib.Object.GetObject(raw_ret) as Gdk.Keymap;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gdk_keymap_get_modifier_mask(IntPtr raw, int intent);
		static d_gdk_keymap_get_modifier_mask gdk_keymap_get_modifier_mask = FuncLoader.LoadFunction<d_gdk_keymap_get_modifier_mask>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_modifier_mask"));

		public Gdk.ModifierType GetModifierMask(Gdk.ModifierIntent intent) {
			int raw_ret = gdk_keymap_get_modifier_mask(Handle, (int) intent);
			Gdk.ModifierType ret = (Gdk.ModifierType) raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_gdk_keymap_get_modifier_state(IntPtr raw);
		static d_gdk_keymap_get_modifier_state gdk_keymap_get_modifier_state = FuncLoader.LoadFunction<d_gdk_keymap_get_modifier_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_modifier_state"));

		public uint ModifierState { 
			get {
				uint raw_ret = gdk_keymap_get_modifier_state(Handle);
				uint ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_keymap_get_num_lock_state(IntPtr raw);
		static d_gdk_keymap_get_num_lock_state gdk_keymap_get_num_lock_state = FuncLoader.LoadFunction<d_gdk_keymap_get_num_lock_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_num_lock_state"));

		public bool NumLockState { 
			get {
				bool raw_ret = gdk_keymap_get_num_lock_state(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_keymap_get_scroll_lock_state(IntPtr raw);
		static d_gdk_keymap_get_scroll_lock_state gdk_keymap_get_scroll_lock_state = FuncLoader.LoadFunction<d_gdk_keymap_get_scroll_lock_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_scroll_lock_state"));

		public bool ScrollLockState { 
			get {
				bool raw_ret = gdk_keymap_get_scroll_lock_state(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_keymap_get_type();
		static d_gdk_keymap_get_type gdk_keymap_get_type = FuncLoader.LoadFunction<d_gdk_keymap_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_type"));

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_keymap_have_bidi_layouts(IntPtr raw);
		static d_gdk_keymap_have_bidi_layouts gdk_keymap_have_bidi_layouts = FuncLoader.LoadFunction<d_gdk_keymap_have_bidi_layouts>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_have_bidi_layouts"));

		public bool HaveBidiLayouts() {
			bool raw_ret = gdk_keymap_have_bidi_layouts(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint d_gdk_keymap_lookup_key(IntPtr raw, IntPtr key);
		static d_gdk_keymap_lookup_key gdk_keymap_lookup_key = FuncLoader.LoadFunction<d_gdk_keymap_lookup_key>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_lookup_key"));

		public uint LookupKey(Gdk.KeymapKey key) {
			IntPtr native_key = GLib.Marshaller.StructureToPtrAlloc (key);
			uint raw_ret = gdk_keymap_lookup_key(Handle, native_key);
			uint ret = raw_ret;
			Marshal.FreeHGlobal (native_key);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_keymap_map_virtual_modifiers(IntPtr raw, out int state);
		static d_gdk_keymap_map_virtual_modifiers gdk_keymap_map_virtual_modifiers = FuncLoader.LoadFunction<d_gdk_keymap_map_virtual_modifiers>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_map_virtual_modifiers"));

		public bool MapVirtualModifiers(out Gdk.ModifierType state) {
			int native_state;
			bool raw_ret = gdk_keymap_map_virtual_modifiers(Handle, out native_state);
			bool ret = raw_ret;
			state = (Gdk.ModifierType) native_state;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_keymap_translate_keyboard_state(IntPtr raw, uint hardware_keycode, int state, int group, out uint keyval, out int effective_group, out int level, out int consumed_modifiers);
		static d_gdk_keymap_translate_keyboard_state gdk_keymap_translate_keyboard_state = FuncLoader.LoadFunction<d_gdk_keymap_translate_keyboard_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_translate_keyboard_state"));

		public bool TranslateKeyboardState(uint hardware_keycode, Gdk.ModifierType state, int group, out uint keyval, out int effective_group, out int level, out Gdk.ModifierType consumed_modifiers) {
			int native_consumed_modifiers;
			bool raw_ret = gdk_keymap_translate_keyboard_state(Handle, hardware_keycode, (int) state, group, out keyval, out effective_group, out level, out native_consumed_modifiers);
			bool ret = raw_ret;
			consumed_modifiers = (Gdk.ModifierType) native_consumed_modifiers;
			return ret;
		}


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

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}