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

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

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

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

		[GLib.Property ("display")]
		public Gdk.Display Display {
			get  {
				IntPtr raw_ret = gdk_device_get_display(Handle);
				Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
				return ret;
			}
		}

		[GLib.Property ("device-manager")]
		public Gdk.DeviceManager DeviceManager {
			get {
				GLib.Value val = GetProperty ("device-manager");
				Gdk.DeviceManager ret = (Gdk.DeviceManager) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Property ("name")]
		public string Name {
			get  {
				IntPtr raw_ret = gdk_device_get_name(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
		}

		[GLib.Property ("type")]
		public Gdk.DeviceType Type {
			get {
				GLib.Value val = GetProperty ("type");
				Gdk.DeviceType ret = (Gdk.DeviceType) (Enum) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Property ("associated-device")]
		public Gdk.Device AssociatedDevice {
			get  {
				IntPtr raw_ret = gdk_device_get_associated_device(Handle);
				Gdk.Device ret = GLib.Object.GetObject(raw_ret) as Gdk.Device;
				return ret;
			}
		}

		[GLib.Property ("input-source")]
		public Gdk.InputSource InputSource {
			get {
				GLib.Value val = GetProperty ("input-source");
				Gdk.InputSource ret = (Gdk.InputSource) (Enum) val;
				val.Dispose ();
				return ret;
			}
		}

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

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

		[GLib.Property ("has-cursor")]
		public bool HasCursor {
			get  {
				bool raw_ret = gdk_device_get_has_cursor(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		[GLib.Property ("n-axes")]
		public int NumAxes {
			get  {
				int raw_ret = gdk_device_get_n_axes(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

		[GLib.Property ("vendor-id")]
		public string VendorId {
			get  {
				IntPtr raw_ret = gdk_device_get_vendor_id(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
		}

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

		[GLib.Property ("product-id")]
		public string ProductId {
			get  {
				IntPtr raw_ret = gdk_device_get_product_id(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
		}

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

		[GLib.Property ("seat")]
		public Gdk.Seat Seat {
			get  {
				IntPtr raw_ret = gdk_device_get_seat(Handle);
				Gdk.Seat ret = GLib.Object.GetObject(raw_ret) as Gdk.Seat;
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("seat", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("num-touches")]
		public uint NumTouches {
			get {
				GLib.Value val = GetProperty ("num-touches");
				uint ret = (uint) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Property ("axes")]
		public Gdk.AxisFlags Axes {
			get  {
				int raw_ret = gdk_device_get_axes(Handle);
				Gdk.AxisFlags ret = (Gdk.AxisFlags) raw_ret;
				return ret;
			}
		}

		[GLib.Property ("tool")]
		public Gdk.DeviceTool Tool {
			get {
				GLib.Value val = GetProperty ("tool");
				Gdk.DeviceTool ret = (Gdk.DeviceTool) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Signal("tool-changed")]
		public event Gdk.ToolChangedHandler ToolChanged {
			add {
				this.AddSignalHandler ("tool-changed", value, typeof (Gdk.ToolChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("tool-changed", value);
			}
		}

		static ChangedNativeDelegate Changed_cb_delegate;
		static ChangedNativeDelegate ChangedVMCallback {
			get {
				if (Changed_cb_delegate == null)
					Changed_cb_delegate = new ChangedNativeDelegate (Changed_cb);
				return Changed_cb_delegate;
			}
		}

		static void OverrideChanged (GLib.GType gtype)
		{
			OverrideChanged (gtype, ChangedVMCallback);
		}

		static void OverrideChanged (GLib.GType gtype, ChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChangedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideChanged")]
		protected virtual void OnChanged ()
		{
			InternalChanged ();
		}

		private void InternalChanged ()
		{
			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 ToolChangedNativeDelegate ToolChanged_cb_delegate;
		static ToolChangedNativeDelegate ToolChangedVMCallback {
			get {
				if (ToolChanged_cb_delegate == null)
					ToolChanged_cb_delegate = new ToolChangedNativeDelegate (ToolChanged_cb);
				return ToolChanged_cb_delegate;
			}
		}

		static void OverrideToolChanged (GLib.GType gtype)
		{
			OverrideToolChanged (gtype, ToolChangedVMCallback);
		}

		static void OverrideToolChanged (GLib.GType gtype, ToolChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "tool-changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ToolChangedNativeDelegate (IntPtr inst, IntPtr p0);

		static void ToolChanged_cb (IntPtr inst, IntPtr p0)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				__obj.OnToolChanged (GLib.Object.GetObject(p0) as Gdk.DeviceTool);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideToolChanged")]
		protected virtual void OnToolChanged (Gdk.DeviceTool p0)
		{
			InternalToolChanged (p0);
		}

		private void InternalToolChanged (Gdk.DeviceTool 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 ();
		}

		static GetHistoryNativeDelegate GetHistory_cb_delegate;
		static GetHistoryNativeDelegate GetHistoryVMCallback {
			get {
				if (GetHistory_cb_delegate == null)
					GetHistory_cb_delegate = new GetHistoryNativeDelegate (GetHistory_cb);
				return GetHistory_cb_delegate;
			}
		}

		static void OverrideGetHistory (GLib.GType gtype)
		{
			OverrideGetHistory (gtype, GetHistoryVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GetHistoryNativeDelegate (IntPtr inst, IntPtr window, uint start, uint stop, IntPtr events, out int n_events);

		static bool GetHistory_cb (IntPtr inst, IntPtr window, uint start, uint stop, IntPtr events, out int n_events)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				bool __result;
				__result = __obj.OnGetHistory (GLib.Object.GetObject(window) as Gdk.Window, start, stop, Gdk.TimeCoord.New (events), out n_events);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideGetHistory")]
		protected virtual bool OnGetHistory (Gdk.Window window, uint start, uint stop, Gdk.TimeCoord events, out int n_events)
		{
			return InternalGetHistory (window, start, stop, events, out n_events);
		}

		private bool InternalGetHistory (Gdk.Window window, uint start, uint stop, Gdk.TimeCoord events, out int n_events)
		{
			GetHistoryNativeDelegate unmanaged = class_abi.BaseOverride<GetHistoryNativeDelegate>(this.LookupGType(), "get_history");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			IntPtr native_events = GLib.Marshaller.StructureToPtrAlloc (events);
			bool __result = unmanaged (this.Handle, window == null ? IntPtr.Zero : window.Handle, start, stop, native_events, out n_events);
			Marshal.FreeHGlobal (native_events);
			return __result;
		}

		static GetStateNativeDelegate GetState_cb_delegate;
		static GetStateNativeDelegate GetStateVMCallback {
			get {
				if (GetState_cb_delegate == null)
					GetState_cb_delegate = new GetStateNativeDelegate (GetState_cb);
				return GetState_cb_delegate;
			}
		}

		static void OverrideGetState (GLib.GType gtype)
		{
			OverrideGetState (gtype, GetStateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetStateNativeDelegate (IntPtr inst, IntPtr window, out double axes, out int mask);

		static void GetState_cb (IntPtr inst, IntPtr window, out double axes, out int mask)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				Gdk.ModifierType mymask;
				__obj.OnGetState (GLib.Object.GetObject(window) as Gdk.Window, out axes, out mymask);
				mask = (int) mymask;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideGetState")]
		protected virtual void OnGetState (Gdk.Window window, out double axes, out Gdk.ModifierType mask)
		{
			InternalGetState (window, out axes, out mask);
		}

		private void InternalGetState (Gdk.Window window, out double axes, out Gdk.ModifierType mask)
		{
			GetStateNativeDelegate unmanaged = class_abi.BaseOverride<GetStateNativeDelegate>(this.LookupGType(), "get_state");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_mask;
			unmanaged (this.Handle, window == null ? IntPtr.Zero : window.Handle, out axes, out native_mask);
			mask = (Gdk.ModifierType) native_mask;
		}

		static SetWindowCursorNativeDelegate SetWindowCursor_cb_delegate;
		static SetWindowCursorNativeDelegate SetWindowCursorVMCallback {
			get {
				if (SetWindowCursor_cb_delegate == null)
					SetWindowCursor_cb_delegate = new SetWindowCursorNativeDelegate (SetWindowCursor_cb);
				return SetWindowCursor_cb_delegate;
			}
		}

		static void OverrideSetWindowCursor (GLib.GType gtype)
		{
			OverrideSetWindowCursor (gtype, SetWindowCursorVMCallback);
		}

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

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

		static void SetWindowCursor_cb (IntPtr inst, IntPtr window, IntPtr cursor)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				__obj.OnSetWindowCursor (GLib.Object.GetObject(window) as Gdk.Window, GLib.Object.GetObject(cursor) as Gdk.Cursor);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideSetWindowCursor")]
		protected virtual void OnSetWindowCursor (Gdk.Window window, Gdk.Cursor cursor)
		{
			InternalSetWindowCursor (window, cursor);
		}

		private void InternalSetWindowCursor (Gdk.Window window, Gdk.Cursor cursor)
		{
			SetWindowCursorNativeDelegate unmanaged = class_abi.BaseOverride<SetWindowCursorNativeDelegate>(this.LookupGType(), "set_window_cursor");
			if (unmanaged == null) return;

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

		static WarpNativeDelegate Warp_cb_delegate;
		static WarpNativeDelegate WarpVMCallback {
			get {
				if (Warp_cb_delegate == null)
					Warp_cb_delegate = new WarpNativeDelegate (Warp_cb);
				return Warp_cb_delegate;
			}
		}

		static void OverrideWarp (GLib.GType gtype)
		{
			OverrideWarp (gtype, WarpVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void WarpNativeDelegate (IntPtr inst, IntPtr screen, double x, double y);

		static void Warp_cb (IntPtr inst, IntPtr screen, double x, double y)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				__obj.OnWarp (GLib.Object.GetObject(screen) as Gdk.Screen, x, y);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideWarp")]
		protected virtual void OnWarp (Gdk.Screen screen, double x, double y)
		{
			InternalWarp (screen, x, y);
		}

		private void InternalWarp (Gdk.Screen screen, double x, double y)
		{
			WarpNativeDelegate unmanaged = class_abi.BaseOverride<WarpNativeDelegate>(this.LookupGType(), "warp");
			if (unmanaged == null) return;

			unmanaged (this.Handle, screen == null ? IntPtr.Zero : screen.Handle, x, y);
		}

		static QueryStateNativeDelegate QueryState_cb_delegate;
		static QueryStateNativeDelegate QueryStateVMCallback {
			get {
				if (QueryState_cb_delegate == null)
					QueryState_cb_delegate = new QueryStateNativeDelegate (QueryState_cb);
				return QueryState_cb_delegate;
			}
		}

		static void OverrideQueryState (GLib.GType gtype)
		{
			OverrideQueryState (gtype, QueryStateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void QueryStateNativeDelegate (IntPtr inst, IntPtr window, IntPtr root_window, IntPtr child_window, out double root_x, out double root_y, out double win_x, out double win_y, out int mask);

		static void QueryState_cb (IntPtr inst, IntPtr window, IntPtr root_window, IntPtr child_window, out double root_x, out double root_y, out double win_x, out double win_y, out int mask)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				Gdk.ModifierType mymask;
				__obj.OnQueryState (GLib.Object.GetObject(window) as Gdk.Window, GLib.Object.GetObject(root_window) as Gdk.Window, GLib.Object.GetObject(child_window) as Gdk.Window, out root_x, out root_y, out win_x, out win_y, out mymask);
				mask = (int) mymask;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideQueryState")]
		protected virtual void OnQueryState (Gdk.Window window, Gdk.Window root_window, Gdk.Window child_window, out double root_x, out double root_y, out double win_x, out double win_y, out Gdk.ModifierType mask)
		{
			InternalQueryState (window, root_window, child_window, out root_x, out root_y, out win_x, out win_y, out mask);
		}

		private void InternalQueryState (Gdk.Window window, Gdk.Window root_window, Gdk.Window child_window, out double root_x, out double root_y, out double win_x, out double win_y, out Gdk.ModifierType mask)
		{
			QueryStateNativeDelegate unmanaged = class_abi.BaseOverride<QueryStateNativeDelegate>(this.LookupGType(), "query_state");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_mask;
			unmanaged (this.Handle, window == null ? IntPtr.Zero : window.Handle, root_window == null ? IntPtr.Zero : root_window.Handle, child_window == null ? IntPtr.Zero : child_window.Handle, out root_x, out root_y, out win_x, out win_y, out native_mask);
			mask = (Gdk.ModifierType) native_mask;
		}

		static GrabNativeDelegate Grab_cb_delegate;
		static GrabNativeDelegate GrabVMCallback {
			get {
				if (Grab_cb_delegate == null)
					Grab_cb_delegate = new GrabNativeDelegate (Grab_cb);
				return Grab_cb_delegate;
			}
		}

		static void OverrideGrab (GLib.GType gtype)
		{
			OverrideGrab (gtype, GrabVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GrabNativeDelegate (IntPtr inst, IntPtr window, bool owner_events, int event_mask, IntPtr confine_to, IntPtr cursor, uint time_);

		static int Grab_cb (IntPtr inst, IntPtr window, bool owner_events, int event_mask, IntPtr confine_to, IntPtr cursor, uint time_)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				Gdk.GrabStatus __result;
				__result = __obj.OnGrab (GLib.Object.GetObject(window) as Gdk.Window, owner_events, (Gdk.EventMask) event_mask, GLib.Object.GetObject(confine_to) as Gdk.Window, GLib.Object.GetObject(cursor) as Gdk.Cursor, time_);
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideGrab")]
		protected virtual Gdk.GrabStatus OnGrab (Gdk.Window window, bool owner_events, Gdk.EventMask event_mask, Gdk.Window confine_to, Gdk.Cursor cursor, uint time_)
		{
			return InternalGrab (window, owner_events, event_mask, confine_to, cursor, time_);
		}

		private Gdk.GrabStatus InternalGrab (Gdk.Window window, bool owner_events, Gdk.EventMask event_mask, Gdk.Window confine_to, Gdk.Cursor cursor, uint time_)
		{
			GrabNativeDelegate unmanaged = class_abi.BaseOverride<GrabNativeDelegate>(this.LookupGType(), "grab");
			if (unmanaged == null) return (Gdk.GrabStatus) 0;

			int __result = unmanaged (this.Handle, window == null ? IntPtr.Zero : window.Handle, owner_events, (int) event_mask, confine_to == null ? IntPtr.Zero : confine_to.Handle, cursor == null ? IntPtr.Zero : cursor.Handle, time_);
			return (Gdk.GrabStatus) __result;
		}

		static UngrabNativeDelegate Ungrab_cb_delegate;
		static UngrabNativeDelegate UngrabVMCallback {
			get {
				if (Ungrab_cb_delegate == null)
					Ungrab_cb_delegate = new UngrabNativeDelegate (Ungrab_cb);
				return Ungrab_cb_delegate;
			}
		}

		static void OverrideUngrab (GLib.GType gtype)
		{
			OverrideUngrab (gtype, UngrabVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void UngrabNativeDelegate (IntPtr inst, uint time_);

		static void Ungrab_cb (IntPtr inst, uint time_)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				__obj.OnUngrab (time_);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideUngrab")]
		protected virtual void OnUngrab (uint time_)
		{
			InternalUngrab (time_);
		}

		private void InternalUngrab (uint time_)
		{
			UngrabNativeDelegate unmanaged = class_abi.BaseOverride<UngrabNativeDelegate>(this.LookupGType(), "ungrab");
			if (unmanaged == null) return;

			unmanaged (this.Handle, time_);
		}

		static WindowAtPositionNativeDelegate WindowAtPosition_cb_delegate;
		static WindowAtPositionNativeDelegate WindowAtPositionVMCallback {
			get {
				if (WindowAtPosition_cb_delegate == null)
					WindowAtPosition_cb_delegate = new WindowAtPositionNativeDelegate (WindowAtPosition_cb);
				return WindowAtPosition_cb_delegate;
			}
		}

		static void OverrideWindowAtPosition (GLib.GType gtype)
		{
			OverrideWindowAtPosition (gtype, WindowAtPositionVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr WindowAtPositionNativeDelegate (IntPtr inst, out double win_x, out double win_y, out int mask, bool get_toplevel);

		static IntPtr WindowAtPosition_cb (IntPtr inst, out double win_x, out double win_y, out int mask, bool get_toplevel)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				Gdk.Window __result;
				Gdk.ModifierType mymask;
				__result = __obj.OnWindowAtPosition (out win_x, out win_y, out mymask, get_toplevel);
				mask = (int) mymask;
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideWindowAtPosition")]
		protected virtual Gdk.Window OnWindowAtPosition (out double win_x, out double win_y, out Gdk.ModifierType mask, bool get_toplevel)
		{
			return InternalWindowAtPosition (out win_x, out win_y, out mask, get_toplevel);
		}

		private Gdk.Window InternalWindowAtPosition (out double win_x, out double win_y, out Gdk.ModifierType mask, bool get_toplevel)
		{
			WindowAtPositionNativeDelegate unmanaged = class_abi.BaseOverride<WindowAtPositionNativeDelegate>(this.LookupGType(), "window_at_position");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_mask;
			IntPtr __result = unmanaged (this.Handle, out win_x, out win_y, out native_mask, get_toplevel);
			mask = (Gdk.ModifierType) native_mask;
			return GLib.Object.GetObject(__result) as Gdk.Window;
		}

		static SelectWindowEventsNativeDelegate SelectWindowEvents_cb_delegate;
		static SelectWindowEventsNativeDelegate SelectWindowEventsVMCallback {
			get {
				if (SelectWindowEvents_cb_delegate == null)
					SelectWindowEvents_cb_delegate = new SelectWindowEventsNativeDelegate (SelectWindowEvents_cb);
				return SelectWindowEvents_cb_delegate;
			}
		}

		static void OverrideSelectWindowEvents (GLib.GType gtype)
		{
			OverrideSelectWindowEvents (gtype, SelectWindowEventsVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SelectWindowEventsNativeDelegate (IntPtr inst, IntPtr window, int event_mask);

		static void SelectWindowEvents_cb (IntPtr inst, IntPtr window, int event_mask)
		{
			try {
				Device __obj = GLib.Object.GetObject (inst, false) as Device;
				__obj.OnSelectWindowEvents (GLib.Object.GetObject(window) as Gdk.Window, (Gdk.EventMask) event_mask);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Device), ConnectionMethod="OverrideSelectWindowEvents")]
		protected virtual void OnSelectWindowEvents (Gdk.Window window, Gdk.EventMask event_mask)
		{
			InternalSelectWindowEvents (window, event_mask);
		}

		private void InternalSelectWindowEvents (Gdk.Window window, Gdk.EventMask event_mask)
		{
			SelectWindowEventsNativeDelegate unmanaged = class_abi.BaseOverride<SelectWindowEventsNativeDelegate>(this.LookupGType(), "select_window_events");
			if (unmanaged == null) return;

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


		// 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_history"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // get_history
							, null
							, "get_state"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_state"
							, -1
							, (uint) sizeof( IntPtr ) // get_state
							, "get_history"
							, "set_window_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_window_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // set_window_cursor
							, "get_state"
							, "warp"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("warp"
							, -1
							, (uint) sizeof( IntPtr ) // warp
							, "set_window_cursor"
							, "query_state"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("query_state"
							, -1
							, (uint) sizeof( IntPtr ) // query_state
							, "warp"
							, "grab"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("grab"
							, -1
							, (uint) sizeof( IntPtr ) // grab
							, "query_state"
							, "ungrab"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("ungrab"
							, -1
							, (uint) sizeof( IntPtr ) // ungrab
							, "grab"
							, "window_at_position"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("window_at_position"
							, -1
							, (uint) sizeof( IntPtr ) // window_at_position
							, "ungrab"
							, "select_window_events"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("select_window_events"
							, -1
							, (uint) sizeof( IntPtr ) // select_window_events
							, "window_at_position"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_device_get_axis(IntPtr raw, double[] axes, int use, out double value);
		static d_gdk_device_get_axis gdk_device_get_axis = FuncLoader.LoadFunction<d_gdk_device_get_axis>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_axis"));

		public bool GetAxis(double[] axes, Gdk.AxisUse use, out double value) {
			bool raw_ret = gdk_device_get_axis(Handle, axes, (int) use, out value);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gdk.AxisUse GetAxisUse(uint index_) {
			int raw_ret = gdk_device_get_axis_use(Handle, index_);
			Gdk.AxisUse ret = (Gdk.AxisUse) raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_device_get_axis_value(IntPtr raw, out double axes, IntPtr axis_label, out double value);
		static d_gdk_device_get_axis_value gdk_device_get_axis_value = FuncLoader.LoadFunction<d_gdk_device_get_axis_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_axis_value"));

		public bool GetAxisValue(out double axes, Gdk.Atom axis_label, out double value) {
			bool raw_ret = gdk_device_get_axis_value(Handle, out axes, axis_label == null ? IntPtr.Zero : axis_label.Handle, out value);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gdk.DeviceType DeviceType { 
			get {
				int raw_ret = gdk_device_get_device_type(Handle);
				Gdk.DeviceType ret = (Gdk.DeviceType) raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_device_get_key(IntPtr raw, uint index_, out uint keyval, out int modifiers);
		static d_gdk_device_get_key gdk_device_get_key = FuncLoader.LoadFunction<d_gdk_device_get_key>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_key"));

		public bool GetKey(uint index_, out uint keyval, out Gdk.ModifierType modifiers) {
			int native_modifiers;
			bool raw_ret = gdk_device_get_key(Handle, index_, out keyval, out native_modifiers);
			bool ret = raw_ret;
			modifiers = (Gdk.ModifierType) native_modifiers;
			return ret;
		}

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

		public Gdk.Window LastEventWindow { 
			get {
				IntPtr raw_ret = gdk_device_get_last_event_window(Handle);
				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
				return ret;
			}
		}

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

		public Gdk.InputMode Mode { 
			get {
				int raw_ret = gdk_device_get_mode(Handle);
				Gdk.InputMode ret = (Gdk.InputMode) raw_ret;
				return ret;
			}
		}

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

		public int NKeys { 
			get {
				int raw_ret = gdk_device_get_n_keys(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_device_get_position(IntPtr raw, IntPtr screen, out int x, out int y);
		static d_gdk_device_get_position gdk_device_get_position = FuncLoader.LoadFunction<d_gdk_device_get_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_position"));

		public void GetPosition(Gdk.Screen screen, out int x, out int y) {
			gdk_device_get_position(Handle, screen == null ? IntPtr.Zero : screen.Handle, out x, out y);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_device_get_position_double(IntPtr raw, IntPtr screen, out double x, out double y);
		static d_gdk_device_get_position_double gdk_device_get_position_double = FuncLoader.LoadFunction<d_gdk_device_get_position_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_position_double"));

		public void GetPositionDouble(Gdk.Screen screen, out double x, out double y) {
			gdk_device_get_position_double(Handle, screen == null ? IntPtr.Zero : screen.Handle, out x, out y);
		}

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

		public Gdk.InputSource Source { 
			get {
				int raw_ret = gdk_device_get_source(Handle);
				Gdk.InputSource ret = (Gdk.InputSource) raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_device_get_state(IntPtr raw, IntPtr window, out double axes, out int mask);
		static d_gdk_device_get_state gdk_device_get_state = FuncLoader.LoadFunction<d_gdk_device_get_state>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_state"));

		public void GetState(Gdk.Window window, out double axes, out Gdk.ModifierType mask) {
			int native_mask;
			gdk_device_get_state(Handle, window == null ? IntPtr.Zero : window.Handle, out axes, out native_mask);
			mask = (Gdk.ModifierType) native_mask;
		}

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_device_get_window_at_position(IntPtr raw, out int win_x, out int win_y);
		static d_gdk_device_get_window_at_position gdk_device_get_window_at_position = FuncLoader.LoadFunction<d_gdk_device_get_window_at_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_window_at_position"));

		public Gdk.Window GetWindowAtPosition(out int win_x, out int win_y) {
			IntPtr raw_ret = gdk_device_get_window_at_position(Handle, out win_x, out win_y);
			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_device_get_window_at_position_double(IntPtr raw, out double win_x, out double win_y);
		static d_gdk_device_get_window_at_position_double gdk_device_get_window_at_position_double = FuncLoader.LoadFunction<d_gdk_device_get_window_at_position_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_window_at_position_double"));

		public Gdk.Window GetWindowAtPositionDouble(out double win_x, out double win_y) {
			IntPtr raw_ret = gdk_device_get_window_at_position_double(Handle, out win_x, out win_y);
			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gdk_device_grab(IntPtr raw, IntPtr window, int grab_ownership, bool owner_events, int event_mask, IntPtr cursor, uint time_);
		static d_gdk_device_grab gdk_device_grab = FuncLoader.LoadFunction<d_gdk_device_grab>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_grab"));

		[Obsolete]
		public Gdk.GrabStatus Grab(Gdk.Window window, Gdk.GrabOwnership grab_ownership, bool owner_events, Gdk.EventMask event_mask, Gdk.Cursor cursor, uint time_) {
			int raw_ret = gdk_device_grab(Handle, window == null ? IntPtr.Zero : window.Handle, (int) grab_ownership, owner_events, (int) event_mask, cursor == null ? IntPtr.Zero : cursor.Handle, time_);
			Gdk.GrabStatus ret = (Gdk.GrabStatus) raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gdk_device_grab_info_libgtk_only(IntPtr display, IntPtr device, IntPtr grab_window, out bool owner_events);
		static d_gdk_device_grab_info_libgtk_only gdk_device_grab_info_libgtk_only = FuncLoader.LoadFunction<d_gdk_device_grab_info_libgtk_only>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_grab_info_libgtk_only"));

		[Obsolete]
		public static bool GrabInfoLibgtkOnly(Gdk.Display display, Gdk.Device device, Gdk.Window grab_window, out bool owner_events) {
			bool raw_ret = gdk_device_grab_info_libgtk_only(display == null ? IntPtr.Zero : display.Handle, device == null ? IntPtr.Zero : device.Handle, grab_window == null ? IntPtr.Zero : grab_window.Handle, out owner_events);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gdk.Atom[] ListAxes() {
			IntPtr raw_ret = gdk_device_list_axes(Handle);
			Gdk.Atom[] ret = GLib.Marshaller.ListPtrToArray<Gdk.Atom, Gdk.Atom> (raw_ret, true, false);
			return ret;
		}

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

		public Gdk.Device[] ListSlaveDevices() {
			IntPtr raw_ret = gdk_device_list_slave_devices(Handle);
			Gdk.Device[] ret = GLib.Marshaller.ListPtrToArray<Gdk.Device, Gdk.Device> (raw_ret, true, false);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_device_set_axis_use(IntPtr raw, uint index_, int use);
		static d_gdk_device_set_axis_use gdk_device_set_axis_use = FuncLoader.LoadFunction<d_gdk_device_set_axis_use>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_set_axis_use"));

		public void SetAxisUse(uint index_, Gdk.AxisUse use) {
			gdk_device_set_axis_use(Handle, index_, (int) use);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_device_set_key(IntPtr raw, uint index_, uint keyval, int modifiers);
		static d_gdk_device_set_key gdk_device_set_key = FuncLoader.LoadFunction<d_gdk_device_set_key>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_set_key"));

		public void SetKey(uint index_, uint keyval, Gdk.ModifierType modifiers) {
			gdk_device_set_key(Handle, index_, keyval, (int) modifiers);
		}

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

		public bool SetMode(Gdk.InputMode mode) {
			bool raw_ret = gdk_device_set_mode(Handle, (int) mode);
			bool ret = raw_ret;
			return ret;
		}

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

		[Obsolete]
		public void Ungrab(uint time_) {
			gdk_device_ungrab(Handle, time_);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_device_warp(IntPtr raw, IntPtr screen, int x, int y);
		static d_gdk_device_warp gdk_device_warp = FuncLoader.LoadFunction<d_gdk_device_warp>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_warp"));

		public void Warp(Gdk.Screen screen, int x, int y) {
			gdk_device_warp(Handle, screen == null ? IntPtr.Zero : screen.Handle, x, y);
		}


		// 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
	}
}
