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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_window_new(IntPtr parent, IntPtr attributes, int attributes_mask);
		static d_gdk_window_new gdk_window_new = FuncLoader.LoadFunction<d_gdk_window_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_new"));

		public Window (Gdk.Window parent, Gdk.WindowAttr attributes, int attributes_mask) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Window)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			IntPtr native_attributes = GLib.Marshaller.StructureToPtrAlloc (attributes);
			Raw = gdk_window_new(parent == null ? IntPtr.Zero : parent.Handle, native_attributes, attributes_mask);
			Marshal.FreeHGlobal (native_attributes);
		}

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

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

		[GLib.Property ("cursor")]
		public Gdk.Cursor Cursor {
			get  {
				IntPtr raw_ret = gdk_window_get_cursor(Handle);
				Gdk.Cursor ret = GLib.Object.GetObject(raw_ret) as Gdk.Cursor;
				return ret;
			}
			set  {
				gdk_window_set_cursor(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[GLib.Signal("pick-embedded-child")]
		public event Gdk.PickEmbeddedChildHandler PickEmbeddedChild {
			add {
				this.AddSignalHandler ("pick-embedded-child", value, typeof (Gdk.PickEmbeddedChildArgs));
			}
			remove {
				this.RemoveSignalHandler ("pick-embedded-child", value);
			}
		}

		[GLib.Signal("create-surface")]
		public event Gdk.CreateSurfaceHandler CreateSurface {
			add {
				this.AddSignalHandler ("create-surface", value, typeof (Gdk.CreateSurfaceArgs));
			}
			remove {
				this.RemoveSignalHandler ("create-surface", value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MovedToRectSignalDelegate (IntPtr inst, IntPtr arg0, IntPtr arg1, bool arg2, bool arg3, IntPtr gch);

		static void MovedToRectSignalCallback (IntPtr inst, IntPtr arg0, IntPtr arg1, bool arg2, bool arg3, IntPtr gch)
		{
			Gdk.MovedToRectArgs args = new Gdk.MovedToRectArgs ();
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[4];
				args.Args[0] = arg0;
				args.Args[1] = arg1;
				args.Args[2] = arg2;
				args.Args[3] = arg3;
				Gdk.MovedToRectHandler handler = (Gdk.MovedToRectHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.Signal("moved-to-rect")]
		public event Gdk.MovedToRectHandler MovedToRect {
			add {
				this.AddSignalHandler ("moved-to-rect", value, new MovedToRectSignalDelegate(MovedToRectSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("moved-to-rect", value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ToEmbedderSignalDelegate (IntPtr inst, double arg0, double arg1, out double arg2, out double arg3, IntPtr gch);

		static void ToEmbedderSignalCallback (IntPtr inst, double arg0, double arg1, out double arg2, out double arg3, IntPtr gch)
		{
			Gdk.ToEmbedderArgs args = new Gdk.ToEmbedderArgs ();
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[4];
				args.Args[0] = arg0;
				args.Args[1] = arg1;
				Gdk.ToEmbedderHandler handler = (Gdk.ToEmbedderHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}

			try {
				arg2 = ((double)args.Args[2]);
				arg3 = ((double)args.Args[3]);
			} catch (Exception) {
				Exception ex = new Exception ("args.RetVal or 'out' property unset or set to incorrect type in Gdk.ToEmbedderHandler callback");
				GLib.ExceptionManager.RaiseUnhandledException (ex, true);
				// NOTREACHED: above call doesn't return.
				throw ex;
			}
		}

		[GLib.Signal("to-embedder")]
		public event Gdk.ToEmbedderHandler ToEmbedder {
			add {
				this.AddSignalHandler ("to-embedder", value, new ToEmbedderSignalDelegate(ToEmbedderSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("to-embedder", value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void FromEmbedderSignalDelegate (IntPtr inst, double arg0, double arg1, out double arg2, out double arg3, IntPtr gch);

		static void FromEmbedderSignalCallback (IntPtr inst, double arg0, double arg1, out double arg2, out double arg3, IntPtr gch)
		{
			Gdk.FromEmbedderArgs args = new Gdk.FromEmbedderArgs ();
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[4];
				args.Args[0] = arg0;
				args.Args[1] = arg1;
				Gdk.FromEmbedderHandler handler = (Gdk.FromEmbedderHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}

			try {
				arg2 = ((double)args.Args[2]);
				arg3 = ((double)args.Args[3]);
			} catch (Exception) {
				Exception ex = new Exception ("args.RetVal or 'out' property unset or set to incorrect type in Gdk.FromEmbedderHandler callback");
				GLib.ExceptionManager.RaiseUnhandledException (ex, true);
				// NOTREACHED: above call doesn't return.
				throw ex;
			}
		}

		[GLib.Signal("from-embedder")]
		public event Gdk.FromEmbedderHandler FromEmbedder {
			add {
				this.AddSignalHandler ("from-embedder", value, new FromEmbedderSignalDelegate(FromEmbedderSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("from-embedder", value);
			}
		}

		static MovedToRectNativeDelegate MovedToRect_cb_delegate;
		static MovedToRectNativeDelegate MovedToRectVMCallback {
			get {
				if (MovedToRect_cb_delegate == null)
					MovedToRect_cb_delegate = new MovedToRectNativeDelegate (MovedToRect_cb);
				return MovedToRect_cb_delegate;
			}
		}

		static void OverrideMovedToRect (GLib.GType gtype)
		{
			OverrideMovedToRect (gtype, MovedToRectVMCallback);
		}

		static void OverrideMovedToRect (GLib.GType gtype, MovedToRectNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "moved-to-rect", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MovedToRectNativeDelegate (IntPtr inst, IntPtr p0, IntPtr p1, bool p2, bool p3);

		static void MovedToRect_cb (IntPtr inst, IntPtr p0, IntPtr p1, bool p2, bool p3)
		{
			try {
				Window __obj = GLib.Object.GetObject (inst, false) as Window;
				__obj.OnMovedToRect (p0, p1, p2, p3);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Window), ConnectionMethod="OverrideMovedToRect")]
		protected virtual void OnMovedToRect (IntPtr p0, IntPtr p1, bool p2, bool p3)
		{
			InternalMovedToRect (p0, p1, p2, p3);
		}

		private void InternalMovedToRect (IntPtr p0, IntPtr p1, bool p2, bool p3)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (5);
			GLib.Value[] vals = new GLib.Value [5];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (p0);
			inst_and_params.Append (vals [1]);
			vals [2] = new GLib.Value (p1);
			inst_and_params.Append (vals [2]);
			vals [3] = new GLib.Value (p2);
			inst_and_params.Append (vals [3]);
			vals [4] = new GLib.Value (p3);
			inst_and_params.Append (vals [4]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static PickEmbeddedChildNativeDelegate PickEmbeddedChild_cb_delegate;
		static PickEmbeddedChildNativeDelegate PickEmbeddedChildVMCallback {
			get {
				if (PickEmbeddedChild_cb_delegate == null)
					PickEmbeddedChild_cb_delegate = new PickEmbeddedChildNativeDelegate (PickEmbeddedChild_cb);
				return PickEmbeddedChild_cb_delegate;
			}
		}

		static void OverridePickEmbeddedChild (GLib.GType gtype)
		{
			OverridePickEmbeddedChild (gtype, PickEmbeddedChildVMCallback);
		}

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

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

		static IntPtr PickEmbeddedChild_cb (IntPtr inst, double x, double y)
		{
			try {
				Window __obj = GLib.Object.GetObject (inst, false) as Window;
				Gdk.Window __result;
				__result = __obj.OnPickEmbeddedChild (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.Window), ConnectionMethod="OverridePickEmbeddedChild")]
		protected virtual Gdk.Window OnPickEmbeddedChild (double x, double y)
		{
			return InternalPickEmbeddedChild (x, y);
		}

		private Gdk.Window InternalPickEmbeddedChild (double x, double y)
		{
			PickEmbeddedChildNativeDelegate unmanaged = class_abi.BaseOverride<PickEmbeddedChildNativeDelegate>(this.LookupGType(), "pick_embedded_child");
			if (unmanaged == null) return null;

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

		static ToEmbedderNativeDelegate ToEmbedder_cb_delegate;
		static ToEmbedderNativeDelegate ToEmbedderVMCallback {
			get {
				if (ToEmbedder_cb_delegate == null)
					ToEmbedder_cb_delegate = new ToEmbedderNativeDelegate (ToEmbedder_cb);
				return ToEmbedder_cb_delegate;
			}
		}

		static void OverrideToEmbedder (GLib.GType gtype)
		{
			OverrideToEmbedder (gtype, ToEmbedderVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ToEmbedderNativeDelegate (IntPtr inst, double offscreen_x, double offscreen_y, out double embedder_x, out double embedder_y);

		static void ToEmbedder_cb (IntPtr inst, double offscreen_x, double offscreen_y, out double embedder_x, out double embedder_y)
		{
			try {
				Window __obj = GLib.Object.GetObject (inst, false) as Window;
				__obj.OnToEmbedder (offscreen_x, offscreen_y, out embedder_x, out embedder_y);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Window), ConnectionMethod="OverrideToEmbedder")]
		protected virtual void OnToEmbedder (double offscreen_x, double offscreen_y, out double embedder_x, out double embedder_y)
		{
			InternalToEmbedder (offscreen_x, offscreen_y, out embedder_x, out embedder_y);
		}

		private void InternalToEmbedder (double offscreen_x, double offscreen_y, out double embedder_x, out double embedder_y)
		{
			ToEmbedderNativeDelegate unmanaged = class_abi.BaseOverride<ToEmbedderNativeDelegate>(this.LookupGType(), "to_embedder");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, offscreen_x, offscreen_y, out embedder_x, out embedder_y);
		}

		static FromEmbedderNativeDelegate FromEmbedder_cb_delegate;
		static FromEmbedderNativeDelegate FromEmbedderVMCallback {
			get {
				if (FromEmbedder_cb_delegate == null)
					FromEmbedder_cb_delegate = new FromEmbedderNativeDelegate (FromEmbedder_cb);
				return FromEmbedder_cb_delegate;
			}
		}

		static void OverrideFromEmbedder (GLib.GType gtype)
		{
			OverrideFromEmbedder (gtype, FromEmbedderVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void FromEmbedderNativeDelegate (IntPtr inst, double embedder_x, double embedder_y, out double offscreen_x, out double offscreen_y);

		static void FromEmbedder_cb (IntPtr inst, double embedder_x, double embedder_y, out double offscreen_x, out double offscreen_y)
		{
			try {
				Window __obj = GLib.Object.GetObject (inst, false) as Window;
				__obj.OnFromEmbedder (embedder_x, embedder_y, out offscreen_x, out offscreen_y);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Window), ConnectionMethod="OverrideFromEmbedder")]
		protected virtual void OnFromEmbedder (double embedder_x, double embedder_y, out double offscreen_x, out double offscreen_y)
		{
			InternalFromEmbedder (embedder_x, embedder_y, out offscreen_x, out offscreen_y);
		}

		private void InternalFromEmbedder (double embedder_x, double embedder_y, out double offscreen_x, out double offscreen_y)
		{
			FromEmbedderNativeDelegate unmanaged = class_abi.BaseOverride<FromEmbedderNativeDelegate>(this.LookupGType(), "from_embedder");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, embedder_x, embedder_y, out offscreen_x, out offscreen_y);
		}

		static CreateSurfaceNativeDelegate CreateSurface_cb_delegate;
		static CreateSurfaceNativeDelegate CreateSurfaceVMCallback {
			get {
				if (CreateSurface_cb_delegate == null)
					CreateSurface_cb_delegate = new CreateSurfaceNativeDelegate (CreateSurface_cb);
				return CreateSurface_cb_delegate;
			}
		}

		static void OverrideCreateSurface (GLib.GType gtype)
		{
			OverrideCreateSurface (gtype, CreateSurfaceVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr CreateSurfaceNativeDelegate (IntPtr inst, int width, int height);

		static IntPtr CreateSurface_cb (IntPtr inst, int width, int height)
		{
			try {
				Window __obj = GLib.Object.GetObject (inst, false) as Window;
				Cairo.Surface __result;
				__result = __obj.OnCreateSurface (width, height);
				return __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gdk.Window), ConnectionMethod="OverrideCreateSurface")]
		protected virtual Cairo.Surface OnCreateSurface (int width, int height)
		{
			return InternalCreateSurface (width, height);
		}

		private Cairo.Surface InternalCreateSurface (int width, int height)
		{
			CreateSurfaceNativeDelegate unmanaged = class_abi.BaseOverride<CreateSurfaceNativeDelegate>(this.LookupGType(), "create_surface");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, width, height);
			return Cairo.Surface.Lookup (__result, true);
		}


		// 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("pick_embedded_child"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // pick_embedded_child
							, null
							, "to_embedder"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("to_embedder"
							, -1
							, (uint) sizeof( IntPtr ) // to_embedder
							, "pick_embedded_child"
							, "from_embedder"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("from_embedder"
							, -1
							, (uint) sizeof( IntPtr ) // from_embedder
							, "to_embedder"
							, "create_surface"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("create_surface"
							, -1
							, (uint) sizeof( IntPtr ) // create_surface
							, "from_embedder"
							, "_gdk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved1
							, "create_surface"
							, "_gdk_reserved2"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved2"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved2
							, "_gdk_reserved1"
							, "_gdk_reserved3"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved3"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved3
							, "_gdk_reserved2"
							, "_gdk_reserved4"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved4"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved4
							, "_gdk_reserved3"
							, "_gdk_reserved5"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved5"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved5
							, "_gdk_reserved4"
							, "_gdk_reserved6"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved6"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved6
							, "_gdk_reserved5"
							, "_gdk_reserved7"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved7"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved7
							, "_gdk_reserved6"
							, "_gdk_reserved8"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gdk_reserved8"
							, -1
							, (uint) sizeof( IntPtr ) // _gdk_reserved8
							, "_gdk_reserved7"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

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

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

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

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

		public Gdk.DrawingContext BeginDrawFrame(Cairo.Region region) {
			IntPtr raw_ret = gdk_window_begin_draw_frame(Handle, region == null ? IntPtr.Zero : region.Handle);
			Gdk.DrawingContext ret = GLib.Object.GetObject(raw_ret) as Gdk.DrawingContext;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_begin_move_drag(IntPtr raw, int button, int root_x, int root_y, uint timestamp);
		static d_gdk_window_begin_move_drag gdk_window_begin_move_drag = FuncLoader.LoadFunction<d_gdk_window_begin_move_drag>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_begin_move_drag"));

		public void BeginMoveDrag(int button, int root_x, int root_y, uint timestamp) {
			gdk_window_begin_move_drag(Handle, button, root_x, root_y, timestamp);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_begin_move_drag_for_device(IntPtr raw, IntPtr device, int button, int root_x, int root_y, uint timestamp);
		static d_gdk_window_begin_move_drag_for_device gdk_window_begin_move_drag_for_device = FuncLoader.LoadFunction<d_gdk_window_begin_move_drag_for_device>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_begin_move_drag_for_device"));

		public void BeginMoveDragForDevice(Gdk.Device device, int button, int root_x, int root_y, uint timestamp) {
			gdk_window_begin_move_drag_for_device(Handle, device == null ? IntPtr.Zero : device.Handle, button, root_x, root_y, timestamp);
		}

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

		[Obsolete]
		public void BeginPaintRect(Gdk.Rectangle rectangle) {
			IntPtr native_rectangle = GLib.Marshaller.StructureToPtrAlloc (rectangle);
			gdk_window_begin_paint_rect(Handle, native_rectangle);
			Marshal.FreeHGlobal (native_rectangle);
		}

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

		[Obsolete]
		public void BeginPaintRegion(Cairo.Region region) {
			gdk_window_begin_paint_region(Handle, region == null ? IntPtr.Zero : region.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_begin_resize_drag(IntPtr raw, int edge, int button, int root_x, int root_y, uint timestamp);
		static d_gdk_window_begin_resize_drag gdk_window_begin_resize_drag = FuncLoader.LoadFunction<d_gdk_window_begin_resize_drag>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_begin_resize_drag"));

		public void BeginResizeDrag(Gdk.WindowEdge edge, int button, int root_x, int root_y, uint timestamp) {
			gdk_window_begin_resize_drag(Handle, (int) edge, button, root_x, root_y, timestamp);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_begin_resize_drag_for_device(IntPtr raw, int edge, IntPtr device, int button, int root_x, int root_y, uint timestamp);
		static d_gdk_window_begin_resize_drag_for_device gdk_window_begin_resize_drag_for_device = FuncLoader.LoadFunction<d_gdk_window_begin_resize_drag_for_device>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_begin_resize_drag_for_device"));

		public void BeginResizeDragForDevice(Gdk.WindowEdge edge, Gdk.Device device, int button, int root_x, int root_y, uint timestamp) {
			gdk_window_begin_resize_drag_for_device(Handle, (int) edge, device == null ? IntPtr.Zero : device.Handle, button, root_x, root_y, timestamp);
		}

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

		[Obsolete]
		public void ConfigureFinished() {
			gdk_window_configure_finished(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_constrain_size(IntPtr geometry, int flags, int width, int height, out int new_width, out int new_height);
		static d_gdk_window_constrain_size gdk_window_constrain_size = FuncLoader.LoadFunction<d_gdk_window_constrain_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_constrain_size"));

		public static void ConstrainSize(Gdk.Geometry geometry, Gdk.WindowHints flags, int width, int height, out int new_width, out int new_height) {
			IntPtr native_geometry = GLib.Marshaller.StructureToPtrAlloc (geometry);
			gdk_window_constrain_size(native_geometry, (int) flags, width, height, out new_width, out new_height);
			Marshal.FreeHGlobal (native_geometry);
		}

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

		public void CoordsFromParent(double parent_x, double parent_y, out double x, out double y) {
			gdk_window_coords_from_parent(Handle, parent_x, parent_y, out x, out y);
		}

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

		public void CoordsToParent(double x, double y, out double parent_x, out double parent_y) {
			gdk_window_coords_to_parent(Handle, x, y, out parent_x, out parent_y);
		}

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

		public unsafe Gdk.GLContext CreateGlContext() {
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = gdk_window_create_gl_context(Handle, out error);
			Gdk.GLContext ret = GLib.Object.GetObject(raw_ret) as Gdk.GLContext;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_window_create_similar_surface(IntPtr raw, int content, int width, int height);
		static d_gdk_window_create_similar_surface gdk_window_create_similar_surface = FuncLoader.LoadFunction<d_gdk_window_create_similar_surface>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_create_similar_surface"));

		public Cairo.Surface CreateSimilarSurface(Cairo.Content content, int width, int height) {
			IntPtr raw_ret = gdk_window_create_similar_surface(Handle, (int) content, width, height);
			Cairo.Surface ret = Cairo.Surface.Lookup (raw_ret, true);
			return ret;
		}

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

		public void Deiconify() {
			gdk_window_deiconify(Handle);
		}

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

		[Obsolete]
		public void EnableSynchronizedConfigure() {
			gdk_window_enable_synchronized_configure(Handle);
		}

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

		public void EndDrawFrame(Gdk.DrawingContext context) {
			gdk_window_end_draw_frame(Handle, context == null ? IntPtr.Zero : context.Handle);
		}

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

		[Obsolete]
		public void EndPaint() {
			gdk_window_end_paint(Handle);
		}

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

		public bool EnsureNative() {
			bool raw_ret = gdk_window_ensure_native(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		[Obsolete]
		public void Flush() {
			gdk_window_flush(Handle);
		}

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

		public void Focus(uint timestamp) {
			gdk_window_focus(Handle, timestamp);
		}

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

		public void FreezeUpdates() {
			gdk_window_freeze_updates(Handle);
		}

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

		public void Fullscreen() {
			gdk_window_fullscreen(Handle);
		}

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

		public void FullscreenOnMonitor(int monitor) {
			gdk_window_fullscreen_on_monitor(Handle, monitor);
		}

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

		public void GeometryChanged() {
			gdk_window_geometry_changed(Handle);
		}

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

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

		public bool AcceptFocus { 
			get {
				bool raw_ret = gdk_window_get_accept_focus(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gdk_window_set_accept_focus(Handle, value);
			}
		}

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

		public GLib.List GetChildrenWithUserData(IntPtr user_data) {
			IntPtr raw_ret = gdk_window_get_children_with_user_data(Handle, user_data);
			GLib.List ret = new GLib.List(raw_ret);
			return ret;
		}

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

		public Cairo.Region ClipRegion { 
			get {
				IntPtr raw_ret = gdk_window_get_clip_region(Handle);
				Cairo.Region ret = new Cairo.Region(raw_ret);
				return ret;
			}
		}

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

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

		[Obsolete]
		public bool Composited { 
			get {
				bool raw_ret = gdk_window_get_composited(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gdk_window_set_composited(Handle, value);
			}
		}

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

		public bool GetDecorations(out Gdk.WMDecoration decorations) {
			int native_decorations;
			bool raw_ret = gdk_window_get_decorations(Handle, out native_decorations);
			bool ret = raw_ret;
			decorations = (Gdk.WMDecoration) native_decorations;
			return ret;
		}

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

		public Gdk.Cursor GetDeviceCursor(Gdk.Device device) {
			IntPtr raw_ret = gdk_window_get_device_cursor(Handle, device == null ? IntPtr.Zero : device.Handle);
			Gdk.Cursor ret = GLib.Object.GetObject(raw_ret) as Gdk.Cursor;
			return ret;
		}

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

		public Gdk.EventMask GetDeviceEvents(Gdk.Device device) {
			int raw_ret = gdk_window_get_device_events(Handle, device == null ? IntPtr.Zero : device.Handle);
			Gdk.EventMask ret = (Gdk.EventMask) raw_ret;
			return ret;
		}

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

		public Gdk.Window GetDevicePosition(Gdk.Device device, out int x, out int y, out Gdk.ModifierType mask) {
			int native_mask;
			IntPtr raw_ret = gdk_window_get_device_position(Handle, device == null ? IntPtr.Zero : device.Handle, out x, out y, out native_mask);
			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
			mask = (Gdk.ModifierType) native_mask;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gdk_window_get_device_position_double(IntPtr raw, IntPtr device, out double x, out double y, out int mask);
		static d_gdk_window_get_device_position_double gdk_window_get_device_position_double = FuncLoader.LoadFunction<d_gdk_window_get_device_position_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_get_device_position_double"));

		public Gdk.Window GetDevicePositionDouble(Gdk.Device device, out double x, out double y, out Gdk.ModifierType mask) {
			int native_mask;
			IntPtr raw_ret = gdk_window_get_device_position_double(Handle, device == null ? IntPtr.Zero : device.Handle, out x, out y, out native_mask);
			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
			mask = (Gdk.ModifierType) native_mask;
			return ret;
		}

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

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

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

		public Gdk.DragProtocol GetDragProtocol(Gdk.Window target) {
			int raw_ret = gdk_window_get_drag_protocol(Handle, target == null ? IntPtr.Zero : target.Handle);
			Gdk.DragProtocol ret = (Gdk.DragProtocol) raw_ret;
			return ret;
		}

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

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

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

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

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

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

		public bool EventCompression { 
			get {
				bool raw_ret = gdk_window_get_event_compression(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gdk_window_set_event_compression(Handle, value);
			}
		}

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

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

		public Gdk.EventMask Events { 
			get {
				int raw_ret = gdk_window_get_events(Handle);
				Gdk.EventMask ret = (Gdk.EventMask) raw_ret;
				return ret;
			}
			set {
				gdk_window_set_events(Handle, (int) value);
			}
		}

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

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

		public bool FocusOnMap { 
			get {
				bool raw_ret = gdk_window_get_focus_on_map(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gdk_window_set_focus_on_map(Handle, value);
			}
		}

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

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

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

		public Gdk.Rectangle FrameExtents { 
			get {
				Gdk.Rectangle rect;
				IntPtr native_rect = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
				gdk_window_get_frame_extents(Handle, native_rect);
				rect = (Gdk.Rectangle) Marshal.PtrToStructure (native_rect, typeof (Gdk.Rectangle));
				Marshal.FreeHGlobal (native_rect);
				return rect;
			}
		}

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

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

		public Gdk.FullscreenMode FullscreenMode { 
			get {
				int raw_ret = gdk_window_get_fullscreen_mode(Handle);
				Gdk.FullscreenMode ret = (Gdk.FullscreenMode) raw_ret;
				return ret;
			}
			set {
				gdk_window_set_fullscreen_mode(Handle, (int) value);
			}
		}

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

		public void GetGeometry(out int x, out int y, out int width, out int height) {
			gdk_window_get_geometry(Handle, out x, out y, out width, out height);
		}

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

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

		public Gdk.Window Group { 
			get {
				IntPtr raw_ret = gdk_window_get_group(Handle);
				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
				return ret;
			}
			set {
				gdk_window_set_group(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public int Height { 
			get {
				int raw_ret = gdk_window_get_height(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

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

		public bool ModalHint { 
			get {
				bool raw_ret = gdk_window_get_modal_hint(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gdk_window_set_modal_hint(Handle, value);
			}
		}

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

		public int GetOrigin(out int x, out int y) {
			int raw_ret = gdk_window_get_origin(Handle, out x, out y);
			int ret = raw_ret;
			return ret;
		}

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

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

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

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

		public bool PassThrough { 
			get {
				bool raw_ret = gdk_window_get_pass_through(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gdk_window_set_pass_through(Handle, value);
			}
		}

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

		[Obsolete]
		public Gdk.Window GetPointer(out int x, out int y, out Gdk.ModifierType mask) {
			int native_mask;
			IntPtr raw_ret = gdk_window_get_pointer(Handle, out x, out y, out native_mask);
			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
			mask = (Gdk.ModifierType) native_mask;
			return ret;
		}

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

		public void GetPosition(out int x, out int y) {
			gdk_window_get_position(Handle, out x, out y);
		}

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

		public void GetRootCoords(int x, int y, out int root_x, out int root_y) {
			gdk_window_get_root_coords(Handle, x, y, out root_x, out root_y);
		}

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

		public void GetRootOrigin(out int x, out int y) {
			gdk_window_get_root_origin(Handle, out x, out y);
		}

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

		public int ScaleFactor { 
			get {
				int raw_ret = gdk_window_get_scale_factor(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

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

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

		public Gdk.EventMask GetSourceEvents(Gdk.InputSource source) {
			int raw_ret = gdk_window_get_source_events(Handle, (int) source);
			Gdk.EventMask ret = (Gdk.EventMask) raw_ret;
			return ret;
		}

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

		public Gdk.WindowState State { 
			get {
				int raw_ret = gdk_window_get_state(Handle);
				Gdk.WindowState ret = (Gdk.WindowState) raw_ret;
				return ret;
			}
		}

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

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

		public bool SupportMultidevice { 
			get {
				bool raw_ret = gdk_window_get_support_multidevice(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gdk_window_set_support_multidevice(Handle, value);
			}
		}

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

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

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

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

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

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

		public Gdk.WindowTypeHint TypeHint { 
			get {
				int raw_ret = gdk_window_get_type_hint(Handle);
				Gdk.WindowTypeHint ret = (Gdk.WindowTypeHint) raw_ret;
				return ret;
			}
			set {
				gdk_window_set_type_hint(Handle, (int) value);
			}
		}

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

		public Cairo.Region UpdateArea { 
			get {
				IntPtr raw_ret = gdk_window_get_update_area(Handle);
				Cairo.Region ret = new Cairo.Region(raw_ret);
				return ret;
			}
		}

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

		public Cairo.Region VisibleRegion { 
			get {
				IntPtr raw_ret = gdk_window_get_visible_region(Handle);
				Cairo.Region ret = new Cairo.Region(raw_ret);
				return ret;
			}
		}

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

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

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

		public int Width { 
			get {
				int raw_ret = gdk_window_get_width(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

		public Gdk.WindowType WindowType { 
			get {
				int raw_ret = gdk_window_get_window_type(Handle);
				Gdk.WindowType ret = (Gdk.WindowType) raw_ret;
				return ret;
			}
		}

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

		public bool HasNative { 
			get {
				bool raw_ret = gdk_window_has_native(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public void Hide() {
			gdk_window_hide(Handle);
		}

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

		public void Iconify() {
			gdk_window_iconify(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_input_shape_combine_region(IntPtr raw, IntPtr shape_region, int offset_x, int offset_y);
		static d_gdk_window_input_shape_combine_region gdk_window_input_shape_combine_region = FuncLoader.LoadFunction<d_gdk_window_input_shape_combine_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_input_shape_combine_region"));

		public void InputShapeCombineRegion(Cairo.Region shape_region, int offset_x, int offset_y) {
			gdk_window_input_shape_combine_region(Handle, shape_region == null ? IntPtr.Zero : shape_region.Handle, offset_x, offset_y);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_invalidate_maybe_recurse(IntPtr raw, IntPtr region, GdkSharp.WindowChildFuncNative child_func, IntPtr user_data);
		static d_gdk_window_invalidate_maybe_recurse gdk_window_invalidate_maybe_recurse = FuncLoader.LoadFunction<d_gdk_window_invalidate_maybe_recurse>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_invalidate_maybe_recurse"));

		public void InvalidateMaybeRecurse(Cairo.Region region, Gdk.WindowChildFunc child_func) {
			GdkSharp.WindowChildFuncWrapper child_func_wrapper = new GdkSharp.WindowChildFuncWrapper (child_func);
			gdk_window_invalidate_maybe_recurse(Handle, region == null ? IntPtr.Zero : region.Handle, child_func_wrapper.NativeDelegate, IntPtr.Zero);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_invalidate_rect(IntPtr raw, IntPtr rect, bool invalidate_children);
		static d_gdk_window_invalidate_rect gdk_window_invalidate_rect = FuncLoader.LoadFunction<d_gdk_window_invalidate_rect>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_invalidate_rect"));

		public void InvalidateRect(Gdk.Rectangle rect, bool invalidate_children) {
			IntPtr native_rect = GLib.Marshaller.StructureToPtrAlloc (rect);
			gdk_window_invalidate_rect(Handle, native_rect, invalidate_children);
			Marshal.FreeHGlobal (native_rect);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_invalidate_region(IntPtr raw, IntPtr region, bool invalidate_children);
		static d_gdk_window_invalidate_region gdk_window_invalidate_region = FuncLoader.LoadFunction<d_gdk_window_invalidate_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_invalidate_region"));

		public void InvalidateRegion(Cairo.Region region, bool invalidate_children) {
			gdk_window_invalidate_region(Handle, region == null ? IntPtr.Zero : region.Handle, invalidate_children);
		}

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

		public bool IsDestroyed { 
			get {
				bool raw_ret = gdk_window_is_destroyed(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsInputOnly { 
			get {
				bool raw_ret = gdk_window_is_input_only(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsShaped { 
			get {
				bool raw_ret = gdk_window_is_shaped(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsViewable { 
			get {
				bool raw_ret = gdk_window_is_viewable(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsVisible { 
			get {
				bool raw_ret = gdk_window_is_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public void Lower() {
			gdk_window_lower(Handle);
		}

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

		public void MarkPaintFromClip(Cairo.Context cr) {
			gdk_window_mark_paint_from_clip(Handle, cr == null ? IntPtr.Zero : cr.Handle);
		}

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

		public void Maximize() {
			gdk_window_maximize(Handle);
		}

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

		public void MergeChildInputShapes() {
			gdk_window_merge_child_input_shapes(Handle);
		}

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

		public void MergeChildShapes() {
			gdk_window_merge_child_shapes(Handle);
		}

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

		public void Move(int x, int y) {
			gdk_window_move(Handle, x, y);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_move_region(IntPtr raw, IntPtr region, int dx, int dy);
		static d_gdk_window_move_region gdk_window_move_region = FuncLoader.LoadFunction<d_gdk_window_move_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_move_region"));

		public void MoveRegion(Cairo.Region region, int dx, int dy) {
			gdk_window_move_region(Handle, region == null ? IntPtr.Zero : region.Handle, dx, dy);
		}

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

		public void MoveResize(int x, int y, int width, int height) {
			gdk_window_move_resize(Handle, x, y, width, height);
		}

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

		public static void ProcessAllUpdates() {
			gdk_window_process_all_updates();
		}

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

		public void ProcessUpdates(bool update_children) {
			gdk_window_process_updates(Handle, update_children);
		}

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

		public void Raise() {
			gdk_window_raise(Handle);
		}

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

		public void RegisterDnd() {
			gdk_window_register_dnd(Handle);
		}

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

		public void Reparent(Gdk.Window new_parent, int x, int y) {
			gdk_window_reparent(Handle, new_parent == null ? IntPtr.Zero : new_parent.Handle, x, y);
		}

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

		public void Resize(int width, int height) {
			gdk_window_resize(Handle, width, height);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_restack(IntPtr raw, IntPtr sibling, bool above);
		static d_gdk_window_restack gdk_window_restack = FuncLoader.LoadFunction<d_gdk_window_restack>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_restack"));

		public void Restack(Gdk.Window sibling, bool above) {
			gdk_window_restack(Handle, sibling == null ? IntPtr.Zero : sibling.Handle, above);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_scroll(IntPtr raw, int dx, int dy);
		static d_gdk_window_scroll gdk_window_scroll = FuncLoader.LoadFunction<d_gdk_window_scroll>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_scroll"));

		public void Scroll(int dx, int dy) {
			gdk_window_scroll(Handle, dx, dy);
		}

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

		[Obsolete]
		public Gdk.Color Background { 
			set {
				IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
				gdk_window_set_background(Handle, native_value);
				Marshal.FreeHGlobal (native_value);
			}
		}

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

		[Obsolete]
		public Gdk.RGBA BackgroundRgba { 
			set {
				IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
				gdk_window_set_background_rgba(Handle, native_value);
				Marshal.FreeHGlobal (native_value);
			}
		}

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

		public void SetChildInputShapes() {
			gdk_window_set_child_input_shapes(Handle);
		}

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

		public void SetChildShapes() {
			gdk_window_set_child_shapes(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_set_debug_updates(bool setting);
		static d_gdk_window_set_debug_updates gdk_window_set_debug_updates = FuncLoader.LoadFunction<d_gdk_window_set_debug_updates>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_debug_updates"));

		[Obsolete]
		public static bool DebugUpdates { 
			set {
				gdk_window_set_debug_updates(value);
			}
		}

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

		public void SetDecorations(Gdk.WMDecoration decorations) {
			gdk_window_set_decorations(Handle, (int) decorations);
		}

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

		public void SetDeviceCursor(Gdk.Device device, Gdk.Cursor cursor) {
			gdk_window_set_device_cursor(Handle, device == null ? IntPtr.Zero : device.Handle, cursor == null ? IntPtr.Zero : cursor.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_set_device_events(IntPtr raw, IntPtr device, int event_mask);
		static d_gdk_window_set_device_events gdk_window_set_device_events = FuncLoader.LoadFunction<d_gdk_window_set_device_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_device_events"));

		public void SetDeviceEvents(Gdk.Device device, Gdk.EventMask event_mask) {
			gdk_window_set_device_events(Handle, device == null ? IntPtr.Zero : device.Handle, (int) event_mask);
		}

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

		public Gdk.WMFunction Functions { 
			set {
				gdk_window_set_functions(Handle, (int) value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_set_geometry_hints(IntPtr raw, IntPtr geometry, int geom_mask);
		static d_gdk_window_set_geometry_hints gdk_window_set_geometry_hints = FuncLoader.LoadFunction<d_gdk_window_set_geometry_hints>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_geometry_hints"));

		public void SetGeometryHints(Gdk.Geometry geometry, Gdk.WindowHints geom_mask) {
			IntPtr native_geometry = GLib.Marshaller.StructureToPtrAlloc (geometry);
			gdk_window_set_geometry_hints(Handle, native_geometry, (int) geom_mask);
			Marshal.FreeHGlobal (native_geometry);
		}

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

		public string IconName { 
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gdk_window_set_icon_name(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_set_invalidate_handler(IntPtr raw, GdkSharp.WindowInvalidateHandlerFuncNative handler);
		static d_gdk_window_set_invalidate_handler gdk_window_set_invalidate_handler = FuncLoader.LoadFunction<d_gdk_window_set_invalidate_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_invalidate_handler"));

		public Gdk.WindowInvalidateHandlerFunc InvalidateHandler { 
			set {
				GdkSharp.WindowInvalidateHandlerFuncWrapper value_wrapper = new GdkSharp.WindowInvalidateHandlerFuncWrapper (value);
				gdk_window_set_invalidate_handler(Handle, value_wrapper.NativeDelegate);
			}
		}

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

		public bool KeepAbove { 
			set {
				gdk_window_set_keep_above(Handle, value);
			}
		}

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

		public bool KeepBelow { 
			set {
				gdk_window_set_keep_below(Handle, value);
			}
		}

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

		public double Opacity { 
			set {
				gdk_window_set_opacity(Handle, value);
			}
		}

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

		public Cairo.Region OpaqueRegion { 
			set {
				gdk_window_set_opaque_region(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public bool OverrideRedirect { 
			set {
				gdk_window_set_override_redirect(Handle, value);
			}
		}

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

		public string Role { 
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gdk_window_set_role(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_set_shadow_width(IntPtr raw, int left, int right, int top, int bottom);
		static d_gdk_window_set_shadow_width gdk_window_set_shadow_width = FuncLoader.LoadFunction<d_gdk_window_set_shadow_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_shadow_width"));

		public void SetShadowWidth(int left, int right, int top, int bottom) {
			gdk_window_set_shadow_width(Handle, left, right, top, bottom);
		}

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

		public bool SkipPagerHint { 
			set {
				gdk_window_set_skip_pager_hint(Handle, value);
			}
		}

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

		public bool SkipTaskbarHint { 
			set {
				gdk_window_set_skip_taskbar_hint(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_set_source_events(IntPtr raw, int source, int event_mask);
		static d_gdk_window_set_source_events gdk_window_set_source_events = FuncLoader.LoadFunction<d_gdk_window_set_source_events>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_source_events"));

		public void SetSourceEvents(Gdk.InputSource source, Gdk.EventMask event_mask) {
			gdk_window_set_source_events(Handle, (int) source, (int) event_mask);
		}

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

		public string StartupId { 
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gdk_window_set_startup_id(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[Obsolete]
		public bool SetStaticGravities(bool use_static) {
			bool raw_ret = gdk_window_set_static_gravities(Handle, use_static);
			bool ret = raw_ret;
			return ret;
		}

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

		public string Title { 
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gdk_window_set_title(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

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

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

		public bool UrgencyHint { 
			set {
				gdk_window_set_urgency_hint(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gdk_window_shape_combine_region(IntPtr raw, IntPtr shape_region, int offset_x, int offset_y);
		static d_gdk_window_shape_combine_region gdk_window_shape_combine_region = FuncLoader.LoadFunction<d_gdk_window_shape_combine_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_shape_combine_region"));

		public void ShapeCombineRegion(Cairo.Region shape_region, int offset_x, int offset_y) {
			gdk_window_shape_combine_region(Handle, shape_region == null ? IntPtr.Zero : shape_region.Handle, offset_x, offset_y);
		}

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

		public void Show() {
			gdk_window_show(Handle);
		}

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

		public void ShowUnraised() {
			gdk_window_show_unraised(Handle);
		}

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

		public bool ShowWindowMenu(Gdk.Event evnt) {
			bool raw_ret = gdk_window_show_window_menu(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void Stick() {
			gdk_window_stick(Handle);
		}

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

		public void ThawUpdates() {
			gdk_window_thaw_updates(Handle);
		}

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

		public void Unfullscreen() {
			gdk_window_unfullscreen(Handle);
		}

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

		public void Unmaximize() {
			gdk_window_unmaximize(Handle);
		}

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

		public void Unstick() {
			gdk_window_unstick(Handle);
		}

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

		public void Withdraw() {
			gdk_window_withdraw(Handle);
		}


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