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

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

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

		protected Screen() : base(IntPtr.Zero)
		{
			CreateNativeObject (new string [0], new GLib.Value [0]);
		}

		static GetDisplayNativeDelegate GetDisplay_cb_delegate;
		static GetDisplayNativeDelegate GetDisplayVMCallback {
			get {
				if (GetDisplay_cb_delegate == null)
					GetDisplay_cb_delegate = new GetDisplayNativeDelegate (GetDisplay_cb);
				return GetDisplay_cb_delegate;
			}
		}

		static void OverrideGetDisplay (GLib.GType gtype)
		{
			OverrideGetDisplay (gtype, GetDisplayVMCallback);
		}

		static void OverrideGetDisplay (GLib.GType gtype, GetDisplayNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_display"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetDisplay_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Display __result;
				__result = __obj.OnGetDisplay ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetDisplay")]
		protected virtual Gdk.Display OnGetDisplay ()
		{
			return InternalGetDisplay ();
		}

		private Gdk.Display InternalGetDisplay ()
		{
			GetDisplayNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_display"));
				unmanaged = (GetDisplayNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetDisplayNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetWidthNativeDelegate GetWidth_cb_delegate;
		static GetWidthNativeDelegate GetWidthVMCallback {
			get {
				if (GetWidth_cb_delegate == null)
					GetWidth_cb_delegate = new GetWidthNativeDelegate (GetWidth_cb);
				return GetWidth_cb_delegate;
			}
		}

		static void OverrideGetWidth (GLib.GType gtype)
		{
			OverrideGetWidth (gtype, GetWidthVMCallback);
		}

		static void OverrideGetWidth (GLib.GType gtype, GetWidthNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_width"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetWidth")]
		protected virtual int OnGetWidth ()
		{
			return InternalGetWidth ();
		}

		private int InternalGetWidth ()
		{
			GetWidthNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_width"));
				unmanaged = (GetWidthNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetWidthNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetHeightNativeDelegate GetHeight_cb_delegate;
		static GetHeightNativeDelegate GetHeightVMCallback {
			get {
				if (GetHeight_cb_delegate == null)
					GetHeight_cb_delegate = new GetHeightNativeDelegate (GetHeight_cb);
				return GetHeight_cb_delegate;
			}
		}

		static void OverrideGetHeight (GLib.GType gtype)
		{
			OverrideGetHeight (gtype, GetHeightVMCallback);
		}

		static void OverrideGetHeight (GLib.GType gtype, GetHeightNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_height"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetHeight")]
		protected virtual int OnGetHeight ()
		{
			return InternalGetHeight ();
		}

		private int InternalGetHeight ()
		{
			GetHeightNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_height"));
				unmanaged = (GetHeightNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetHeightNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetWidthMmNativeDelegate GetWidthMm_cb_delegate;
		static GetWidthMmNativeDelegate GetWidthMmVMCallback {
			get {
				if (GetWidthMm_cb_delegate == null)
					GetWidthMm_cb_delegate = new GetWidthMmNativeDelegate (GetWidthMm_cb);
				return GetWidthMm_cb_delegate;
			}
		}

		static void OverrideGetWidthMm (GLib.GType gtype)
		{
			OverrideGetWidthMm (gtype, GetWidthMmVMCallback);
		}

		static void OverrideGetWidthMm (GLib.GType gtype, GetWidthMmNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_width_mm"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetWidthMm")]
		protected virtual int OnGetWidthMm ()
		{
			return InternalGetWidthMm ();
		}

		private int InternalGetWidthMm ()
		{
			GetWidthMmNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_width_mm"));
				unmanaged = (GetWidthMmNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetWidthMmNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetHeightMmNativeDelegate GetHeightMm_cb_delegate;
		static GetHeightMmNativeDelegate GetHeightMmVMCallback {
			get {
				if (GetHeightMm_cb_delegate == null)
					GetHeightMm_cb_delegate = new GetHeightMmNativeDelegate (GetHeightMm_cb);
				return GetHeightMm_cb_delegate;
			}
		}

		static void OverrideGetHeightMm (GLib.GType gtype)
		{
			OverrideGetHeightMm (gtype, GetHeightMmVMCallback);
		}

		static void OverrideGetHeightMm (GLib.GType gtype, GetHeightMmNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_height_mm"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetHeightMm")]
		protected virtual int OnGetHeightMm ()
		{
			return InternalGetHeightMm ();
		}

		private int InternalGetHeightMm ()
		{
			GetHeightMmNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_height_mm"));
				unmanaged = (GetHeightMmNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetHeightMmNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetNumberNativeDelegate GetNumber_cb_delegate;
		static GetNumberNativeDelegate GetNumberVMCallback {
			get {
				if (GetNumber_cb_delegate == null)
					GetNumber_cb_delegate = new GetNumberNativeDelegate (GetNumber_cb);
				return GetNumber_cb_delegate;
			}
		}

		static void OverrideGetNumber (GLib.GType gtype)
		{
			OverrideGetNumber (gtype, GetNumberVMCallback);
		}

		static void OverrideGetNumber (GLib.GType gtype, GetNumberNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_number"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetNumber")]
		protected virtual int OnGetNumber ()
		{
			return InternalGetNumber ();
		}

		private int InternalGetNumber ()
		{
			GetNumberNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_number"));
				unmanaged = (GetNumberNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetNumberNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetRootWindowNativeDelegate GetRootWindow_cb_delegate;
		static GetRootWindowNativeDelegate GetRootWindowVMCallback {
			get {
				if (GetRootWindow_cb_delegate == null)
					GetRootWindow_cb_delegate = new GetRootWindowNativeDelegate (GetRootWindow_cb);
				return GetRootWindow_cb_delegate;
			}
		}

		static void OverrideGetRootWindow (GLib.GType gtype)
		{
			OverrideGetRootWindow (gtype, GetRootWindowVMCallback);
		}

		static void OverrideGetRootWindow (GLib.GType gtype, GetRootWindowNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_root_window"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetRootWindow_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Window __result;
				__result = __obj.OnGetRootWindow ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetRootWindow")]
		protected virtual Gdk.Window OnGetRootWindow ()
		{
			return InternalGetRootWindow ();
		}

		private Gdk.Window InternalGetRootWindow ()
		{
			GetRootWindowNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_root_window"));
				unmanaged = (GetRootWindowNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetRootWindowNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		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((Delegate) callback);
			}
		}

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

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

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

		private int InternalGetNMonitors ()
		{
			GetNMonitorsNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_n_monitors"));
				unmanaged = (GetNMonitorsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetNMonitorsNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		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((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetPrimaryMonitor")]
		protected virtual int OnGetPrimaryMonitor ()
		{
			return InternalGetPrimaryMonitor ();
		}

		private int InternalGetPrimaryMonitor ()
		{
			GetPrimaryMonitorNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_primary_monitor"));
				unmanaged = (GetPrimaryMonitorNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetPrimaryMonitorNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetMonitorWidthMmNativeDelegate GetMonitorWidthMm_cb_delegate;
		static GetMonitorWidthMmNativeDelegate GetMonitorWidthMmVMCallback {
			get {
				if (GetMonitorWidthMm_cb_delegate == null)
					GetMonitorWidthMm_cb_delegate = new GetMonitorWidthMmNativeDelegate (GetMonitorWidthMm_cb);
				return GetMonitorWidthMm_cb_delegate;
			}
		}

		static void OverrideGetMonitorWidthMm (GLib.GType gtype)
		{
			OverrideGetMonitorWidthMm (gtype, GetMonitorWidthMmVMCallback);
		}

		static void OverrideGetMonitorWidthMm (GLib.GType gtype, GetMonitorWidthMmNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_width_mm"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetMonitorWidthMmNativeDelegate (IntPtr inst, int monitor_num);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetMonitorWidthMm")]
		protected virtual int OnGetMonitorWidthMm (int monitor_num)
		{
			return InternalGetMonitorWidthMm (monitor_num);
		}

		private int InternalGetMonitorWidthMm (int monitor_num)
		{
			GetMonitorWidthMmNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_width_mm"));
				unmanaged = (GetMonitorWidthMmNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMonitorWidthMmNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetMonitorHeightMmNativeDelegate GetMonitorHeightMm_cb_delegate;
		static GetMonitorHeightMmNativeDelegate GetMonitorHeightMmVMCallback {
			get {
				if (GetMonitorHeightMm_cb_delegate == null)
					GetMonitorHeightMm_cb_delegate = new GetMonitorHeightMmNativeDelegate (GetMonitorHeightMm_cb);
				return GetMonitorHeightMm_cb_delegate;
			}
		}

		static void OverrideGetMonitorHeightMm (GLib.GType gtype)
		{
			OverrideGetMonitorHeightMm (gtype, GetMonitorHeightMmVMCallback);
		}

		static void OverrideGetMonitorHeightMm (GLib.GType gtype, GetMonitorHeightMmNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_height_mm"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetMonitorHeightMmNativeDelegate (IntPtr inst, int monitor_num);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetMonitorHeightMm")]
		protected virtual int OnGetMonitorHeightMm (int monitor_num)
		{
			return InternalGetMonitorHeightMm (monitor_num);
		}

		private int InternalGetMonitorHeightMm (int monitor_num)
		{
			GetMonitorHeightMmNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_height_mm"));
				unmanaged = (GetMonitorHeightMmNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMonitorHeightMmNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetMonitorPlugNameNativeDelegate GetMonitorPlugName_cb_delegate;
		static GetMonitorPlugNameNativeDelegate GetMonitorPlugNameVMCallback {
			get {
				if (GetMonitorPlugName_cb_delegate == null)
					GetMonitorPlugName_cb_delegate = new GetMonitorPlugNameNativeDelegate (GetMonitorPlugName_cb);
				return GetMonitorPlugName_cb_delegate;
			}
		}

		static void OverrideGetMonitorPlugName (GLib.GType gtype)
		{
			OverrideGetMonitorPlugName (gtype, GetMonitorPlugNameVMCallback);
		}

		static void OverrideGetMonitorPlugName (GLib.GType gtype, GetMonitorPlugNameNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_plug_name"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr GetMonitorPlugNameNativeDelegate (IntPtr inst, int monitor_num);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetMonitorPlugName")]
		protected virtual string OnGetMonitorPlugName (int monitor_num)
		{
			return InternalGetMonitorPlugName (monitor_num);
		}

		private string InternalGetMonitorPlugName (int monitor_num)
		{
			GetMonitorPlugNameNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_plug_name"));
				unmanaged = (GetMonitorPlugNameNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMonitorPlugNameNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetMonitorGeometryNativeDelegate GetMonitorGeometry_cb_delegate;
		static GetMonitorGeometryNativeDelegate GetMonitorGeometryVMCallback {
			get {
				if (GetMonitorGeometry_cb_delegate == null)
					GetMonitorGeometry_cb_delegate = new GetMonitorGeometryNativeDelegate (GetMonitorGeometry_cb);
				return GetMonitorGeometry_cb_delegate;
			}
		}

		static void OverrideGetMonitorGeometry (GLib.GType gtype)
		{
			OverrideGetMonitorGeometry (gtype, GetMonitorGeometryVMCallback);
		}

		static void OverrideGetMonitorGeometry (GLib.GType gtype, GetMonitorGeometryNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_geometry"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetMonitorGeometryNativeDelegate (IntPtr inst, int monitor_num, IntPtr dest);

		static void GetMonitorGeometry_cb (IntPtr inst, int monitor_num, IntPtr dest)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				__obj.OnGetMonitorGeometry (monitor_num, (Gdk.Rectangle) Marshal.PtrToStructure (dest, typeof (Gdk.Rectangle)));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetMonitorGeometry")]
		protected virtual void OnGetMonitorGeometry (int monitor_num, Gdk.Rectangle dest)
		{
			InternalGetMonitorGeometry (monitor_num, dest);
		}

		private void InternalGetMonitorGeometry (int monitor_num, Gdk.Rectangle dest)
		{
			GetMonitorGeometryNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_geometry"));
				unmanaged = (GetMonitorGeometryNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMonitorGeometryNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_dest = GLib.Marshaller.StructureToPtrAlloc (dest);
			unmanaged (this.Handle, monitor_num, native_dest);
			Marshal.FreeHGlobal (native_dest);
		}

		static GetMonitorWorkareaNativeDelegate GetMonitorWorkarea_cb_delegate;
		static GetMonitorWorkareaNativeDelegate GetMonitorWorkareaVMCallback {
			get {
				if (GetMonitorWorkarea_cb_delegate == null)
					GetMonitorWorkarea_cb_delegate = new GetMonitorWorkareaNativeDelegate (GetMonitorWorkarea_cb);
				return GetMonitorWorkarea_cb_delegate;
			}
		}

		static void OverrideGetMonitorWorkarea (GLib.GType gtype)
		{
			OverrideGetMonitorWorkarea (gtype, GetMonitorWorkareaVMCallback);
		}

		static void OverrideGetMonitorWorkarea (GLib.GType gtype, GetMonitorWorkareaNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_workarea"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetMonitorWorkareaNativeDelegate (IntPtr inst, int monitor_num, IntPtr dest);

		static void GetMonitorWorkarea_cb (IntPtr inst, int monitor_num, IntPtr dest)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				__obj.OnGetMonitorWorkarea (monitor_num, (Gdk.Rectangle) Marshal.PtrToStructure (dest, typeof (Gdk.Rectangle)));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetMonitorWorkarea")]
		protected virtual void OnGetMonitorWorkarea (int monitor_num, Gdk.Rectangle dest)
		{
			InternalGetMonitorWorkarea (monitor_num, dest);
		}

		private void InternalGetMonitorWorkarea (int monitor_num, Gdk.Rectangle dest)
		{
			GetMonitorWorkareaNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_workarea"));
				unmanaged = (GetMonitorWorkareaNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMonitorWorkareaNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_dest = GLib.Marshaller.StructureToPtrAlloc (dest);
			unmanaged (this.Handle, monitor_num, native_dest);
			Marshal.FreeHGlobal (native_dest);
		}

		static ListVisualsNativeDelegate ListVisuals_cb_delegate;
		static ListVisualsNativeDelegate ListVisualsVMCallback {
			get {
				if (ListVisuals_cb_delegate == null)
					ListVisuals_cb_delegate = new ListVisualsNativeDelegate (ListVisuals_cb);
				return ListVisuals_cb_delegate;
			}
		}

		static void OverrideListVisuals (GLib.GType gtype)
		{
			OverrideListVisuals (gtype, ListVisualsVMCallback);
		}

		static void OverrideListVisuals (GLib.GType gtype, ListVisualsNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("list_visuals"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr ListVisuals_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				GLib.List __result;
				__result = __obj.OnListVisuals ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideListVisuals")]
		protected virtual GLib.List OnListVisuals ()
		{
			return InternalListVisuals ();
		}

		private GLib.List InternalListVisuals ()
		{
			ListVisualsNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("list_visuals"));
				unmanaged = (ListVisualsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ListVisualsNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return new GLib.List(__result);
		}

		static GetSystemVisualNativeDelegate GetSystemVisual_cb_delegate;
		static GetSystemVisualNativeDelegate GetSystemVisualVMCallback {
			get {
				if (GetSystemVisual_cb_delegate == null)
					GetSystemVisual_cb_delegate = new GetSystemVisualNativeDelegate (GetSystemVisual_cb);
				return GetSystemVisual_cb_delegate;
			}
		}

		static void OverrideGetSystemVisual (GLib.GType gtype)
		{
			OverrideGetSystemVisual (gtype, GetSystemVisualVMCallback);
		}

		static void OverrideGetSystemVisual (GLib.GType gtype, GetSystemVisualNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_system_visual"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetSystemVisual_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Visual __result;
				__result = __obj.OnGetSystemVisual ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetSystemVisual")]
		protected virtual Gdk.Visual OnGetSystemVisual ()
		{
			return InternalGetSystemVisual ();
		}

		private Gdk.Visual InternalGetSystemVisual ()
		{
			GetSystemVisualNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_system_visual"));
				unmanaged = (GetSystemVisualNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetSystemVisualNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetRgbaVisualNativeDelegate GetRgbaVisual_cb_delegate;
		static GetRgbaVisualNativeDelegate GetRgbaVisualVMCallback {
			get {
				if (GetRgbaVisual_cb_delegate == null)
					GetRgbaVisual_cb_delegate = new GetRgbaVisualNativeDelegate (GetRgbaVisual_cb);
				return GetRgbaVisual_cb_delegate;
			}
		}

		static void OverrideGetRgbaVisual (GLib.GType gtype)
		{
			OverrideGetRgbaVisual (gtype, GetRgbaVisualVMCallback);
		}

		static void OverrideGetRgbaVisual (GLib.GType gtype, GetRgbaVisualNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_rgba_visual"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetRgbaVisual_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Visual __result;
				__result = __obj.OnGetRgbaVisual ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetRgbaVisual")]
		protected virtual Gdk.Visual OnGetRgbaVisual ()
		{
			return InternalGetRgbaVisual ();
		}

		private Gdk.Visual InternalGetRgbaVisual ()
		{
			GetRgbaVisualNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_rgba_visual"));
				unmanaged = (GetRgbaVisualNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetRgbaVisualNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static IsCompositedNativeDelegate IsComposited_cb_delegate;
		static IsCompositedNativeDelegate IsCompositedVMCallback {
			get {
				if (IsComposited_cb_delegate == null)
					IsComposited_cb_delegate = new IsCompositedNativeDelegate (IsComposited_cb);
				return IsComposited_cb_delegate;
			}
		}

		static void OverrideIsComposited (GLib.GType gtype)
		{
			OverrideIsComposited (gtype, IsCompositedVMCallback);
		}

		static void OverrideIsComposited (GLib.GType gtype, IsCompositedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("is_composited"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideIsComposited")]
		protected virtual bool OnIsComposited ()
		{
			return InternalIsComposited ();
		}

		private bool InternalIsComposited ()
		{
			IsCompositedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("is_composited"));
				unmanaged = (IsCompositedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(IsCompositedNativeDelegate));
			}
			if (unmanaged == null) return false;

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

		static MakeDisplayNameNativeDelegate MakeDisplayName_cb_delegate;
		static MakeDisplayNameNativeDelegate MakeDisplayNameVMCallback {
			get {
				if (MakeDisplayName_cb_delegate == null)
					MakeDisplayName_cb_delegate = new MakeDisplayNameNativeDelegate (MakeDisplayName_cb);
				return MakeDisplayName_cb_delegate;
			}
		}

		static void OverrideMakeDisplayName (GLib.GType gtype)
		{
			OverrideMakeDisplayName (gtype, MakeDisplayNameVMCallback);
		}

		static void OverrideMakeDisplayName (GLib.GType gtype, MakeDisplayNameNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("make_display_name"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideMakeDisplayName")]
		protected virtual string OnMakeDisplayName ()
		{
			return InternalMakeDisplayName ();
		}

		private string InternalMakeDisplayName ()
		{
			MakeDisplayNameNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("make_display_name"));
				unmanaged = (MakeDisplayNameNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(MakeDisplayNameNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetActiveWindowNativeDelegate GetActiveWindow_cb_delegate;
		static GetActiveWindowNativeDelegate GetActiveWindowVMCallback {
			get {
				if (GetActiveWindow_cb_delegate == null)
					GetActiveWindow_cb_delegate = new GetActiveWindowNativeDelegate (GetActiveWindow_cb);
				return GetActiveWindow_cb_delegate;
			}
		}

		static void OverrideGetActiveWindow (GLib.GType gtype)
		{
			OverrideGetActiveWindow (gtype, GetActiveWindowVMCallback);
		}

		static void OverrideGetActiveWindow (GLib.GType gtype, GetActiveWindowNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_active_window"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetActiveWindow_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Window __result;
				__result = __obj.OnGetActiveWindow ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetActiveWindow")]
		protected virtual Gdk.Window OnGetActiveWindow ()
		{
			return InternalGetActiveWindow ();
		}

		private Gdk.Window InternalGetActiveWindow ()
		{
			GetActiveWindowNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_active_window"));
				unmanaged = (GetActiveWindowNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetActiveWindowNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static GetWindowStackNativeDelegate GetWindowStack_cb_delegate;
		static GetWindowStackNativeDelegate GetWindowStackVMCallback {
			get {
				if (GetWindowStack_cb_delegate == null)
					GetWindowStack_cb_delegate = new GetWindowStackNativeDelegate (GetWindowStack_cb);
				return GetWindowStack_cb_delegate;
			}
		}

		static void OverrideGetWindowStack (GLib.GType gtype)
		{
			OverrideGetWindowStack (gtype, GetWindowStackVMCallback);
		}

		static void OverrideGetWindowStack (GLib.GType gtype, GetWindowStackNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_window_stack"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr GetWindowStack_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Window[] __result;
				__result = __obj.OnGetWindowStack ();
				return new GLib.List(__result, typeof (Gdk.Window), true, true) == null ? IntPtr.Zero : new GLib.List(__result, typeof (Gdk.Window), true, true).Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetWindowStack")]
		protected virtual Gdk.Window[] OnGetWindowStack ()
		{
			return InternalGetWindowStack ();
		}

		private Gdk.Window[] InternalGetWindowStack ()
		{
			GetWindowStackNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_window_stack"));
				unmanaged = (GetWindowStackNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetWindowStackNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return (Gdk.Window[]) GLib.Marshaller.ListPtrToArray (__result, typeof(GLib.List), true, true, typeof(Gdk.Window));
		}

		static BroadcastClientMessageNativeDelegate BroadcastClientMessage_cb_delegate;
		static BroadcastClientMessageNativeDelegate BroadcastClientMessageVMCallback {
			get {
				if (BroadcastClientMessage_cb_delegate == null)
					BroadcastClientMessage_cb_delegate = new BroadcastClientMessageNativeDelegate (BroadcastClientMessage_cb);
				return BroadcastClientMessage_cb_delegate;
			}
		}

		static void OverrideBroadcastClientMessage (GLib.GType gtype)
		{
			OverrideBroadcastClientMessage (gtype, BroadcastClientMessageVMCallback);
		}

		static void OverrideBroadcastClientMessage (GLib.GType gtype, BroadcastClientMessageNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("broadcast_client_message"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideBroadcastClientMessage")]
		protected virtual void OnBroadcastClientMessage (Gdk.Event evnt)
		{
			InternalBroadcastClientMessage (evnt);
		}

		private void InternalBroadcastClientMessage (Gdk.Event evnt)
		{
			BroadcastClientMessageNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("broadcast_client_message"));
				unmanaged = (BroadcastClientMessageNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(BroadcastClientMessageNativeDelegate));
			}
			if (unmanaged == null) return;

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

		static GetSettingNativeDelegate GetSetting_cb_delegate;
		static GetSettingNativeDelegate GetSettingVMCallback {
			get {
				if (GetSetting_cb_delegate == null)
					GetSetting_cb_delegate = new GetSettingNativeDelegate (GetSetting_cb);
				return GetSetting_cb_delegate;
			}
		}

		static void OverrideGetSetting (GLib.GType gtype)
		{
			OverrideGetSetting (gtype, GetSettingVMCallback);
		}

		static void OverrideGetSetting (GLib.GType gtype, GetSettingNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_setting"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GetSettingNativeDelegate (IntPtr inst, IntPtr name, IntPtr value);

		static bool GetSetting_cb (IntPtr inst, IntPtr name, IntPtr value)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				bool __result;
				__result = __obj.OnGetSetting (GLib.Marshaller.Utf8PtrToString (name), (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetSetting")]
		protected virtual bool OnGetSetting (string name, GLib.Value value)
		{
			return InternalGetSetting (name, value);
		}

		private bool InternalGetSetting (string name, GLib.Value value)
		{
			GetSettingNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_setting"));
				unmanaged = (GetSettingNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetSettingNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			bool __result = unmanaged (this.Handle, native_name, native_value);
			GLib.Marshaller.Free (native_name);
			Marshal.FreeHGlobal (native_value);
			return __result;
		}

		static VisualGetBestDepthNativeDelegate VisualGetBestDepth_cb_delegate;
		static VisualGetBestDepthNativeDelegate VisualGetBestDepthVMCallback {
			get {
				if (VisualGetBestDepth_cb_delegate == null)
					VisualGetBestDepth_cb_delegate = new VisualGetBestDepthNativeDelegate (VisualGetBestDepth_cb);
				return VisualGetBestDepth_cb_delegate;
			}
		}

		static void OverrideVisualGetBestDepth (GLib.GType gtype)
		{
			OverrideVisualGetBestDepth (gtype, VisualGetBestDepthVMCallback);
		}

		static void OverrideVisualGetBestDepth (GLib.GType gtype, VisualGetBestDepthNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_depth"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideVisualGetBestDepth")]
		protected virtual int OnVisualGetBestDepth ()
		{
			return InternalVisualGetBestDepth ();
		}

		private int InternalVisualGetBestDepth ()
		{
			VisualGetBestDepthNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_depth"));
				unmanaged = (VisualGetBestDepthNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(VisualGetBestDepthNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static VisualGetBestTypeNativeDelegate VisualGetBestType_cb_delegate;
		static VisualGetBestTypeNativeDelegate VisualGetBestTypeVMCallback {
			get {
				if (VisualGetBestType_cb_delegate == null)
					VisualGetBestType_cb_delegate = new VisualGetBestTypeNativeDelegate (VisualGetBestType_cb);
				return VisualGetBestType_cb_delegate;
			}
		}

		static void OverrideVisualGetBestType (GLib.GType gtype)
		{
			OverrideVisualGetBestType (gtype, VisualGetBestTypeVMCallback);
		}

		static void OverrideVisualGetBestType (GLib.GType gtype, VisualGetBestTypeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_type"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideVisualGetBestType")]
		protected virtual Gdk.VisualType OnVisualGetBestType ()
		{
			return InternalVisualGetBestType ();
		}

		private Gdk.VisualType InternalVisualGetBestType ()
		{
			VisualGetBestTypeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_type"));
				unmanaged = (VisualGetBestTypeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(VisualGetBestTypeNativeDelegate));
			}
			if (unmanaged == null) return (Gdk.VisualType) 0;

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

		static VisualGetBestNativeDelegate VisualGetBest_cb_delegate;
		static VisualGetBestNativeDelegate VisualGetBestVMCallback {
			get {
				if (VisualGetBest_cb_delegate == null)
					VisualGetBest_cb_delegate = new VisualGetBestNativeDelegate (VisualGetBest_cb);
				return VisualGetBest_cb_delegate;
			}
		}

		static void OverrideVisualGetBest (GLib.GType gtype)
		{
			OverrideVisualGetBest (gtype, VisualGetBestVMCallback);
		}

		static void OverrideVisualGetBest (GLib.GType gtype, VisualGetBestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static IntPtr VisualGetBest_cb (IntPtr inst)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Visual __result;
				__result = __obj.OnVisualGetBest ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideVisualGetBest")]
		protected virtual Gdk.Visual OnVisualGetBest ()
		{
			return InternalVisualGetBest ();
		}

		private Gdk.Visual InternalVisualGetBest ()
		{
			VisualGetBestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best"));
				unmanaged = (VisualGetBestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(VisualGetBestNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static VisualGetBestWithDepthNativeDelegate VisualGetBestWithDepth_cb_delegate;
		static VisualGetBestWithDepthNativeDelegate VisualGetBestWithDepthVMCallback {
			get {
				if (VisualGetBestWithDepth_cb_delegate == null)
					VisualGetBestWithDepth_cb_delegate = new VisualGetBestWithDepthNativeDelegate (VisualGetBestWithDepth_cb);
				return VisualGetBestWithDepth_cb_delegate;
			}
		}

		static void OverrideVisualGetBestWithDepth (GLib.GType gtype)
		{
			OverrideVisualGetBestWithDepth (gtype, VisualGetBestWithDepthVMCallback);
		}

		static void OverrideVisualGetBestWithDepth (GLib.GType gtype, VisualGetBestWithDepthNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_with_depth"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr VisualGetBestWithDepthNativeDelegate (IntPtr inst, int depth);

		static IntPtr VisualGetBestWithDepth_cb (IntPtr inst, int depth)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Visual __result;
				__result = __obj.OnVisualGetBestWithDepth (depth);
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideVisualGetBestWithDepth")]
		protected virtual Gdk.Visual OnVisualGetBestWithDepth (int depth)
		{
			return InternalVisualGetBestWithDepth (depth);
		}

		private Gdk.Visual InternalVisualGetBestWithDepth (int depth)
		{
			VisualGetBestWithDepthNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_with_depth"));
				unmanaged = (VisualGetBestWithDepthNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(VisualGetBestWithDepthNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static VisualGetBestWithTypeNativeDelegate VisualGetBestWithType_cb_delegate;
		static VisualGetBestWithTypeNativeDelegate VisualGetBestWithTypeVMCallback {
			get {
				if (VisualGetBestWithType_cb_delegate == null)
					VisualGetBestWithType_cb_delegate = new VisualGetBestWithTypeNativeDelegate (VisualGetBestWithType_cb);
				return VisualGetBestWithType_cb_delegate;
			}
		}

		static void OverrideVisualGetBestWithType (GLib.GType gtype)
		{
			OverrideVisualGetBestWithType (gtype, VisualGetBestWithTypeVMCallback);
		}

		static void OverrideVisualGetBestWithType (GLib.GType gtype, VisualGetBestWithTypeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_with_type"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr VisualGetBestWithTypeNativeDelegate (IntPtr inst, int visual_type);

		static IntPtr VisualGetBestWithType_cb (IntPtr inst, int visual_type)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Visual __result;
				__result = __obj.OnVisualGetBestWithType ((Gdk.VisualType) visual_type);
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideVisualGetBestWithType")]
		protected virtual Gdk.Visual OnVisualGetBestWithType (Gdk.VisualType visual_type)
		{
			return InternalVisualGetBestWithType (visual_type);
		}

		private Gdk.Visual InternalVisualGetBestWithType (Gdk.VisualType visual_type)
		{
			VisualGetBestWithTypeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_with_type"));
				unmanaged = (VisualGetBestWithTypeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(VisualGetBestWithTypeNativeDelegate));
			}
			if (unmanaged == null) return null;

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

		static VisualGetBestWithBothNativeDelegate VisualGetBestWithBoth_cb_delegate;
		static VisualGetBestWithBothNativeDelegate VisualGetBestWithBothVMCallback {
			get {
				if (VisualGetBestWithBoth_cb_delegate == null)
					VisualGetBestWithBoth_cb_delegate = new VisualGetBestWithBothNativeDelegate (VisualGetBestWithBoth_cb);
				return VisualGetBestWithBoth_cb_delegate;
			}
		}

		static void OverrideVisualGetBestWithBoth (GLib.GType gtype)
		{
			OverrideVisualGetBestWithBoth (gtype, VisualGetBestWithBothVMCallback);
		}

		static void OverrideVisualGetBestWithBoth (GLib.GType gtype, VisualGetBestWithBothNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_with_both"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr VisualGetBestWithBothNativeDelegate (IntPtr inst, int depth, int visual_type);

		static IntPtr VisualGetBestWithBoth_cb (IntPtr inst, int depth, int visual_type)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.Visual __result;
				__result = __obj.OnVisualGetBestWithBoth (depth, (Gdk.VisualType) visual_type);
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideVisualGetBestWithBoth")]
		protected virtual Gdk.Visual OnVisualGetBestWithBoth (int depth, Gdk.VisualType visual_type)
		{
			return InternalVisualGetBestWithBoth (depth, visual_type);
		}

		private Gdk.Visual InternalVisualGetBestWithBoth (int depth, Gdk.VisualType visual_type)
		{
			VisualGetBestWithBothNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("visual_get_best_with_both"));
				unmanaged = (VisualGetBestWithBothNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(VisualGetBestWithBothNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, depth, (int) visual_type);
			return GLib.Object.GetObject(__result) as Gdk.Visual;
		}

		static QueryDepthsNativeDelegate QueryDepths_cb_delegate;
		static QueryDepthsNativeDelegate QueryDepthsVMCallback {
			get {
				if (QueryDepths_cb_delegate == null)
					QueryDepths_cb_delegate = new QueryDepthsNativeDelegate (QueryDepths_cb);
				return QueryDepths_cb_delegate;
			}
		}

		static void OverrideQueryDepths (GLib.GType gtype)
		{
			OverrideQueryDepths (gtype, QueryDepthsVMCallback);
		}

		static void OverrideQueryDepths (GLib.GType gtype, QueryDepthsNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_depths"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void QueryDepthsNativeDelegate (IntPtr inst, out int depths, out int count);

		static void QueryDepths_cb (IntPtr inst, out int depths, out int count)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				__obj.OnQueryDepths (out depths, out count);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideQueryDepths")]
		protected virtual void OnQueryDepths (out int depths, out int count)
		{
			InternalQueryDepths (out depths, out count);
		}

		private void InternalQueryDepths (out int depths, out int count)
		{
			QueryDepthsNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query_depths"));
				unmanaged = (QueryDepthsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryDepthsNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out depths, out count);
		}

		static QueryVisualTypesNativeDelegate QueryVisualTypes_cb_delegate;
		static QueryVisualTypesNativeDelegate QueryVisualTypesVMCallback {
			get {
				if (QueryVisualTypes_cb_delegate == null)
					QueryVisualTypes_cb_delegate = new QueryVisualTypesNativeDelegate (QueryVisualTypes_cb);
				return QueryVisualTypes_cb_delegate;
			}
		}

		static void OverrideQueryVisualTypes (GLib.GType gtype)
		{
			OverrideQueryVisualTypes (gtype, QueryVisualTypesVMCallback);
		}

		static void OverrideQueryVisualTypes (GLib.GType gtype, QueryVisualTypesNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_visual_types"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void QueryVisualTypesNativeDelegate (IntPtr inst, out int visual_types, out int count);

		static void QueryVisualTypes_cb (IntPtr inst, out int visual_types, out int count)
		{
			try {
				Screen __obj = GLib.Object.GetObject (inst, false) as Screen;
				Gdk.VisualType myvisual_types;
				__obj.OnQueryVisualTypes (out myvisual_types, out count);
				visual_types = (int) myvisual_types;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideQueryVisualTypes")]
		protected virtual void OnQueryVisualTypes (out Gdk.VisualType visual_types, out int count)
		{
			InternalQueryVisualTypes (out visual_types, out count);
		}

		private void InternalQueryVisualTypes (out Gdk.VisualType visual_types, out int count)
		{
			QueryVisualTypesNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query_visual_types"));
				unmanaged = (QueryVisualTypesNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryVisualTypesNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_visual_types;
			unmanaged (this.Handle, out native_visual_types, out count);
			visual_types = (Gdk.VisualType) native_visual_types;
		}

		static GetMonitorScaleFactorNativeDelegate GetMonitorScaleFactor_cb_delegate;
		static GetMonitorScaleFactorNativeDelegate GetMonitorScaleFactorVMCallback {
			get {
				if (GetMonitorScaleFactor_cb_delegate == null)
					GetMonitorScaleFactor_cb_delegate = new GetMonitorScaleFactorNativeDelegate (GetMonitorScaleFactor_cb);
				return GetMonitorScaleFactor_cb_delegate;
			}
		}

		static void OverrideGetMonitorScaleFactor (GLib.GType gtype)
		{
			OverrideGetMonitorScaleFactor (gtype, GetMonitorScaleFactorVMCallback);
		}

		static void OverrideGetMonitorScaleFactor (GLib.GType gtype, GetMonitorScaleFactorNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_scale_factor"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetMonitorScaleFactorNativeDelegate (IntPtr inst, int monitor_num);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideGetMonitorScaleFactor")]
		protected virtual int OnGetMonitorScaleFactor (int monitor_num)
		{
			return InternalGetMonitorScaleFactor (monitor_num);
		}

		private int InternalGetMonitorScaleFactor (int monitor_num)
		{
			GetMonitorScaleFactorNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_monitor_scale_factor"));
				unmanaged = (GetMonitorScaleFactorNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMonitorScaleFactorNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static SizeChangedNativeDelegate SizeChanged_cb_delegate;
		static SizeChangedNativeDelegate SizeChangedVMCallback {
			get {
				if (SizeChanged_cb_delegate == null)
					SizeChanged_cb_delegate = new SizeChangedNativeDelegate (SizeChanged_cb);
				return SizeChanged_cb_delegate;
			}
		}

		static void OverrideSizeChanged (GLib.GType gtype)
		{
			OverrideSizeChanged (gtype, SizeChangedVMCallback);
		}

		static void OverrideSizeChanged (GLib.GType gtype, SizeChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("size_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideSizeChanged")]
		protected virtual void OnSizeChanged ()
		{
			InternalSizeChanged ();
		}

		private void InternalSizeChanged ()
		{
			SizeChangedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("size_changed"));
				unmanaged = (SizeChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SizeChangedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static CompositedChangedNativeDelegate CompositedChanged_cb_delegate;
		static CompositedChangedNativeDelegate CompositedChangedVMCallback {
			get {
				if (CompositedChanged_cb_delegate == null)
					CompositedChanged_cb_delegate = new CompositedChangedNativeDelegate (CompositedChanged_cb);
				return CompositedChanged_cb_delegate;
			}
		}

		static void OverrideCompositedChanged (GLib.GType gtype)
		{
			OverrideCompositedChanged (gtype, CompositedChangedVMCallback);
		}

		static void OverrideCompositedChanged (GLib.GType gtype, CompositedChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("composited_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideCompositedChanged")]
		protected virtual void OnCompositedChanged ()
		{
			InternalCompositedChanged ();
		}

		private void InternalCompositedChanged ()
		{
			CompositedChangedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("composited_changed"));
				unmanaged = (CompositedChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CompositedChangedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static MonitorsChangedNativeDelegate MonitorsChanged_cb_delegate;
		static MonitorsChangedNativeDelegate MonitorsChangedVMCallback {
			get {
				if (MonitorsChanged_cb_delegate == null)
					MonitorsChanged_cb_delegate = new MonitorsChangedNativeDelegate (MonitorsChanged_cb);
				return MonitorsChanged_cb_delegate;
			}
		}

		static void OverrideMonitorsChanged (GLib.GType gtype)
		{
			OverrideMonitorsChanged (gtype, MonitorsChangedVMCallback);
		}

		static void OverrideMonitorsChanged (GLib.GType gtype, MonitorsChangedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("monitors_changed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Screen), ConnectionMethod="OverrideMonitorsChanged")]
		protected virtual void OnMonitorsChanged ()
		{
			InternalMonitorsChanged ();
		}

		private void InternalMonitorsChanged ()
		{
			MonitorsChangedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("monitors_changed"));
				unmanaged = (MonitorsChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(MonitorsChangedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("get_display"
							, GLib.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_display
							, null
							, "get_width"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_width"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_width
							, "get_display"
							, "get_height"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_height"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_height
							, "get_width"
							, "get_width_mm"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_width_mm"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_width_mm
							, "get_height"
							, "get_height_mm"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_height_mm"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_height_mm
							, "get_width_mm"
							, "get_number"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_number"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_number
							, "get_height_mm"
							, "get_root_window"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_root_window"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_root_window
							, "get_number"
							, "get_n_monitors"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_n_monitors"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_n_monitors
							, "get_root_window"
							, "get_primary_monitor"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_primary_monitor"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_primary_monitor
							, "get_n_monitors"
							, "get_monitor_width_mm"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_monitor_width_mm"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_monitor_width_mm
							, "get_primary_monitor"
							, "get_monitor_height_mm"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_monitor_height_mm"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_monitor_height_mm
							, "get_monitor_width_mm"
							, "get_monitor_plug_name"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_monitor_plug_name"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_monitor_plug_name
							, "get_monitor_height_mm"
							, "get_monitor_geometry"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_monitor_geometry"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_monitor_geometry
							, "get_monitor_plug_name"
							, "get_monitor_workarea"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_monitor_workarea"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_monitor_workarea
							, "get_monitor_geometry"
							, "list_visuals"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("list_visuals"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // list_visuals
							, "get_monitor_workarea"
							, "get_system_visual"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_system_visual"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_system_visual
							, "list_visuals"
							, "get_rgba_visual"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_rgba_visual"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_rgba_visual
							, "get_system_visual"
							, "is_composited"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("is_composited"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // is_composited
							, "get_rgba_visual"
							, "make_display_name"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("make_display_name"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // make_display_name
							, "is_composited"
							, "get_active_window"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_active_window"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_active_window
							, "make_display_name"
							, "get_window_stack"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_window_stack"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_window_stack
							, "get_active_window"
							, "broadcast_client_message"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("broadcast_client_message"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // broadcast_client_message
							, "get_window_stack"
							, "get_setting"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_setting"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_setting
							, "broadcast_client_message"
							, "visual_get_best_depth"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("visual_get_best_depth"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // visual_get_best_depth
							, "get_setting"
							, "visual_get_best_type"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("visual_get_best_type"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // visual_get_best_type
							, "visual_get_best_depth"
							, "visual_get_best"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("visual_get_best"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // visual_get_best
							, "visual_get_best_type"
							, "visual_get_best_with_depth"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("visual_get_best_with_depth"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // visual_get_best_with_depth
							, "visual_get_best"
							, "visual_get_best_with_type"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("visual_get_best_with_type"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // visual_get_best_with_type
							, "visual_get_best_with_depth"
							, "visual_get_best_with_both"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("visual_get_best_with_both"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // visual_get_best_with_both
							, "visual_get_best_with_type"
							, "query_depths"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("query_depths"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // query_depths
							, "visual_get_best_with_both"
							, "query_visual_types"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("query_visual_types"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // query_visual_types
							, "query_depths"
							, "get_monitor_scale_factor"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_monitor_scale_factor"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_monitor_scale_factor
							, "query_visual_types"
							, "size_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("size_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // size_changed
							, "get_monitor_scale_factor"
							, "composited_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("composited_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // composited_changed
							, "size_changed"
							, "monitors_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("monitors_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // monitors_changed
							, "composited_changed"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_active_window(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_default();

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_display(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_height(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_height_mm(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_monitor_at_point(IntPtr raw, int x, int y);

		[Obsolete]
		public int GetMonitorAtPoint(int x, int y) {
			int raw_ret = gdk_screen_get_monitor_at_point(Handle, x, y);
			int ret = raw_ret;
			return ret;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_monitor_at_window(IntPtr raw, IntPtr window);

		[Obsolete]
		public int GetMonitorAtWindow(Gdk.Window window) {
			int raw_ret = gdk_screen_get_monitor_at_window(Handle, window == null ? IntPtr.Zero : window.Handle);
			int ret = raw_ret;
			return ret;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gdk_screen_get_monitor_geometry(IntPtr raw, int monitor_num, IntPtr dest);

		[Obsolete]
		public Gdk.Rectangle GetMonitorGeometry(int monitor_num) {
			Gdk.Rectangle dest;
			IntPtr native_dest = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (Gdk.Rectangle)));
			gdk_screen_get_monitor_geometry(Handle, monitor_num, native_dest);
			dest = (Gdk.Rectangle) Marshal.PtrToStructure (native_dest, typeof (Gdk.Rectangle));
			Marshal.FreeHGlobal (native_dest);
			return dest;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_monitor_height_mm(IntPtr raw, int monitor_num);

		[Obsolete]
		public int GetMonitorHeightMm(int monitor_num) {
			int raw_ret = gdk_screen_get_monitor_height_mm(Handle, monitor_num);
			int ret = raw_ret;
			return ret;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_monitor_plug_name(IntPtr raw, int monitor_num);

		[Obsolete]
		public string GetMonitorPlugName(int monitor_num) {
			IntPtr raw_ret = gdk_screen_get_monitor_plug_name(Handle, monitor_num);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			return ret;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_monitor_scale_factor(IntPtr raw, int monitor_num);

		[Obsolete]
		public int GetMonitorScaleFactor(int monitor_num) {
			int raw_ret = gdk_screen_get_monitor_scale_factor(Handle, monitor_num);
			int ret = raw_ret;
			return ret;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_monitor_width_mm(IntPtr raw, int monitor_num);

		[Obsolete]
		public int GetMonitorWidthMm(int monitor_num) {
			int raw_ret = gdk_screen_get_monitor_width_mm(Handle, monitor_num);
			int ret = raw_ret;
			return ret;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gdk_screen_get_monitor_workarea(IntPtr raw, int monitor_num, IntPtr dest);

		[Obsolete]
		public void GetMonitorWorkarea(int monitor_num, Gdk.Rectangle dest) {
			IntPtr native_dest = GLib.Marshaller.StructureToPtrAlloc (dest);
			gdk_screen_get_monitor_workarea(Handle, monitor_num, native_dest);
			Marshal.FreeHGlobal (native_dest);
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_n_monitors(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_number(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_primary_monitor(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern double gdk_screen_get_resolution(IntPtr raw);

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gdk_screen_set_resolution(IntPtr raw, double dpi);

		public double Resolution { 
			get {
				double raw_ret = gdk_screen_get_resolution(Handle);
				double ret = raw_ret;
				return ret;
			}
			set {
				gdk_screen_set_resolution(Handle, value);
			}
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_rgba_visual(IntPtr raw);

		public Gdk.Visual RgbaVisual { 
			get {
				IntPtr raw_ret = gdk_screen_get_rgba_visual(Handle);
				Gdk.Visual ret = GLib.Object.GetObject(raw_ret) as Gdk.Visual;
				return ret;
			}
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_root_window(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gdk_screen_get_setting(IntPtr raw, IntPtr name, IntPtr value);

		public bool GetSetting(string name, GLib.Value value) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			bool raw_ret = gdk_screen_get_setting(Handle, native_name, native_value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_name);
			Marshal.FreeHGlobal (native_value);
			return ret;
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_system_visual(IntPtr raw);

		public Gdk.Visual SystemVisual { 
			get {
				IntPtr raw_ret = gdk_screen_get_system_visual(Handle);
				Gdk.Visual ret = GLib.Object.GetObject(raw_ret) as Gdk.Visual;
				return ret;
			}
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_type();

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_width(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gdk_screen_get_width_mm(IntPtr raw);

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

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_get_window_stack(IntPtr raw);

		public Gdk.Window[] WindowStack { 
			get {
				IntPtr raw_ret = gdk_screen_get_window_stack(Handle);
				Gdk.Window[] ret = (Gdk.Window[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(Gdk.Window));
				return ret;
			}
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gdk_screen_is_composited(IntPtr raw);

		public bool IsComposited { 
			get {
				bool raw_ret = gdk_screen_is_composited(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gdk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gdk_screen_make_display_name(IntPtr raw);

		[Obsolete]
		public string MakeDisplayName() {
			IntPtr raw_ret = gdk_screen_make_display_name(Handle);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			return ret;
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public 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
	}
}