KioskApp/GtkSharp/Source/Libs/GdkSharp/Generated/Gdk/Display.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 Display : GLib.Object {

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

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

		[GLib.Signal("seat-removed")]
		public event Gdk.SeatRemovedHandler SeatRemoved {
			add {
				this.AddSignalHandler ("seat-removed", value, typeof (Gdk.SeatRemovedArgs));
			}
			remove {
				this.RemoveSignalHandler ("seat-removed", value);
			}
		}

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

		[GLib.Signal("monitor-added")]
		public event Gdk.MonitorAddedHandler MonitorAdded {
			add {
				this.AddSignalHandler ("monitor-added", value, typeof (Gdk.MonitorAddedArgs));
			}
			remove {
				this.RemoveSignalHandler ("monitor-added", value);
			}
		}

		[GLib.Signal("seat-added")]
		public event Gdk.SeatAddedHandler SeatAdded {
			add {
				this.AddSignalHandler ("seat-added", value, typeof (Gdk.SeatAddedArgs));
			}
			remove {
				this.RemoveSignalHandler ("seat-added", value);
			}
		}

		[GLib.Signal("monitor-removed")]
		public event Gdk.MonitorRemovedHandler MonitorRemoved {
			add {
				this.AddSignalHandler ("monitor-removed", value, typeof (Gdk.MonitorRemovedArgs));
			}
			remove {
				this.RemoveSignalHandler ("monitor-removed", value);
			}
		}

		[GLib.Signal("closed")]
		public event Gdk.ClosedHandler Closed {
			add {
				this.AddSignalHandler ("closed", value, typeof (Gdk.ClosedArgs));
			}
			remove {
				this.RemoveSignalHandler ("closed", value);
			}
		}

		static SeatAddedNativeDelegate SeatAdded_cb_delegate;
		static SeatAddedNativeDelegate SeatAddedVMCallback {
			get {
				if (SeatAdded_cb_delegate == null)
					SeatAdded_cb_delegate = new SeatAddedNativeDelegate (SeatAdded_cb);
				return SeatAdded_cb_delegate;
			}
		}

		static void OverrideSeatAdded (GLib.GType gtype)
		{
			OverrideSeatAdded (gtype, SeatAddedVMCallback);
		}

		static void OverrideSeatAdded (GLib.GType gtype, SeatAddedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "seat-added", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SeatAddedNativeDelegate (IntPtr inst, IntPtr p0);

		static void SeatAdded_cb (IntPtr inst, IntPtr p0)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnSeatAdded (GLib.Object.GetObject(p0) as Gdk.Seat);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSeatAdded")]
		protected virtual void OnSeatAdded (Gdk.Seat p0)
		{
			InternalSeatAdded (p0);
		}

		private void InternalSeatAdded (Gdk.Seat 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 SeatRemovedNativeDelegate SeatRemoved_cb_delegate;
		static SeatRemovedNativeDelegate SeatRemovedVMCallback {
			get {
				if (SeatRemoved_cb_delegate == null)
					SeatRemoved_cb_delegate = new SeatRemovedNativeDelegate (SeatRemoved_cb);
				return SeatRemoved_cb_delegate;
			}
		}

		static void OverrideSeatRemoved (GLib.GType gtype)
		{
			OverrideSeatRemoved (gtype, SeatRemovedVMCallback);
		}

		static void OverrideSeatRemoved (GLib.GType gtype, SeatRemovedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "seat-removed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SeatRemovedNativeDelegate (IntPtr inst, IntPtr p0);

		static void SeatRemoved_cb (IntPtr inst, IntPtr p0)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnSeatRemoved (GLib.Object.GetObject(p0) as Gdk.Seat);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSeatRemoved")]
		protected virtual void OnSeatRemoved (Gdk.Seat p0)
		{
			InternalSeatRemoved (p0);
		}

		private void InternalSeatRemoved (Gdk.Seat 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 MonitorAddedNativeDelegate MonitorAdded_cb_delegate;
		static MonitorAddedNativeDelegate MonitorAddedVMCallback {
			get {
				if (MonitorAdded_cb_delegate == null)
					MonitorAdded_cb_delegate = new MonitorAddedNativeDelegate (MonitorAdded_cb);
				return MonitorAdded_cb_delegate;
			}
		}

		static void OverrideMonitorAdded (GLib.GType gtype)
		{
			OverrideMonitorAdded (gtype, MonitorAddedVMCallback);
		}

		static void OverrideMonitorAdded (GLib.GType gtype, MonitorAddedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "monitor-added", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MonitorAddedNativeDelegate (IntPtr inst, IntPtr p0);

		static void MonitorAdded_cb (IntPtr inst, IntPtr p0)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnMonitorAdded (GLib.Object.GetObject(p0) as Gdk.Monitor);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideMonitorAdded")]
		protected virtual void OnMonitorAdded (Gdk.Monitor p0)
		{
			InternalMonitorAdded (p0);
		}

		private void InternalMonitorAdded (Gdk.Monitor 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 MonitorRemovedNativeDelegate MonitorRemoved_cb_delegate;
		static MonitorRemovedNativeDelegate MonitorRemovedVMCallback {
			get {
				if (MonitorRemoved_cb_delegate == null)
					MonitorRemoved_cb_delegate = new MonitorRemovedNativeDelegate (MonitorRemoved_cb);
				return MonitorRemoved_cb_delegate;
			}
		}

		static void OverrideMonitorRemoved (GLib.GType gtype)
		{
			OverrideMonitorRemoved (gtype, MonitorRemovedVMCallback);
		}

		static void OverrideMonitorRemoved (GLib.GType gtype, MonitorRemovedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "monitor-removed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MonitorRemovedNativeDelegate (IntPtr inst, IntPtr p0);

		static void MonitorRemoved_cb (IntPtr inst, IntPtr p0)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnMonitorRemoved (GLib.Object.GetObject(p0) as Gdk.Monitor);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideMonitorRemoved")]
		protected virtual void OnMonitorRemoved (Gdk.Monitor p0)
		{
			InternalMonitorRemoved (p0);
		}

		private void InternalMonitorRemoved (Gdk.Monitor 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 GetNameNativeDelegate GetName_cb_delegate;
		static GetNameNativeDelegate GetNameVMCallback {
			get {
				if (GetName_cb_delegate == null)
					GetName_cb_delegate = new GetNameNativeDelegate (GetName_cb);
				return GetName_cb_delegate;
			}
		}

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

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

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

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

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

		private string InternalGetName ()
		{
			GetNameNativeDelegate unmanaged = class_abi.BaseOverride<GetNameNativeDelegate>(this.LookupGType(), "get_name");
			if (unmanaged == null) return null;

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

		static GetDefaultScreenNativeDelegate GetDefaultScreen_cb_delegate;
		static GetDefaultScreenNativeDelegate GetDefaultScreenVMCallback {
			get {
				if (GetDefaultScreen_cb_delegate == null)
					GetDefaultScreen_cb_delegate = new GetDefaultScreenNativeDelegate (GetDefaultScreen_cb);
				return GetDefaultScreen_cb_delegate;
			}
		}

		static void OverrideGetDefaultScreen (GLib.GType gtype)
		{
			OverrideGetDefaultScreen (gtype, GetDefaultScreenVMCallback);
		}

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

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

		static IntPtr GetDefaultScreen_cb (IntPtr inst)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Screen __result;
				__result = __obj.OnGetDefaultScreen ();
				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.Display), ConnectionMethod="OverrideGetDefaultScreen")]
		protected virtual Gdk.Screen OnGetDefaultScreen ()
		{
			return InternalGetDefaultScreen ();
		}

		private Gdk.Screen InternalGetDefaultScreen ()
		{
			GetDefaultScreenNativeDelegate unmanaged = class_abi.BaseOverride<GetDefaultScreenNativeDelegate>(this.LookupGType(), "get_default_screen");
			if (unmanaged == null) return null;

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

		static BeepNativeDelegate Beep_cb_delegate;
		static BeepNativeDelegate BeepVMCallback {
			get {
				if (Beep_cb_delegate == null)
					Beep_cb_delegate = new BeepNativeDelegate (Beep_cb);
				return Beep_cb_delegate;
			}
		}

		static void OverrideBeep (GLib.GType gtype)
		{
			OverrideBeep (gtype, BeepVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideBeep")]
		protected virtual void OnBeep ()
		{
			InternalBeep ();
		}

		private void InternalBeep ()
		{
			BeepNativeDelegate unmanaged = class_abi.BaseOverride<BeepNativeDelegate>(this.LookupGType(), "beep");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static SyncNativeDelegate Sync_cb_delegate;
		static SyncNativeDelegate SyncVMCallback {
			get {
				if (Sync_cb_delegate == null)
					Sync_cb_delegate = new SyncNativeDelegate (Sync_cb);
				return Sync_cb_delegate;
			}
		}

		static void OverrideSync (GLib.GType gtype)
		{
			OverrideSync (gtype, SyncVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSync")]
		protected virtual void OnSync ()
		{
			InternalSync ();
		}

		private void InternalSync ()
		{
			SyncNativeDelegate unmanaged = class_abi.BaseOverride<SyncNativeDelegate>(this.LookupGType(), "sync");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static FlushNativeDelegate Flush_cb_delegate;
		static FlushNativeDelegate FlushVMCallback {
			get {
				if (Flush_cb_delegate == null)
					Flush_cb_delegate = new FlushNativeDelegate (Flush_cb);
				return Flush_cb_delegate;
			}
		}

		static void OverrideFlush (GLib.GType gtype)
		{
			OverrideFlush (gtype, FlushVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideFlush")]
		protected virtual void OnFlush ()
		{
			InternalFlush ();
		}

		private void InternalFlush ()
		{
			FlushNativeDelegate unmanaged = class_abi.BaseOverride<FlushNativeDelegate>(this.LookupGType(), "flush");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static HasPendingNativeDelegate HasPending_cb_delegate;
		static HasPendingNativeDelegate HasPendingVMCallback {
			get {
				if (HasPending_cb_delegate == null)
					HasPending_cb_delegate = new HasPendingNativeDelegate (HasPending_cb);
				return HasPending_cb_delegate;
			}
		}

		static void OverrideHasPending (GLib.GType gtype)
		{
			OverrideHasPending (gtype, HasPendingVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideHasPending")]
		protected virtual bool OnHasPending ()
		{
			return InternalHasPending ();
		}

		private bool InternalHasPending ()
		{
			HasPendingNativeDelegate unmanaged = class_abi.BaseOverride<HasPendingNativeDelegate>(this.LookupGType(), "has_pending");
			if (unmanaged == null) return false;

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

		static QueueEventsNativeDelegate QueueEvents_cb_delegate;
		static QueueEventsNativeDelegate QueueEventsVMCallback {
			get {
				if (QueueEvents_cb_delegate == null)
					QueueEvents_cb_delegate = new QueueEventsNativeDelegate (QueueEvents_cb);
				return QueueEvents_cb_delegate;
			}
		}

		static void OverrideQueueEvents (GLib.GType gtype)
		{
			OverrideQueueEvents (gtype, QueueEventsVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideQueueEvents")]
		protected virtual void OnQueueEvents ()
		{
			InternalQueueEvents ();
		}

		private void InternalQueueEvents ()
		{
			QueueEventsNativeDelegate unmanaged = class_abi.BaseOverride<QueueEventsNativeDelegate>(this.LookupGType(), "queue_events");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static MakeDefaultNativeDelegate MakeDefault_cb_delegate;
		static MakeDefaultNativeDelegate MakeDefaultVMCallback {
			get {
				if (MakeDefault_cb_delegate == null)
					MakeDefault_cb_delegate = new MakeDefaultNativeDelegate (MakeDefault_cb);
				return MakeDefault_cb_delegate;
			}
		}

		static void OverrideMakeDefault (GLib.GType gtype)
		{
			OverrideMakeDefault (gtype, MakeDefaultVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideMakeDefault")]
		protected virtual void OnMakeDefault ()
		{
			InternalMakeDefault ();
		}

		private void InternalMakeDefault ()
		{
			MakeDefaultNativeDelegate unmanaged = class_abi.BaseOverride<MakeDefaultNativeDelegate>(this.LookupGType(), "make_default");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static GetDefaultGroupNativeDelegate GetDefaultGroup_cb_delegate;
		static GetDefaultGroupNativeDelegate GetDefaultGroupVMCallback {
			get {
				if (GetDefaultGroup_cb_delegate == null)
					GetDefaultGroup_cb_delegate = new GetDefaultGroupNativeDelegate (GetDefaultGroup_cb);
				return GetDefaultGroup_cb_delegate;
			}
		}

		static void OverrideGetDefaultGroup (GLib.GType gtype)
		{
			OverrideGetDefaultGroup (gtype, GetDefaultGroupVMCallback);
		}

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

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

		static IntPtr GetDefaultGroup_cb (IntPtr inst)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Window __result;
				__result = __obj.OnGetDefaultGroup ();
				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.Display), ConnectionMethod="OverrideGetDefaultGroup")]
		protected virtual Gdk.Window OnGetDefaultGroup ()
		{
			return InternalGetDefaultGroup ();
		}

		private Gdk.Window InternalGetDefaultGroup ()
		{
			GetDefaultGroupNativeDelegate unmanaged = class_abi.BaseOverride<GetDefaultGroupNativeDelegate>(this.LookupGType(), "get_default_group");
			if (unmanaged == null) return null;

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

		static SupportsSelectionNotificationNativeDelegate SupportsSelectionNotification_cb_delegate;
		static SupportsSelectionNotificationNativeDelegate SupportsSelectionNotificationVMCallback {
			get {
				if (SupportsSelectionNotification_cb_delegate == null)
					SupportsSelectionNotification_cb_delegate = new SupportsSelectionNotificationNativeDelegate (SupportsSelectionNotification_cb);
				return SupportsSelectionNotification_cb_delegate;
			}
		}

		static void OverrideSupportsSelectionNotification (GLib.GType gtype)
		{
			OverrideSupportsSelectionNotification (gtype, SupportsSelectionNotificationVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSupportsSelectionNotification")]
		protected virtual bool OnSupportsSelectionNotification ()
		{
			return InternalSupportsSelectionNotification ();
		}

		private bool InternalSupportsSelectionNotification ()
		{
			SupportsSelectionNotificationNativeDelegate unmanaged = class_abi.BaseOverride<SupportsSelectionNotificationNativeDelegate>(this.LookupGType(), "supports_selection_notification");
			if (unmanaged == null) return false;

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

		static RequestSelectionNotificationNativeDelegate RequestSelectionNotification_cb_delegate;
		static RequestSelectionNotificationNativeDelegate RequestSelectionNotificationVMCallback {
			get {
				if (RequestSelectionNotification_cb_delegate == null)
					RequestSelectionNotification_cb_delegate = new RequestSelectionNotificationNativeDelegate (RequestSelectionNotification_cb);
				return RequestSelectionNotification_cb_delegate;
			}
		}

		static void OverrideRequestSelectionNotification (GLib.GType gtype)
		{
			OverrideRequestSelectionNotification (gtype, RequestSelectionNotificationVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool RequestSelectionNotificationNativeDelegate (IntPtr inst, IntPtr selection);

		static bool RequestSelectionNotification_cb (IntPtr inst, IntPtr selection)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				bool __result;
				__result = __obj.OnRequestSelectionNotification (selection == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (selection, typeof (Gdk.Atom), false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideRequestSelectionNotification")]
		protected virtual bool OnRequestSelectionNotification (Gdk.Atom selection)
		{
			return InternalRequestSelectionNotification (selection);
		}

		private bool InternalRequestSelectionNotification (Gdk.Atom selection)
		{
			RequestSelectionNotificationNativeDelegate unmanaged = class_abi.BaseOverride<RequestSelectionNotificationNativeDelegate>(this.LookupGType(), "request_selection_notification");
			if (unmanaged == null) return false;

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

		static SupportsShapesNativeDelegate SupportsShapes_cb_delegate;
		static SupportsShapesNativeDelegate SupportsShapesVMCallback {
			get {
				if (SupportsShapes_cb_delegate == null)
					SupportsShapes_cb_delegate = new SupportsShapesNativeDelegate (SupportsShapes_cb);
				return SupportsShapes_cb_delegate;
			}
		}

		static void OverrideSupportsShapes (GLib.GType gtype)
		{
			OverrideSupportsShapes (gtype, SupportsShapesVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSupportsShapes")]
		protected virtual bool OnSupportsShapes ()
		{
			return InternalSupportsShapes ();
		}

		private bool InternalSupportsShapes ()
		{
			SupportsShapesNativeDelegate unmanaged = class_abi.BaseOverride<SupportsShapesNativeDelegate>(this.LookupGType(), "supports_shapes");
			if (unmanaged == null) return false;

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

		static SupportsInputShapesNativeDelegate SupportsInputShapes_cb_delegate;
		static SupportsInputShapesNativeDelegate SupportsInputShapesVMCallback {
			get {
				if (SupportsInputShapes_cb_delegate == null)
					SupportsInputShapes_cb_delegate = new SupportsInputShapesNativeDelegate (SupportsInputShapes_cb);
				return SupportsInputShapes_cb_delegate;
			}
		}

		static void OverrideSupportsInputShapes (GLib.GType gtype)
		{
			OverrideSupportsInputShapes (gtype, SupportsInputShapesVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSupportsInputShapes")]
		protected virtual bool OnSupportsInputShapes ()
		{
			return InternalSupportsInputShapes ();
		}

		private bool InternalSupportsInputShapes ()
		{
			SupportsInputShapesNativeDelegate unmanaged = class_abi.BaseOverride<SupportsInputShapesNativeDelegate>(this.LookupGType(), "supports_input_shapes");
			if (unmanaged == null) return false;

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

		static SupportsCompositeNativeDelegate SupportsComposite_cb_delegate;
		static SupportsCompositeNativeDelegate SupportsCompositeVMCallback {
			get {
				if (SupportsComposite_cb_delegate == null)
					SupportsComposite_cb_delegate = new SupportsCompositeNativeDelegate (SupportsComposite_cb);
				return SupportsComposite_cb_delegate;
			}
		}

		static void OverrideSupportsComposite (GLib.GType gtype)
		{
			OverrideSupportsComposite (gtype, SupportsCompositeVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSupportsComposite")]
		protected virtual bool OnSupportsComposite ()
		{
			return InternalSupportsComposite ();
		}

		private bool InternalSupportsComposite ()
		{
			SupportsCompositeNativeDelegate unmanaged = class_abi.BaseOverride<SupportsCompositeNativeDelegate>(this.LookupGType(), "supports_composite");
			if (unmanaged == null) return false;

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

		static SupportsCursorAlphaNativeDelegate SupportsCursorAlpha_cb_delegate;
		static SupportsCursorAlphaNativeDelegate SupportsCursorAlphaVMCallback {
			get {
				if (SupportsCursorAlpha_cb_delegate == null)
					SupportsCursorAlpha_cb_delegate = new SupportsCursorAlphaNativeDelegate (SupportsCursorAlpha_cb);
				return SupportsCursorAlpha_cb_delegate;
			}
		}

		static void OverrideSupportsCursorAlpha (GLib.GType gtype)
		{
			OverrideSupportsCursorAlpha (gtype, SupportsCursorAlphaVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSupportsCursorAlpha")]
		protected virtual bool OnSupportsCursorAlpha ()
		{
			return InternalSupportsCursorAlpha ();
		}

		private bool InternalSupportsCursorAlpha ()
		{
			SupportsCursorAlphaNativeDelegate unmanaged = class_abi.BaseOverride<SupportsCursorAlphaNativeDelegate>(this.LookupGType(), "supports_cursor_alpha");
			if (unmanaged == null) return false;

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

		static SupportsCursorColorNativeDelegate SupportsCursorColor_cb_delegate;
		static SupportsCursorColorNativeDelegate SupportsCursorColorVMCallback {
			get {
				if (SupportsCursorColor_cb_delegate == null)
					SupportsCursorColor_cb_delegate = new SupportsCursorColorNativeDelegate (SupportsCursorColor_cb);
				return SupportsCursorColor_cb_delegate;
			}
		}

		static void OverrideSupportsCursorColor (GLib.GType gtype)
		{
			OverrideSupportsCursorColor (gtype, SupportsCursorColorVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSupportsCursorColor")]
		protected virtual bool OnSupportsCursorColor ()
		{
			return InternalSupportsCursorColor ();
		}

		private bool InternalSupportsCursorColor ()
		{
			SupportsCursorColorNativeDelegate unmanaged = class_abi.BaseOverride<SupportsCursorColorNativeDelegate>(this.LookupGType(), "supports_cursor_color");
			if (unmanaged == null) return false;

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

		static SupportsClipboardPersistenceNativeDelegate SupportsClipboardPersistence_cb_delegate;
		static SupportsClipboardPersistenceNativeDelegate SupportsClipboardPersistenceVMCallback {
			get {
				if (SupportsClipboardPersistence_cb_delegate == null)
					SupportsClipboardPersistence_cb_delegate = new SupportsClipboardPersistenceNativeDelegate (SupportsClipboardPersistence_cb);
				return SupportsClipboardPersistence_cb_delegate;
			}
		}

		static void OverrideSupportsClipboardPersistence (GLib.GType gtype)
		{
			OverrideSupportsClipboardPersistence (gtype, SupportsClipboardPersistenceVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSupportsClipboardPersistence")]
		protected virtual bool OnSupportsClipboardPersistence ()
		{
			return InternalSupportsClipboardPersistence ();
		}

		private bool InternalSupportsClipboardPersistence ()
		{
			SupportsClipboardPersistenceNativeDelegate unmanaged = class_abi.BaseOverride<SupportsClipboardPersistenceNativeDelegate>(this.LookupGType(), "supports_clipboard_persistence");
			if (unmanaged == null) return false;

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

		static StoreClipboardNativeDelegate StoreClipboard_cb_delegate;
		static StoreClipboardNativeDelegate StoreClipboardVMCallback {
			get {
				if (StoreClipboard_cb_delegate == null)
					StoreClipboard_cb_delegate = new StoreClipboardNativeDelegate (StoreClipboard_cb);
				return StoreClipboard_cb_delegate;
			}
		}

		static void OverrideStoreClipboard (GLib.GType gtype)
		{
			OverrideStoreClipboard (gtype, StoreClipboardVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void StoreClipboardNativeDelegate (IntPtr inst, IntPtr clipboard_window, uint time_, IntPtr targets, int n_targets);

		static void StoreClipboard_cb (IntPtr inst, IntPtr clipboard_window, uint time_, IntPtr targets, int n_targets)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnStoreClipboard (GLib.Object.GetObject(clipboard_window) as Gdk.Window, time_, targets == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (targets, typeof (Gdk.Atom), false), n_targets);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideStoreClipboard")]
		protected virtual void OnStoreClipboard (Gdk.Window clipboard_window, uint time_, Gdk.Atom targets, int n_targets)
		{
			InternalStoreClipboard (clipboard_window, time_, targets, n_targets);
		}

		private void InternalStoreClipboard (Gdk.Window clipboard_window, uint time_, Gdk.Atom targets, int n_targets)
		{
			StoreClipboardNativeDelegate unmanaged = class_abi.BaseOverride<StoreClipboardNativeDelegate>(this.LookupGType(), "store_clipboard");
			if (unmanaged == null) return;

			unmanaged (this.Handle, clipboard_window == null ? IntPtr.Zero : clipboard_window.Handle, time_, targets == null ? IntPtr.Zero : targets.Handle, n_targets);
		}

		static GetDefaultCursorSizeNativeDelegate GetDefaultCursorSize_cb_delegate;
		static GetDefaultCursorSizeNativeDelegate GetDefaultCursorSizeVMCallback {
			get {
				if (GetDefaultCursorSize_cb_delegate == null)
					GetDefaultCursorSize_cb_delegate = new GetDefaultCursorSizeNativeDelegate (GetDefaultCursorSize_cb);
				return GetDefaultCursorSize_cb_delegate;
			}
		}

		static void OverrideGetDefaultCursorSize (GLib.GType gtype)
		{
			OverrideGetDefaultCursorSize (gtype, GetDefaultCursorSizeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetDefaultCursorSizeNativeDelegate (IntPtr inst, out uint width, out uint height);

		static void GetDefaultCursorSize_cb (IntPtr inst, out uint width, out uint height)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnGetDefaultCursorSize (out width, out height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideGetDefaultCursorSize")]
		protected virtual void OnGetDefaultCursorSize (out uint width, out uint height)
		{
			InternalGetDefaultCursorSize (out width, out height);
		}

		private void InternalGetDefaultCursorSize (out uint width, out uint height)
		{
			GetDefaultCursorSizeNativeDelegate unmanaged = class_abi.BaseOverride<GetDefaultCursorSizeNativeDelegate>(this.LookupGType(), "get_default_cursor_size");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out width, out height);
		}

		static GetMaximalCursorSizeNativeDelegate GetMaximalCursorSize_cb_delegate;
		static GetMaximalCursorSizeNativeDelegate GetMaximalCursorSizeVMCallback {
			get {
				if (GetMaximalCursorSize_cb_delegate == null)
					GetMaximalCursorSize_cb_delegate = new GetMaximalCursorSizeNativeDelegate (GetMaximalCursorSize_cb);
				return GetMaximalCursorSize_cb_delegate;
			}
		}

		static void OverrideGetMaximalCursorSize (GLib.GType gtype)
		{
			OverrideGetMaximalCursorSize (gtype, GetMaximalCursorSizeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetMaximalCursorSizeNativeDelegate (IntPtr inst, out uint width, out uint height);

		static void GetMaximalCursorSize_cb (IntPtr inst, out uint width, out uint height)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnGetMaximalCursorSize (out width, out height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideGetMaximalCursorSize")]
		protected virtual void OnGetMaximalCursorSize (out uint width, out uint height)
		{
			InternalGetMaximalCursorSize (out width, out height);
		}

		private void InternalGetMaximalCursorSize (out uint width, out uint height)
		{
			GetMaximalCursorSizeNativeDelegate unmanaged = class_abi.BaseOverride<GetMaximalCursorSizeNativeDelegate>(this.LookupGType(), "get_maximal_cursor_size");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out width, out height);
		}

		static GetCursorForTypeNativeDelegate GetCursorForType_cb_delegate;
		static GetCursorForTypeNativeDelegate GetCursorForTypeVMCallback {
			get {
				if (GetCursorForType_cb_delegate == null)
					GetCursorForType_cb_delegate = new GetCursorForTypeNativeDelegate (GetCursorForType_cb);
				return GetCursorForType_cb_delegate;
			}
		}

		static void OverrideGetCursorForType (GLib.GType gtype)
		{
			OverrideGetCursorForType (gtype, GetCursorForTypeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr GetCursorForTypeNativeDelegate (IntPtr inst, int type);

		static IntPtr GetCursorForType_cb (IntPtr inst, int type)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Cursor __result;
				__result = __obj.OnGetCursorForType ((Gdk.CursorType) type);
				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.Display), ConnectionMethod="OverrideGetCursorForType")]
		protected virtual Gdk.Cursor OnGetCursorForType (Gdk.CursorType type)
		{
			return InternalGetCursorForType (type);
		}

		private Gdk.Cursor InternalGetCursorForType (Gdk.CursorType type)
		{
			GetCursorForTypeNativeDelegate unmanaged = class_abi.BaseOverride<GetCursorForTypeNativeDelegate>(this.LookupGType(), "get_cursor_for_type");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, (int) type);
			return GLib.Object.GetObject(__result) as Gdk.Cursor;
		}

		static GetCursorForNameNativeDelegate GetCursorForName_cb_delegate;
		static GetCursorForNameNativeDelegate GetCursorForNameVMCallback {
			get {
				if (GetCursorForName_cb_delegate == null)
					GetCursorForName_cb_delegate = new GetCursorForNameNativeDelegate (GetCursorForName_cb);
				return GetCursorForName_cb_delegate;
			}
		}

		static void OverrideGetCursorForName (GLib.GType gtype)
		{
			OverrideGetCursorForName (gtype, GetCursorForNameVMCallback);
		}

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

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

		static IntPtr GetCursorForName_cb (IntPtr inst, IntPtr name)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Cursor __result;
				__result = __obj.OnGetCursorForName (GLib.Marshaller.Utf8PtrToString (name));
				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.Display), ConnectionMethod="OverrideGetCursorForName")]
		protected virtual Gdk.Cursor OnGetCursorForName (string name)
		{
			return InternalGetCursorForName (name);
		}

		private Gdk.Cursor InternalGetCursorForName (string name)
		{
			GetCursorForNameNativeDelegate unmanaged = class_abi.BaseOverride<GetCursorForNameNativeDelegate>(this.LookupGType(), "get_cursor_for_name");
			if (unmanaged == null) return null;

			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr __result = unmanaged (this.Handle, native_name);
			GLib.Marshaller.Free (native_name);
			return GLib.Object.GetObject(__result) as Gdk.Cursor;
		}

		static GetCursorForSurfaceNativeDelegate GetCursorForSurface_cb_delegate;
		static GetCursorForSurfaceNativeDelegate GetCursorForSurfaceVMCallback {
			get {
				if (GetCursorForSurface_cb_delegate == null)
					GetCursorForSurface_cb_delegate = new GetCursorForSurfaceNativeDelegate (GetCursorForSurface_cb);
				return GetCursorForSurface_cb_delegate;
			}
		}

		static void OverrideGetCursorForSurface (GLib.GType gtype)
		{
			OverrideGetCursorForSurface (gtype, GetCursorForSurfaceVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr GetCursorForSurfaceNativeDelegate (IntPtr inst, IntPtr surface, double x, double y);

		static IntPtr GetCursorForSurface_cb (IntPtr inst, IntPtr surface, double x, double y)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Cursor __result;
				__result = __obj.OnGetCursorForSurface (Cairo.Surface.Lookup (surface, true), x, y);
				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.Display), ConnectionMethod="OverrideGetCursorForSurface")]
		protected virtual Gdk.Cursor OnGetCursorForSurface (Cairo.Surface surface, double x, double y)
		{
			return InternalGetCursorForSurface (surface, x, y);
		}

		private Gdk.Cursor InternalGetCursorForSurface (Cairo.Surface surface, double x, double y)
		{
			GetCursorForSurfaceNativeDelegate unmanaged = class_abi.BaseOverride<GetCursorForSurfaceNativeDelegate>(this.LookupGType(), "get_cursor_for_surface");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, surface.Handle, x, y);
			return GLib.Object.GetObject(__result) as Gdk.Cursor;
		}

		static GetAppLaunchContextNativeDelegate GetAppLaunchContext_cb_delegate;
		static GetAppLaunchContextNativeDelegate GetAppLaunchContextVMCallback {
			get {
				if (GetAppLaunchContext_cb_delegate == null)
					GetAppLaunchContext_cb_delegate = new GetAppLaunchContextNativeDelegate (GetAppLaunchContext_cb);
				return GetAppLaunchContext_cb_delegate;
			}
		}

		static void OverrideGetAppLaunchContext (GLib.GType gtype)
		{
			OverrideGetAppLaunchContext (gtype, GetAppLaunchContextVMCallback);
		}

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

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

		static IntPtr GetAppLaunchContext_cb (IntPtr inst)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.AppLaunchContext __result;
				__result = __obj.OnGetAppLaunchContext ();
				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.Display), ConnectionMethod="OverrideGetAppLaunchContext")]
		protected virtual Gdk.AppLaunchContext OnGetAppLaunchContext ()
		{
			return InternalGetAppLaunchContext ();
		}

		private Gdk.AppLaunchContext InternalGetAppLaunchContext ()
		{
			GetAppLaunchContextNativeDelegate unmanaged = class_abi.BaseOverride<GetAppLaunchContextNativeDelegate>(this.LookupGType(), "get_app_launch_context");
			if (unmanaged == null) return null;

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

		static BeforeProcessAllUpdatesNativeDelegate BeforeProcessAllUpdates_cb_delegate;
		static BeforeProcessAllUpdatesNativeDelegate BeforeProcessAllUpdatesVMCallback {
			get {
				if (BeforeProcessAllUpdates_cb_delegate == null)
					BeforeProcessAllUpdates_cb_delegate = new BeforeProcessAllUpdatesNativeDelegate (BeforeProcessAllUpdates_cb);
				return BeforeProcessAllUpdates_cb_delegate;
			}
		}

		static void OverrideBeforeProcessAllUpdates (GLib.GType gtype)
		{
			OverrideBeforeProcessAllUpdates (gtype, BeforeProcessAllUpdatesVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideBeforeProcessAllUpdates")]
		protected virtual void OnBeforeProcessAllUpdates ()
		{
			InternalBeforeProcessAllUpdates ();
		}

		private void InternalBeforeProcessAllUpdates ()
		{
			BeforeProcessAllUpdatesNativeDelegate unmanaged = class_abi.BaseOverride<BeforeProcessAllUpdatesNativeDelegate>(this.LookupGType(), "before_process_all_updates");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static AfterProcessAllUpdatesNativeDelegate AfterProcessAllUpdates_cb_delegate;
		static AfterProcessAllUpdatesNativeDelegate AfterProcessAllUpdatesVMCallback {
			get {
				if (AfterProcessAllUpdates_cb_delegate == null)
					AfterProcessAllUpdates_cb_delegate = new AfterProcessAllUpdatesNativeDelegate (AfterProcessAllUpdates_cb);
				return AfterProcessAllUpdates_cb_delegate;
			}
		}

		static void OverrideAfterProcessAllUpdates (GLib.GType gtype)
		{
			OverrideAfterProcessAllUpdates (gtype, AfterProcessAllUpdatesVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideAfterProcessAllUpdates")]
		protected virtual void OnAfterProcessAllUpdates ()
		{
			InternalAfterProcessAllUpdates ();
		}

		private void InternalAfterProcessAllUpdates ()
		{
			AfterProcessAllUpdatesNativeDelegate unmanaged = class_abi.BaseOverride<AfterProcessAllUpdatesNativeDelegate>(this.LookupGType(), "after_process_all_updates");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static GetNextSerialNativeDelegate GetNextSerial_cb_delegate;
		static GetNextSerialNativeDelegate GetNextSerialVMCallback {
			get {
				if (GetNextSerial_cb_delegate == null)
					GetNextSerial_cb_delegate = new GetNextSerialNativeDelegate (GetNextSerial_cb);
				return GetNextSerial_cb_delegate;
			}
		}

		static void OverrideGetNextSerial (GLib.GType gtype)
		{
			OverrideGetNextSerial (gtype, GetNextSerialVMCallback);
		}

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

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

		static UIntPtr GetNextSerial_cb (IntPtr inst)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				ulong __result;
				__result = __obj.OnGetNextSerial ();
				return new UIntPtr (__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideGetNextSerial")]
		protected virtual ulong OnGetNextSerial ()
		{
			return InternalGetNextSerial ();
		}

		private ulong InternalGetNextSerial ()
		{
			GetNextSerialNativeDelegate unmanaged = class_abi.BaseOverride<GetNextSerialNativeDelegate>(this.LookupGType(), "get_next_serial");
			if (unmanaged == null) return 0;

			UIntPtr __result = unmanaged (this.Handle);
			return (ulong) __result;
		}

		static NotifyStartupCompleteNativeDelegate NotifyStartupComplete_cb_delegate;
		static NotifyStartupCompleteNativeDelegate NotifyStartupCompleteVMCallback {
			get {
				if (NotifyStartupComplete_cb_delegate == null)
					NotifyStartupComplete_cb_delegate = new NotifyStartupCompleteNativeDelegate (NotifyStartupComplete_cb);
				return NotifyStartupComplete_cb_delegate;
			}
		}

		static void OverrideNotifyStartupComplete (GLib.GType gtype)
		{
			OverrideNotifyStartupComplete (gtype, NotifyStartupCompleteVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NotifyStartupCompleteNativeDelegate (IntPtr inst, IntPtr startup_id);

		static void NotifyStartupComplete_cb (IntPtr inst, IntPtr startup_id)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnNotifyStartupComplete (GLib.Marshaller.Utf8PtrToString (startup_id));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideNotifyStartupComplete")]
		protected virtual void OnNotifyStartupComplete (string startup_id)
		{
			InternalNotifyStartupComplete (startup_id);
		}

		private void InternalNotifyStartupComplete (string startup_id)
		{
			NotifyStartupCompleteNativeDelegate unmanaged = class_abi.BaseOverride<NotifyStartupCompleteNativeDelegate>(this.LookupGType(), "notify_startup_complete");
			if (unmanaged == null) return;

			IntPtr native_startup_id = GLib.Marshaller.StringToPtrGStrdup (startup_id);
			unmanaged (this.Handle, native_startup_id);
			GLib.Marshaller.Free (native_startup_id);
		}

		static EventDataCopyNativeDelegate EventDataCopy_cb_delegate;
		static EventDataCopyNativeDelegate EventDataCopyVMCallback {
			get {
				if (EventDataCopy_cb_delegate == null)
					EventDataCopy_cb_delegate = new EventDataCopyNativeDelegate (EventDataCopy_cb);
				return EventDataCopy_cb_delegate;
			}
		}

		static void OverrideEventDataCopy (GLib.GType gtype)
		{
			OverrideEventDataCopy (gtype, EventDataCopyVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void EventDataCopyNativeDelegate (IntPtr inst, IntPtr evnt, IntPtr new_event);

		static void EventDataCopy_cb (IntPtr inst, IntPtr evnt, IntPtr new_event)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnEventDataCopy (Gdk.Event.GetEvent (evnt), Gdk.Event.GetEvent (new_event));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideEventDataCopy")]
		protected virtual void OnEventDataCopy (Gdk.Event evnt, Gdk.Event new_event)
		{
			InternalEventDataCopy (evnt, new_event);
		}

		private void InternalEventDataCopy (Gdk.Event evnt, Gdk.Event new_event)
		{
			EventDataCopyNativeDelegate unmanaged = class_abi.BaseOverride<EventDataCopyNativeDelegate>(this.LookupGType(), "event_data_copy");
			if (unmanaged == null) return;

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

		static EventDataFreeNativeDelegate EventDataFree_cb_delegate;
		static EventDataFreeNativeDelegate EventDataFreeVMCallback {
			get {
				if (EventDataFree_cb_delegate == null)
					EventDataFree_cb_delegate = new EventDataFreeNativeDelegate (EventDataFree_cb);
				return EventDataFree_cb_delegate;
			}
		}

		static void OverrideEventDataFree (GLib.GType gtype)
		{
			OverrideEventDataFree (gtype, EventDataFreeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void EventDataFreeNativeDelegate (IntPtr inst, IntPtr evnt);

		static void EventDataFree_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnEventDataFree (Gdk.Event.GetEvent (evnt));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideEventDataFree")]
		protected virtual void OnEventDataFree (Gdk.Event evnt)
		{
			InternalEventDataFree (evnt);
		}

		private void InternalEventDataFree (Gdk.Event evnt)
		{
			EventDataFreeNativeDelegate unmanaged = class_abi.BaseOverride<EventDataFreeNativeDelegate>(this.LookupGType(), "event_data_free");
			if (unmanaged == null) return;

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

		static CreateWindowImplNativeDelegate CreateWindowImpl_cb_delegate;
		static CreateWindowImplNativeDelegate CreateWindowImplVMCallback {
			get {
				if (CreateWindowImpl_cb_delegate == null)
					CreateWindowImpl_cb_delegate = new CreateWindowImplNativeDelegate (CreateWindowImpl_cb);
				return CreateWindowImpl_cb_delegate;
			}
		}

		static void OverrideCreateWindowImpl (GLib.GType gtype)
		{
			OverrideCreateWindowImpl (gtype, CreateWindowImplVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void CreateWindowImplNativeDelegate (IntPtr inst, IntPtr window, IntPtr real_parent, IntPtr screen, int event_mask, IntPtr attributes, int attributes_mask);

		static void CreateWindowImpl_cb (IntPtr inst, IntPtr window, IntPtr real_parent, IntPtr screen, int event_mask, IntPtr attributes, int attributes_mask)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnCreateWindowImpl (GLib.Object.GetObject(window) as Gdk.Window, GLib.Object.GetObject(real_parent) as Gdk.Window, GLib.Object.GetObject(screen) as Gdk.Screen, (Gdk.EventMask) event_mask, Gdk.WindowAttr.New (attributes), attributes_mask);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideCreateWindowImpl")]
		protected virtual void OnCreateWindowImpl (Gdk.Window window, Gdk.Window real_parent, Gdk.Screen screen, Gdk.EventMask event_mask, Gdk.WindowAttr attributes, int attributes_mask)
		{
			InternalCreateWindowImpl (window, real_parent, screen, event_mask, attributes, attributes_mask);
		}

		private void InternalCreateWindowImpl (Gdk.Window window, Gdk.Window real_parent, Gdk.Screen screen, Gdk.EventMask event_mask, Gdk.WindowAttr attributes, int attributes_mask)
		{
			CreateWindowImplNativeDelegate unmanaged = class_abi.BaseOverride<CreateWindowImplNativeDelegate>(this.LookupGType(), "create_window_impl");
			if (unmanaged == null) return;

			IntPtr native_attributes = GLib.Marshaller.StructureToPtrAlloc (attributes);
			unmanaged (this.Handle, window == null ? IntPtr.Zero : window.Handle, real_parent == null ? IntPtr.Zero : real_parent.Handle, screen == null ? IntPtr.Zero : screen.Handle, (int) event_mask, native_attributes, attributes_mask);
			Marshal.FreeHGlobal (native_attributes);
		}

		static GetKeymapNativeDelegate GetKeymap_cb_delegate;
		static GetKeymapNativeDelegate GetKeymapVMCallback {
			get {
				if (GetKeymap_cb_delegate == null)
					GetKeymap_cb_delegate = new GetKeymapNativeDelegate (GetKeymap_cb);
				return GetKeymap_cb_delegate;
			}
		}

		static void OverrideGetKeymap (GLib.GType gtype)
		{
			OverrideGetKeymap (gtype, GetKeymapVMCallback);
		}

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

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

		static IntPtr GetKeymap_cb (IntPtr inst)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Keymap __result;
				__result = __obj.OnGetKeymap ();
				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.Display), ConnectionMethod="OverrideGetKeymap")]
		protected virtual Gdk.Keymap OnGetKeymap ()
		{
			return InternalGetKeymap ();
		}

		private Gdk.Keymap InternalGetKeymap ()
		{
			GetKeymapNativeDelegate unmanaged = class_abi.BaseOverride<GetKeymapNativeDelegate>(this.LookupGType(), "get_keymap");
			if (unmanaged == null) return null;

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

		static PushErrorTrapNativeDelegate PushErrorTrap_cb_delegate;
		static PushErrorTrapNativeDelegate PushErrorTrapVMCallback {
			get {
				if (PushErrorTrap_cb_delegate == null)
					PushErrorTrap_cb_delegate = new PushErrorTrapNativeDelegate (PushErrorTrap_cb);
				return PushErrorTrap_cb_delegate;
			}
		}

		static void OverridePushErrorTrap (GLib.GType gtype)
		{
			OverridePushErrorTrap (gtype, PushErrorTrapVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverridePushErrorTrap")]
		protected virtual void OnPushErrorTrap ()
		{
			InternalPushErrorTrap ();
		}

		private void InternalPushErrorTrap ()
		{
			PushErrorTrapNativeDelegate unmanaged = class_abi.BaseOverride<PushErrorTrapNativeDelegate>(this.LookupGType(), "push_error_trap");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static PopErrorTrapNativeDelegate PopErrorTrap_cb_delegate;
		static PopErrorTrapNativeDelegate PopErrorTrapVMCallback {
			get {
				if (PopErrorTrap_cb_delegate == null)
					PopErrorTrap_cb_delegate = new PopErrorTrapNativeDelegate (PopErrorTrap_cb);
				return PopErrorTrap_cb_delegate;
			}
		}

		static void OverridePopErrorTrap (GLib.GType gtype)
		{
			OverridePopErrorTrap (gtype, PopErrorTrapVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PopErrorTrapNativeDelegate (IntPtr inst, bool ignore);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverridePopErrorTrap")]
		protected virtual int OnPopErrorTrap (bool ignore)
		{
			return InternalPopErrorTrap (ignore);
		}

		private int InternalPopErrorTrap (bool ignore)
		{
			PopErrorTrapNativeDelegate unmanaged = class_abi.BaseOverride<PopErrorTrapNativeDelegate>(this.LookupGType(), "pop_error_trap");
			if (unmanaged == null) return 0;

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

		static GetSelectionOwnerNativeDelegate GetSelectionOwner_cb_delegate;
		static GetSelectionOwnerNativeDelegate GetSelectionOwnerVMCallback {
			get {
				if (GetSelectionOwner_cb_delegate == null)
					GetSelectionOwner_cb_delegate = new GetSelectionOwnerNativeDelegate (GetSelectionOwner_cb);
				return GetSelectionOwner_cb_delegate;
			}
		}

		static void OverrideGetSelectionOwner (GLib.GType gtype)
		{
			OverrideGetSelectionOwner (gtype, GetSelectionOwnerVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr GetSelectionOwnerNativeDelegate (IntPtr inst, IntPtr selection);

		static IntPtr GetSelectionOwner_cb (IntPtr inst, IntPtr selection)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Window __result;
				__result = __obj.OnGetSelectionOwner (selection == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (selection, typeof (Gdk.Atom), false));
				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.Display), ConnectionMethod="OverrideGetSelectionOwner")]
		protected virtual Gdk.Window OnGetSelectionOwner (Gdk.Atom selection)
		{
			return InternalGetSelectionOwner (selection);
		}

		private Gdk.Window InternalGetSelectionOwner (Gdk.Atom selection)
		{
			GetSelectionOwnerNativeDelegate unmanaged = class_abi.BaseOverride<GetSelectionOwnerNativeDelegate>(this.LookupGType(), "get_selection_owner");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, selection == null ? IntPtr.Zero : selection.Handle);
			return GLib.Object.GetObject(__result) as Gdk.Window;
		}

		static SetSelectionOwnerNativeDelegate SetSelectionOwner_cb_delegate;
		static SetSelectionOwnerNativeDelegate SetSelectionOwnerVMCallback {
			get {
				if (SetSelectionOwner_cb_delegate == null)
					SetSelectionOwner_cb_delegate = new SetSelectionOwnerNativeDelegate (SetSelectionOwner_cb);
				return SetSelectionOwner_cb_delegate;
			}
		}

		static void OverrideSetSelectionOwner (GLib.GType gtype)
		{
			OverrideSetSelectionOwner (gtype, SetSelectionOwnerVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetSelectionOwnerNativeDelegate (IntPtr inst, IntPtr owner, IntPtr selection, uint time, bool send_event);

		static bool SetSelectionOwner_cb (IntPtr inst, IntPtr owner, IntPtr selection, uint time, bool send_event)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				bool __result;
				__result = __obj.OnSetSelectionOwner (GLib.Object.GetObject(owner) as Gdk.Window, selection == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (selection, typeof (Gdk.Atom), false), time, send_event);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSetSelectionOwner")]
		protected virtual bool OnSetSelectionOwner (Gdk.Window owner, Gdk.Atom selection, uint time, bool send_event)
		{
			return InternalSetSelectionOwner (owner, selection, time, send_event);
		}

		private bool InternalSetSelectionOwner (Gdk.Window owner, Gdk.Atom selection, uint time, bool send_event)
		{
			SetSelectionOwnerNativeDelegate unmanaged = class_abi.BaseOverride<SetSelectionOwnerNativeDelegate>(this.LookupGType(), "set_selection_owner");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, owner == null ? IntPtr.Zero : owner.Handle, selection == null ? IntPtr.Zero : selection.Handle, time, send_event);
			return __result;
		}

		static SendSelectionNotifyNativeDelegate SendSelectionNotify_cb_delegate;
		static SendSelectionNotifyNativeDelegate SendSelectionNotifyVMCallback {
			get {
				if (SendSelectionNotify_cb_delegate == null)
					SendSelectionNotify_cb_delegate = new SendSelectionNotifyNativeDelegate (SendSelectionNotify_cb);
				return SendSelectionNotify_cb_delegate;
			}
		}

		static void OverrideSendSelectionNotify (GLib.GType gtype)
		{
			OverrideSendSelectionNotify (gtype, SendSelectionNotifyVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SendSelectionNotifyNativeDelegate (IntPtr inst, IntPtr requestor, IntPtr selection, IntPtr target, IntPtr property, uint time);

		static void SendSelectionNotify_cb (IntPtr inst, IntPtr requestor, IntPtr selection, IntPtr target, IntPtr property, uint time)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnSendSelectionNotify (GLib.Object.GetObject(requestor) as Gdk.Window, selection == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (selection, typeof (Gdk.Atom), false), target == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (target, typeof (Gdk.Atom), false), property == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (property, typeof (Gdk.Atom), false), time);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideSendSelectionNotify")]
		protected virtual void OnSendSelectionNotify (Gdk.Window requestor, Gdk.Atom selection, Gdk.Atom target, Gdk.Atom property, uint time)
		{
			InternalSendSelectionNotify (requestor, selection, target, property, time);
		}

		private void InternalSendSelectionNotify (Gdk.Window requestor, Gdk.Atom selection, Gdk.Atom target, Gdk.Atom property, uint time)
		{
			SendSelectionNotifyNativeDelegate unmanaged = class_abi.BaseOverride<SendSelectionNotifyNativeDelegate>(this.LookupGType(), "send_selection_notify");
			if (unmanaged == null) return;

			unmanaged (this.Handle, requestor == null ? IntPtr.Zero : requestor.Handle, selection == null ? IntPtr.Zero : selection.Handle, target == null ? IntPtr.Zero : target.Handle, property == null ? IntPtr.Zero : property.Handle, time);
		}

		static GetSelectionPropertyNativeDelegate GetSelectionProperty_cb_delegate;
		static GetSelectionPropertyNativeDelegate GetSelectionPropertyVMCallback {
			get {
				if (GetSelectionProperty_cb_delegate == null)
					GetSelectionProperty_cb_delegate = new GetSelectionPropertyNativeDelegate (GetSelectionProperty_cb);
				return GetSelectionProperty_cb_delegate;
			}
		}

		static void OverrideGetSelectionProperty (GLib.GType gtype)
		{
			OverrideGetSelectionProperty (gtype, GetSelectionPropertyVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetSelectionPropertyNativeDelegate (IntPtr inst, IntPtr requestor, out byte data, IntPtr type, out int format);

		static int GetSelectionProperty_cb (IntPtr inst, IntPtr requestor, out byte data, IntPtr type, out int format)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				int __result;
				__result = __obj.OnGetSelectionProperty (GLib.Object.GetObject(requestor) as Gdk.Window, out data, type == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (type, typeof (Gdk.Atom), false), out format);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideGetSelectionProperty")]
		protected virtual int OnGetSelectionProperty (Gdk.Window requestor, out byte data, Gdk.Atom type, out int format)
		{
			return InternalGetSelectionProperty (requestor, out data, type, out format);
		}

		private int InternalGetSelectionProperty (Gdk.Window requestor, out byte data, Gdk.Atom type, out int format)
		{
			GetSelectionPropertyNativeDelegate unmanaged = class_abi.BaseOverride<GetSelectionPropertyNativeDelegate>(this.LookupGType(), "get_selection_property");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int __result = unmanaged (this.Handle, requestor == null ? IntPtr.Zero : requestor.Handle, out data, type == null ? IntPtr.Zero : type.Handle, out format);
			return __result;
		}

		static ConvertSelectionNativeDelegate ConvertSelection_cb_delegate;
		static ConvertSelectionNativeDelegate ConvertSelectionVMCallback {
			get {
				if (ConvertSelection_cb_delegate == null)
					ConvertSelection_cb_delegate = new ConvertSelectionNativeDelegate (ConvertSelection_cb);
				return ConvertSelection_cb_delegate;
			}
		}

		static void OverrideConvertSelection (GLib.GType gtype)
		{
			OverrideConvertSelection (gtype, ConvertSelectionVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ConvertSelectionNativeDelegate (IntPtr inst, IntPtr requestor, IntPtr selection, IntPtr target, uint time);

		static void ConvertSelection_cb (IntPtr inst, IntPtr requestor, IntPtr selection, IntPtr target, uint time)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnConvertSelection (GLib.Object.GetObject(requestor) as Gdk.Window, selection == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (selection, typeof (Gdk.Atom), false), target == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (target, typeof (Gdk.Atom), false), time);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideConvertSelection")]
		protected virtual void OnConvertSelection (Gdk.Window requestor, Gdk.Atom selection, Gdk.Atom target, uint time)
		{
			InternalConvertSelection (requestor, selection, target, time);
		}

		private void InternalConvertSelection (Gdk.Window requestor, Gdk.Atom selection, Gdk.Atom target, uint time)
		{
			ConvertSelectionNativeDelegate unmanaged = class_abi.BaseOverride<ConvertSelectionNativeDelegate>(this.LookupGType(), "convert_selection");
			if (unmanaged == null) return;

			unmanaged (this.Handle, requestor == null ? IntPtr.Zero : requestor.Handle, selection == null ? IntPtr.Zero : selection.Handle, target == null ? IntPtr.Zero : target.Handle, time);
		}

		static TextPropertyToUtf8ListNativeDelegate TextPropertyToUtf8List_cb_delegate;
		static TextPropertyToUtf8ListNativeDelegate TextPropertyToUtf8ListVMCallback {
			get {
				if (TextPropertyToUtf8List_cb_delegate == null)
					TextPropertyToUtf8List_cb_delegate = new TextPropertyToUtf8ListNativeDelegate (TextPropertyToUtf8List_cb);
				return TextPropertyToUtf8List_cb_delegate;
			}
		}

		static void OverrideTextPropertyToUtf8List (GLib.GType gtype)
		{
			OverrideTextPropertyToUtf8List (gtype, TextPropertyToUtf8ListVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int TextPropertyToUtf8ListNativeDelegate (IntPtr inst, IntPtr encoding, int format, out byte text, int length, IntPtr list);

		static int TextPropertyToUtf8List_cb (IntPtr inst, IntPtr encoding, int format, out byte text, int length, IntPtr list)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				int __result;
				__result = __obj.OnTextPropertyToUtf8List (encoding == IntPtr.Zero ? null : (Gdk.Atom) GLib.Opaque.GetOpaque (encoding, typeof (Gdk.Atom), false), format, out text, length, GLib.Marshaller.PtrToStringGFree(list));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideTextPropertyToUtf8List")]
		protected virtual int OnTextPropertyToUtf8List (Gdk.Atom encoding, int format, out byte text, int length, string list)
		{
			return InternalTextPropertyToUtf8List (encoding, format, out text, length, list);
		}

		private int InternalTextPropertyToUtf8List (Gdk.Atom encoding, int format, out byte text, int length, string list)
		{
			TextPropertyToUtf8ListNativeDelegate unmanaged = class_abi.BaseOverride<TextPropertyToUtf8ListNativeDelegate>(this.LookupGType(), "text_property_to_utf8_list");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int __result = unmanaged (this.Handle, encoding == null ? IntPtr.Zero : encoding.Handle, format, out text, length, GLib.Marshaller.StringToPtrGStrdup(list));
			return __result;
		}

		static Utf8ToStringTargetNativeDelegate Utf8ToStringTarget_cb_delegate;
		static Utf8ToStringTargetNativeDelegate Utf8ToStringTargetVMCallback {
			get {
				if (Utf8ToStringTarget_cb_delegate == null)
					Utf8ToStringTarget_cb_delegate = new Utf8ToStringTargetNativeDelegate (Utf8ToStringTarget_cb);
				return Utf8ToStringTarget_cb_delegate;
			}
		}

		static void OverrideUtf8ToStringTarget (GLib.GType gtype)
		{
			OverrideUtf8ToStringTarget (gtype, Utf8ToStringTargetVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr Utf8ToStringTargetNativeDelegate (IntPtr inst, IntPtr text);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideUtf8ToStringTarget")]
		protected virtual string OnUtf8ToStringTarget (string text)
		{
			return InternalUtf8ToStringTarget (text);
		}

		private string InternalUtf8ToStringTarget (string text)
		{
			Utf8ToStringTargetNativeDelegate unmanaged = class_abi.BaseOverride<Utf8ToStringTargetNativeDelegate>(this.LookupGType(), "utf8_to_string_target");
			if (unmanaged == null) return null;

			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
			IntPtr __result = unmanaged (this.Handle, native_text);
			GLib.Marshaller.Free (native_text);
			return GLib.Marshaller.PtrToStringGFree(__result);
		}

		static MakeGlContextCurrentNativeDelegate MakeGlContextCurrent_cb_delegate;
		static MakeGlContextCurrentNativeDelegate MakeGlContextCurrentVMCallback {
			get {
				if (MakeGlContextCurrent_cb_delegate == null)
					MakeGlContextCurrent_cb_delegate = new MakeGlContextCurrentNativeDelegate (MakeGlContextCurrent_cb);
				return MakeGlContextCurrent_cb_delegate;
			}
		}

		static void OverrideMakeGlContextCurrent (GLib.GType gtype)
		{
			OverrideMakeGlContextCurrent (gtype, MakeGlContextCurrentVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool MakeGlContextCurrentNativeDelegate (IntPtr inst, IntPtr context);

		static bool MakeGlContextCurrent_cb (IntPtr inst, IntPtr context)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				bool __result;
				__result = __obj.OnMakeGlContextCurrent (GLib.Object.GetObject(context) as Gdk.GLContext);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideMakeGlContextCurrent")]
		protected virtual bool OnMakeGlContextCurrent (Gdk.GLContext context)
		{
			return InternalMakeGlContextCurrent (context);
		}

		private bool InternalMakeGlContextCurrent (Gdk.GLContext context)
		{
			MakeGlContextCurrentNativeDelegate unmanaged = class_abi.BaseOverride<MakeGlContextCurrentNativeDelegate>(this.LookupGType(), "make_gl_context_current");
			if (unmanaged == null) return false;

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

		static GetDefaultSeatNativeDelegate GetDefaultSeat_cb_delegate;
		static GetDefaultSeatNativeDelegate GetDefaultSeatVMCallback {
			get {
				if (GetDefaultSeat_cb_delegate == null)
					GetDefaultSeat_cb_delegate = new GetDefaultSeatNativeDelegate (GetDefaultSeat_cb);
				return GetDefaultSeat_cb_delegate;
			}
		}

		static void OverrideGetDefaultSeat (GLib.GType gtype)
		{
			OverrideGetDefaultSeat (gtype, GetDefaultSeatVMCallback);
		}

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

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

		static IntPtr GetDefaultSeat_cb (IntPtr inst)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Seat __result;
				__result = __obj.OnGetDefaultSeat ();
				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.Display), ConnectionMethod="OverrideGetDefaultSeat")]
		protected virtual Gdk.Seat OnGetDefaultSeat ()
		{
			return InternalGetDefaultSeat ();
		}

		private Gdk.Seat InternalGetDefaultSeat ()
		{
			GetDefaultSeatNativeDelegate unmanaged = class_abi.BaseOverride<GetDefaultSeatNativeDelegate>(this.LookupGType(), "get_default_seat");
			if (unmanaged == null) return null;

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

		static GetNMonitorsNativeDelegate GetNMonitors_cb_delegate;
		static GetNMonitorsNativeDelegate GetNMonitorsVMCallback {
			get {
				if (GetNMonitors_cb_delegate == null)
					GetNMonitors_cb_delegate = new GetNMonitorsNativeDelegate (GetNMonitors_cb);
				return GetNMonitors_cb_delegate;
			}
		}

		static void OverrideGetNMonitors (GLib.GType gtype)
		{
			OverrideGetNMonitors (gtype, GetNMonitorsVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideGetNMonitors")]
		protected virtual int OnGetNMonitors ()
		{
			return InternalGetNMonitors ();
		}

		private int InternalGetNMonitors ()
		{
			GetNMonitorsNativeDelegate unmanaged = class_abi.BaseOverride<GetNMonitorsNativeDelegate>(this.LookupGType(), "get_n_monitors");
			if (unmanaged == null) return 0;

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

		static GetMonitorNativeDelegate GetMonitor_cb_delegate;
		static GetMonitorNativeDelegate GetMonitorVMCallback {
			get {
				if (GetMonitor_cb_delegate == null)
					GetMonitor_cb_delegate = new GetMonitorNativeDelegate (GetMonitor_cb);
				return GetMonitor_cb_delegate;
			}
		}

		static void OverrideGetMonitor (GLib.GType gtype)
		{
			OverrideGetMonitor (gtype, GetMonitorVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr GetMonitorNativeDelegate (IntPtr inst, int index);

		static IntPtr GetMonitor_cb (IntPtr inst, int index)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Monitor __result;
				__result = __obj.OnGetMonitor (index);
				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.Display), ConnectionMethod="OverrideGetMonitor")]
		protected virtual Gdk.Monitor OnGetMonitor (int index)
		{
			return InternalGetMonitor (index);
		}

		private Gdk.Monitor InternalGetMonitor (int index)
		{
			GetMonitorNativeDelegate unmanaged = class_abi.BaseOverride<GetMonitorNativeDelegate>(this.LookupGType(), "get_monitor");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, index);
			return GLib.Object.GetObject(__result) as Gdk.Monitor;
		}

		static GetPrimaryMonitorNativeDelegate GetPrimaryMonitor_cb_delegate;
		static GetPrimaryMonitorNativeDelegate GetPrimaryMonitorVMCallback {
			get {
				if (GetPrimaryMonitor_cb_delegate == null)
					GetPrimaryMonitor_cb_delegate = new GetPrimaryMonitorNativeDelegate (GetPrimaryMonitor_cb);
				return GetPrimaryMonitor_cb_delegate;
			}
		}

		static void OverrideGetPrimaryMonitor (GLib.GType gtype)
		{
			OverrideGetPrimaryMonitor (gtype, GetPrimaryMonitorVMCallback);
		}

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

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

		static IntPtr GetPrimaryMonitor_cb (IntPtr inst)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Monitor __result;
				__result = __obj.OnGetPrimaryMonitor ();
				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.Display), ConnectionMethod="OverrideGetPrimaryMonitor")]
		protected virtual Gdk.Monitor OnGetPrimaryMonitor ()
		{
			return InternalGetPrimaryMonitor ();
		}

		private Gdk.Monitor InternalGetPrimaryMonitor ()
		{
			GetPrimaryMonitorNativeDelegate unmanaged = class_abi.BaseOverride<GetPrimaryMonitorNativeDelegate>(this.LookupGType(), "get_primary_monitor");
			if (unmanaged == null) return null;

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

		static GetMonitorAtWindowNativeDelegate GetMonitorAtWindow_cb_delegate;
		static GetMonitorAtWindowNativeDelegate GetMonitorAtWindowVMCallback {
			get {
				if (GetMonitorAtWindow_cb_delegate == null)
					GetMonitorAtWindow_cb_delegate = new GetMonitorAtWindowNativeDelegate (GetMonitorAtWindow_cb);
				return GetMonitorAtWindow_cb_delegate;
			}
		}

		static void OverrideGetMonitorAtWindow (GLib.GType gtype)
		{
			OverrideGetMonitorAtWindow (gtype, GetMonitorAtWindowVMCallback);
		}

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

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

		static IntPtr GetMonitorAtWindow_cb (IntPtr inst, IntPtr window)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				Gdk.Monitor __result;
				__result = __obj.OnGetMonitorAtWindow (GLib.Object.GetObject(window) as Gdk.Window);
				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.Display), ConnectionMethod="OverrideGetMonitorAtWindow")]
		protected virtual Gdk.Monitor OnGetMonitorAtWindow (Gdk.Window window)
		{
			return InternalGetMonitorAtWindow (window);
		}

		private Gdk.Monitor InternalGetMonitorAtWindow (Gdk.Window window)
		{
			GetMonitorAtWindowNativeDelegate unmanaged = class_abi.BaseOverride<GetMonitorAtWindowNativeDelegate>(this.LookupGType(), "get_monitor_at_window");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, window == null ? IntPtr.Zero : window.Handle);
			return GLib.Object.GetObject(__result) as Gdk.Monitor;
		}

		static OpenedNativeDelegate Opened_cb_delegate;
		static OpenedNativeDelegate OpenedVMCallback {
			get {
				if (Opened_cb_delegate == null)
					Opened_cb_delegate = new OpenedNativeDelegate (Opened_cb);
				return Opened_cb_delegate;
			}
		}

		static void OverrideOpened (GLib.GType gtype)
		{
			OverrideOpened (gtype, OpenedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideOpened")]
		protected virtual void OnOpened ()
		{
			InternalOpened ();
		}

		private void InternalOpened ()
		{
			OpenedNativeDelegate unmanaged = class_abi.BaseOverride<OpenedNativeDelegate>(this.LookupGType(), "opened");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ClosedNativeDelegate Closed_cb_delegate;
		static ClosedNativeDelegate ClosedVMCallback {
			get {
				if (Closed_cb_delegate == null)
					Closed_cb_delegate = new ClosedNativeDelegate (Closed_cb);
				return Closed_cb_delegate;
			}
		}

		static void OverrideClosed (GLib.GType gtype)
		{
			OverrideClosed (gtype, ClosedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ClosedNativeDelegate (IntPtr inst, bool is_error);

		static void Closed_cb (IntPtr inst, bool is_error)
		{
			try {
				Display __obj = GLib.Object.GetObject (inst, false) as Display;
				__obj.OnClosed (is_error);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Display), ConnectionMethod="OverrideClosed")]
		protected virtual void OnClosed (bool is_error)
		{
			InternalClosed (is_error);
		}

		private void InternalClosed (bool is_error)
		{
			ClosedNativeDelegate unmanaged = class_abi.BaseOverride<ClosedNativeDelegate>(this.LookupGType(), "closed");
			if (unmanaged == null) return;

			unmanaged (this.Handle, is_error);
		}


		// 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("window_type"
							, GLib.Object.class_abi.Fields
							, (uint) Marshal.SizeOf<GLib.GType>() // window_type
							, null
							, "get_name"
							, (long) Marshal.OffsetOf<GdkDisplay_window_typeAlign>("window_type")
							, 0
							),
						new GLib.AbiField("get_name"
							, -1
							, (uint) sizeof( IntPtr ) // get_name
							, "window_type"
							, "get_default_screen"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_default_screen"
							, -1
							, (uint) sizeof( IntPtr ) // get_default_screen
							, "get_name"
							, "beep"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("beep"
							, -1
							, (uint) sizeof( IntPtr ) // beep
							, "get_default_screen"
							, "sync"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("sync"
							, -1
							, (uint) sizeof( IntPtr ) // sync
							, "beep"
							, "flush"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("flush"
							, -1
							, (uint) sizeof( IntPtr ) // flush
							, "sync"
							, "has_pending"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("has_pending"
							, -1
							, (uint) sizeof( IntPtr ) // has_pending
							, "flush"
							, "queue_events"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("queue_events"
							, -1
							, (uint) sizeof( IntPtr ) // queue_events
							, "has_pending"
							, "make_default"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("make_default"
							, -1
							, (uint) sizeof( IntPtr ) // make_default
							, "queue_events"
							, "get_default_group"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_default_group"
							, -1
							, (uint) sizeof( IntPtr ) // get_default_group
							, "make_default"
							, "supports_selection_notification"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("supports_selection_notification"
							, -1
							, (uint) sizeof( IntPtr ) // supports_selection_notification
							, "get_default_group"
							, "request_selection_notification"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("request_selection_notification"
							, -1
							, (uint) sizeof( IntPtr ) // request_selection_notification
							, "supports_selection_notification"
							, "supports_shapes"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("supports_shapes"
							, -1
							, (uint) sizeof( IntPtr ) // supports_shapes
							, "request_selection_notification"
							, "supports_input_shapes"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("supports_input_shapes"
							, -1
							, (uint) sizeof( IntPtr ) // supports_input_shapes
							, "supports_shapes"
							, "supports_composite"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("supports_composite"
							, -1
							, (uint) sizeof( IntPtr ) // supports_composite
							, "supports_input_shapes"
							, "supports_cursor_alpha"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("supports_cursor_alpha"
							, -1
							, (uint) sizeof( IntPtr ) // supports_cursor_alpha
							, "supports_composite"
							, "supports_cursor_color"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("supports_cursor_color"
							, -1
							, (uint) sizeof( IntPtr ) // supports_cursor_color
							, "supports_cursor_alpha"
							, "supports_clipboard_persistence"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("supports_clipboard_persistence"
							, -1
							, (uint) sizeof( IntPtr ) // supports_clipboard_persistence
							, "supports_cursor_color"
							, "store_clipboard"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("store_clipboard"
							, -1
							, (uint) sizeof( IntPtr ) // store_clipboard
							, "supports_clipboard_persistence"
							, "get_default_cursor_size"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_default_cursor_size"
							, -1
							, (uint) sizeof( IntPtr ) // get_default_cursor_size
							, "store_clipboard"
							, "get_maximal_cursor_size"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_maximal_cursor_size"
							, -1
							, (uint) sizeof( IntPtr ) // get_maximal_cursor_size
							, "get_default_cursor_size"
							, "get_cursor_for_type"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_cursor_for_type"
							, -1
							, (uint) sizeof( IntPtr ) // get_cursor_for_type
							, "get_maximal_cursor_size"
							, "get_cursor_for_name"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_cursor_for_name"
							, -1
							, (uint) sizeof( IntPtr ) // get_cursor_for_name
							, "get_cursor_for_type"
							, "get_cursor_for_surface"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_cursor_for_surface"
							, -1
							, (uint) sizeof( IntPtr ) // get_cursor_for_surface
							, "get_cursor_for_name"
							, "get_app_launch_context"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_app_launch_context"
							, -1
							, (uint) sizeof( IntPtr ) // get_app_launch_context
							, "get_cursor_for_surface"
							, "before_process_all_updates"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("before_process_all_updates"
							, -1
							, (uint) sizeof( IntPtr ) // before_process_all_updates
							, "get_app_launch_context"
							, "after_process_all_updates"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("after_process_all_updates"
							, -1
							, (uint) sizeof( IntPtr ) // after_process_all_updates
							, "before_process_all_updates"
							, "get_next_serial"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_next_serial"
							, -1
							, (uint) sizeof( IntPtr ) // get_next_serial
							, "after_process_all_updates"
							, "notify_startup_complete"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("notify_startup_complete"
							, -1
							, (uint) sizeof( IntPtr ) // notify_startup_complete
							, "get_next_serial"
							, "event_data_copy"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("event_data_copy"
							, -1
							, (uint) sizeof( IntPtr ) // event_data_copy
							, "notify_startup_complete"
							, "event_data_free"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("event_data_free"
							, -1
							, (uint) sizeof( IntPtr ) // event_data_free
							, "event_data_copy"
							, "create_window_impl"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("create_window_impl"
							, -1
							, (uint) sizeof( IntPtr ) // create_window_impl
							, "event_data_free"
							, "get_keymap"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_keymap"
							, -1
							, (uint) sizeof( IntPtr ) // get_keymap
							, "create_window_impl"
							, "push_error_trap"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("push_error_trap"
							, -1
							, (uint) sizeof( IntPtr ) // push_error_trap
							, "get_keymap"
							, "pop_error_trap"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("pop_error_trap"
							, -1
							, (uint) sizeof( IntPtr ) // pop_error_trap
							, "push_error_trap"
							, "get_selection_owner"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_selection_owner"
							, -1
							, (uint) sizeof( IntPtr ) // get_selection_owner
							, "pop_error_trap"
							, "set_selection_owner"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_selection_owner"
							, -1
							, (uint) sizeof( IntPtr ) // set_selection_owner
							, "get_selection_owner"
							, "send_selection_notify"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("send_selection_notify"
							, -1
							, (uint) sizeof( IntPtr ) // send_selection_notify
							, "set_selection_owner"
							, "get_selection_property"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_selection_property"
							, -1
							, (uint) sizeof( IntPtr ) // get_selection_property
							, "send_selection_notify"
							, "convert_selection"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("convert_selection"
							, -1
							, (uint) sizeof( IntPtr ) // convert_selection
							, "get_selection_property"
							, "text_property_to_utf8_list"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("text_property_to_utf8_list"
							, -1
							, (uint) sizeof( IntPtr ) // text_property_to_utf8_list
							, "convert_selection"
							, "utf8_to_string_target"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("utf8_to_string_target"
							, -1
							, (uint) sizeof( IntPtr ) // utf8_to_string_target
							, "text_property_to_utf8_list"
							, "make_gl_context_current"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("make_gl_context_current"
							, -1
							, (uint) sizeof( IntPtr ) // make_gl_context_current
							, "utf8_to_string_target"
							, "get_default_seat"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_default_seat"
							, -1
							, (uint) sizeof( IntPtr ) // get_default_seat
							, "make_gl_context_current"
							, "get_n_monitors"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_n_monitors"
							, -1
							, (uint) sizeof( IntPtr ) // get_n_monitors
							, "get_default_seat"
							, "get_monitor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_monitor"
							, -1
							, (uint) sizeof( IntPtr ) // get_monitor
							, "get_n_monitors"
							, "get_primary_monitor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_primary_monitor"
							, -1
							, (uint) sizeof( IntPtr ) // get_primary_monitor
							, "get_monitor"
							, "get_monitor_at_window"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_monitor_at_window"
							, -1
							, (uint) sizeof( IntPtr ) // get_monitor_at_window
							, "get_primary_monitor"
							, "opened"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("opened"
							, -1
							, (uint) sizeof( IntPtr ) // opened
							, "get_monitor_at_window"
							, "closed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("closed"
							, -1
							, (uint) sizeof( IntPtr ) // closed
							, "opened"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GdkDisplay_window_typeAlign
		{
			sbyte f1;
			private GLib.GType window_type;
		}


		// End of the ABI representation.

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

		public void Beep() {
			gdk_display_beep(Handle);
		}

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

		public void Close() {
			gdk_display_close(Handle);
		}

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

		public bool DeviceIsGrabbed(Gdk.Device device) {
			bool raw_ret = gdk_display_device_is_grabbed(Handle, device == null ? IntPtr.Zero : device.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void Flush() {
			gdk_display_flush(Handle);
		}

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

		public Gdk.AppLaunchContext AppLaunchContext { 
			get {
				IntPtr raw_ret = gdk_display_get_app_launch_context(Handle);
				Gdk.AppLaunchContext ret = GLib.Object.GetObject(raw_ret) as Gdk.AppLaunchContext;
				return ret;
			}
		}

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

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

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

		public uint DefaultCursorSize { 
			get {
				uint raw_ret = gdk_display_get_default_cursor_size(Handle);
				uint ret = raw_ret;
				return ret;
			}
		}

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

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

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

		public Gdk.Screen DefaultScreen { 
			get {
				IntPtr raw_ret = gdk_display_get_default_screen(Handle);
				Gdk.Screen ret = GLib.Object.GetObject(raw_ret) as Gdk.Screen;
				return ret;
			}
		}

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

		public Gdk.Seat DefaultSeat { 
			get {
				IntPtr raw_ret = gdk_display_get_default_seat(Handle);
				Gdk.Seat ret = GLib.Object.GetObject(raw_ret) as Gdk.Seat;
				return ret;
			}
		}

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

		[Obsolete]
		public Gdk.DeviceManager DeviceManager { 
			get {
				IntPtr raw_ret = gdk_display_get_device_manager(Handle);
				Gdk.DeviceManager ret = GLib.Object.GetObject(raw_ret) as Gdk.DeviceManager;
				return ret;
			}
		}

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

		public Gdk.Event Event { 
			get {
				IntPtr raw_ret = gdk_display_get_event(Handle);
				Gdk.Event ret = Gdk.Event.GetEvent (raw_ret);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_display_get_maximal_cursor_size(IntPtr raw, out uint width, out uint height);
		static d_gdk_display_get_maximal_cursor_size gdk_display_get_maximal_cursor_size = FuncLoader.LoadFunction<d_gdk_display_get_maximal_cursor_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_get_maximal_cursor_size"));

		public void GetMaximalCursorSize(out uint width, out uint height) {
			gdk_display_get_maximal_cursor_size(Handle, out width, out height);
		}

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

		public Gdk.Monitor GetMonitor(int monitor_num) {
			IntPtr raw_ret = gdk_display_get_monitor(Handle, monitor_num);
			Gdk.Monitor ret = GLib.Object.GetObject(raw_ret) as Gdk.Monitor;
			return ret;
		}

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

		public Gdk.Monitor GetMonitorAtPoint(int x, int y) {
			IntPtr raw_ret = gdk_display_get_monitor_at_point(Handle, x, y);
			Gdk.Monitor ret = GLib.Object.GetObject(raw_ret) as Gdk.Monitor;
			return ret;
		}

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

		public Gdk.Monitor GetMonitorAtWindow(Gdk.Window window) {
			IntPtr raw_ret = gdk_display_get_monitor_at_window(Handle, window == null ? IntPtr.Zero : window.Handle);
			Gdk.Monitor ret = GLib.Object.GetObject(raw_ret) as Gdk.Monitor;
			return ret;
		}

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

		public int NMonitors { 
			get {
				int raw_ret = gdk_display_get_n_monitors(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

		[Obsolete]
		public int NScreens { 
			get {
				int raw_ret = gdk_display_get_n_screens(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

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

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

		public Gdk.Monitor PrimaryMonitor { 
			get {
				IntPtr raw_ret = gdk_display_get_primary_monitor(Handle);
				Gdk.Monitor ret = GLib.Object.GetObject(raw_ret) as Gdk.Monitor;
				return ret;
			}
		}

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

		[Obsolete]
		public Gdk.Screen GetScreen(int screen_num) {
			IntPtr raw_ret = gdk_display_get_screen(Handle, screen_num);
			Gdk.Screen ret = GLib.Object.GetObject(raw_ret) as Gdk.Screen;
			return ret;
		}

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

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

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

		[Obsolete]
		public Gdk.Window GetWindowAtPointer(out int win_x, out int win_y) {
			IntPtr raw_ret = gdk_display_get_window_at_pointer(Handle, out win_x, out win_y);
			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
			return ret;
		}

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

		public bool HasPending { 
			get {
				bool raw_ret = gdk_display_has_pending(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsClosed { 
			get {
				bool raw_ret = gdk_display_is_closed(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		[Obsolete]
		public void KeyboardUngrab(uint time_) {
			gdk_display_keyboard_ungrab(Handle, time_);
		}

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

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

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

		public void NotifyStartupComplete(string startup_id) {
			IntPtr native_startup_id = GLib.Marshaller.StringToPtrGStrdup (startup_id);
			gdk_display_notify_startup_complete(Handle, native_startup_id);
			GLib.Marshaller.Free (native_startup_id);
		}

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

		public static Gdk.Display Open(string display_name) {
			IntPtr native_display_name = GLib.Marshaller.StringToPtrGStrdup (display_name);
			IntPtr raw_ret = gdk_display_open(native_display_name);
			Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
			GLib.Marshaller.Free (native_display_name);
			return ret;
		}

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

		[Obsolete]
		public static Gdk.Display OpenDefaultLibgtkOnly() {
			IntPtr raw_ret = gdk_display_open_default_libgtk_only();
			Gdk.Display ret = GLib.Object.GetObject(raw_ret) as Gdk.Display;
			return ret;
		}

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

		public Gdk.Event PeekEvent() {
			IntPtr raw_ret = gdk_display_peek_event(Handle);
			Gdk.Event ret = Gdk.Event.GetEvent (raw_ret);
			return ret;
		}

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

		[Obsolete]
		public bool PointerIsGrabbed() {
			bool raw_ret = gdk_display_pointer_is_grabbed(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		[Obsolete]
		public void PointerUngrab(uint time_) {
			gdk_display_pointer_ungrab(Handle, time_);
		}

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

		public void PutEvent(Gdk.Event evnt) {
			gdk_display_put_event(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
		}

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

		public bool RequestSelectionNotification(Gdk.Atom selection) {
			bool raw_ret = gdk_display_request_selection_notification(Handle, selection == null ? IntPtr.Zero : selection.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public uint DoubleClickDistance { 
			set {
				gdk_display_set_double_click_distance(Handle, value);
			}
		}

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

		public uint DoubleClickTime { 
			set {
				gdk_display_set_double_click_time(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_display_store_clipboard(IntPtr raw, IntPtr clipboard_window, uint time_, IntPtr targets, int n_targets);
		static d_gdk_display_store_clipboard gdk_display_store_clipboard = FuncLoader.LoadFunction<d_gdk_display_store_clipboard>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_store_clipboard"));

		public void StoreClipboard(Gdk.Window clipboard_window, uint time_, Gdk.Atom targets, int n_targets) {
			gdk_display_store_clipboard(Handle, clipboard_window == null ? IntPtr.Zero : clipboard_window.Handle, time_, targets == null ? IntPtr.Zero : targets.Handle, n_targets);
		}

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

		public bool SupportsClipboardPersistence() {
			bool raw_ret = gdk_display_supports_clipboard_persistence(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		[Obsolete]
		public bool SupportsComposite { 
			get {
				bool raw_ret = gdk_display_supports_composite(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool SupportsCursorAlpha() {
			bool raw_ret = gdk_display_supports_cursor_alpha(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SupportsCursorColor() {
			bool raw_ret = gdk_display_supports_cursor_color(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SupportsInputShapes { 
			get {
				bool raw_ret = gdk_display_supports_input_shapes(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool SupportsSelectionNotification() {
			bool raw_ret = gdk_display_supports_selection_notification(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SupportsShapes { 
			get {
				bool raw_ret = gdk_display_supports_shapes(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public void Sync() {
			gdk_display_sync(Handle);
		}

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

		[Obsolete]
		public void WarpPointer(Gdk.Screen screen, int x, int y) {
			gdk_display_warp_pointer(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
	}
}