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

namespace Gtk {

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

#region Autogenerated code
	public partial class Window : Gtk.Bin {

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_window_new(int type);
		static d_gtk_window_new gtk_window_new = FuncLoader.LoadFunction<d_gtk_window_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_new"));

		public Window (Gtk.WindowType type) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Window)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				names.Add ("type");
				vals.Add (new GLib.Value (type));
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = gtk_window_new((int) type);
		}

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

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

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

		[GLib.Property ("title")]
		public string Title {
			get  {
				IntPtr raw_ret = gtk_window_get_title(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_window_set_title(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

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

		[GLib.Property ("role")]
		public string Role {
			get  {
				IntPtr raw_ret = gtk_window_get_role(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_window_set_role(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[GLib.Property ("startup-id")]
		public string StartupId {
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_window_set_startup_id(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_resizable(IntPtr raw, bool resizable);
		static d_gtk_window_set_resizable gtk_window_set_resizable = FuncLoader.LoadFunction<d_gtk_window_set_resizable>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_resizable"));

		[GLib.Property ("resizable")]
		public bool Resizable {
			get  {
				bool raw_ret = gtk_window_get_resizable(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_resizable(Handle, value);
			}
		}

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

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

		[GLib.Property ("modal")]
		public bool Modal {
			get  {
				bool raw_ret = gtk_window_get_modal(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_modal(Handle, value);
			}
		}

		[GLib.Property ("window-position")]
		public Gtk.WindowPosition WindowPosition {
			get {
				GLib.Value val = GetProperty ("window-position");
				Gtk.WindowPosition ret = (Gtk.WindowPosition) (Enum) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value((Enum) value);
				SetProperty("window-position", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("default-width")]
		public int DefaultWidth {
			get {
				GLib.Value val = GetProperty ("default-width");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("default-width", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("default-height")]
		public int DefaultHeight {
			get {
				GLib.Value val = GetProperty ("default-height");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("default-height", val);
				val.Dispose ();
			}
		}

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

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

		[GLib.Property ("destroy-with-parent")]
		public bool DestroyWithParent {
			get  {
				bool raw_ret = gtk_window_get_destroy_with_parent(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_destroy_with_parent(Handle, value);
			}
		}

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

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

		[GLib.Property ("hide-titlebar-when-maximized")]
		public bool HideTitlebarWhenMaximized {
			get  {
				bool raw_ret = gtk_window_get_hide_titlebar_when_maximized(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_hide_titlebar_when_maximized(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_icon(IntPtr raw, IntPtr icon);
		static d_gtk_window_set_icon gtk_window_set_icon = FuncLoader.LoadFunction<d_gtk_window_set_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_icon"));

		[GLib.Property ("icon")]
		public Gdk.Pixbuf Icon {
			get  {
				IntPtr raw_ret = gtk_window_get_icon(Handle);
				Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
				return ret;
			}
			set  {
				gtk_window_set_icon(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

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

		[GLib.Property ("mnemonics-visible")]
		public bool MnemonicsVisible {
			get  {
				bool raw_ret = gtk_window_get_mnemonics_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_mnemonics_visible(Handle, value);
			}
		}

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

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

		[GLib.Property ("focus-visible")]
		public bool FocusVisible {
			get  {
				bool raw_ret = gtk_window_get_focus_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_focus_visible(Handle, value);
			}
		}

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

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

		[GLib.Property ("icon-name")]
		public string IconName {
			get  {
				IntPtr raw_ret = gtk_window_get_icon_name(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_window_set_icon_name(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_screen(IntPtr raw, IntPtr screen);
		static d_gtk_window_set_screen gtk_window_set_screen = FuncLoader.LoadFunction<d_gtk_window_set_screen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_screen"));

		[GLib.Property ("screen")]
		public new Gdk.Screen Screen {
			get  {
				IntPtr raw_ret = gtk_window_get_screen(Handle);
				Gdk.Screen ret = GLib.Object.GetObject(raw_ret) as Gdk.Screen;
				return ret;
			}
			set  {
				gtk_window_set_screen(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[GLib.Property ("is-active")]
		public bool IsActive {
			get {
				GLib.Value val = GetProperty ("is-active");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("has-toplevel-focus")]
		public bool HasToplevelFocus {
			get {
				GLib.Value val = GetProperty ("has-toplevel-focus");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

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

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

		[GLib.Property ("type-hint")]
		public Gdk.WindowTypeHint TypeHint {
			get  {
				int raw_ret = gtk_window_get_type_hint(Handle);
				Gdk.WindowTypeHint ret = (Gdk.WindowTypeHint) raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_type_hint(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("skip-taskbar-hint")]
		public bool SkipTaskbarHint {
			get  {
				bool raw_ret = gtk_window_get_skip_taskbar_hint(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_skip_taskbar_hint(Handle, value);
			}
		}

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

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

		[GLib.Property ("skip-pager-hint")]
		public bool SkipPagerHint {
			get  {
				bool raw_ret = gtk_window_get_skip_pager_hint(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_skip_pager_hint(Handle, value);
			}
		}

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

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

		[GLib.Property ("urgency-hint")]
		public bool UrgencyHint {
			get  {
				bool raw_ret = gtk_window_get_urgency_hint(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_urgency_hint(Handle, value);
			}
		}

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

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

		[GLib.Property ("accept-focus")]
		public bool AcceptFocus {
			get  {
				bool raw_ret = gtk_window_get_accept_focus(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_accept_focus(Handle, value);
			}
		}

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

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

		[GLib.Property ("focus-on-map")]
		public bool FocusOnMap {
			get  {
				bool raw_ret = gtk_window_get_focus_on_map(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_focus_on_map(Handle, value);
			}
		}

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

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

		[GLib.Property ("decorated")]
		public bool Decorated {
			get  {
				bool raw_ret = gtk_window_get_decorated(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_decorated(Handle, value);
			}
		}

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

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

		[GLib.Property ("deletable")]
		public bool Deletable {
			get  {
				bool raw_ret = gtk_window_get_deletable(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_deletable(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_has_resize_grip(IntPtr raw, bool value);
		static d_gtk_window_set_has_resize_grip gtk_window_set_has_resize_grip = FuncLoader.LoadFunction<d_gtk_window_set_has_resize_grip>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_has_resize_grip"));

		[Obsolete]
		[GLib.Property ("has-resize-grip")]
		public bool HasResizeGrip {
			get  {
				bool raw_ret = gtk_window_get_has_resize_grip(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_has_resize_grip(Handle, value);
			}
		}

		[GLib.Property ("resize-grip-visible")]
		public bool ResizeGripVisible {
			get {
				GLib.Value val = GetProperty ("resize-grip-visible");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_gravity(IntPtr raw, int gravity);
		static d_gtk_window_set_gravity gtk_window_set_gravity = FuncLoader.LoadFunction<d_gtk_window_set_gravity>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_gravity"));

		[GLib.Property ("gravity")]
		public Gdk.Gravity Gravity {
			get  {
				int raw_ret = gtk_window_get_gravity(Handle);
				Gdk.Gravity ret = (Gdk.Gravity) raw_ret;
				return ret;
			}
			set  {
				gtk_window_set_gravity(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("transient-for")]
		public Gtk.Window TransientFor {
			get  {
				IntPtr raw_ret = gtk_window_get_transient_for(Handle);
				Gtk.Window ret = GLib.Object.GetObject(raw_ret) as Gtk.Window;
				return ret;
			}
			set  {
				gtk_window_set_transient_for(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_attached_to(IntPtr raw, IntPtr attach_widget);
		static d_gtk_window_set_attached_to gtk_window_set_attached_to = FuncLoader.LoadFunction<d_gtk_window_set_attached_to>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_attached_to"));

		[GLib.Property ("attached-to")]
		public Gtk.Widget AttachedTo {
			get  {
				IntPtr raw_ret = gtk_window_get_attached_to(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
			set  {
				gtk_window_set_attached_to(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[GLib.Property ("is-maximized")]
		public bool Maximized {
			get {
				GLib.Value val = GetProperty ("is-maximized");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_application(IntPtr raw, IntPtr application);
		static d_gtk_window_set_application gtk_window_set_application = FuncLoader.LoadFunction<d_gtk_window_set_application>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_application"));

		[GLib.Property ("application")]
		public Gtk.Application Application {
			get  {
				IntPtr raw_ret = gtk_window_get_application(Handle);
				Gtk.Application ret = GLib.Object.GetObject(raw_ret) as Gtk.Application;
				return ret;
			}
			set  {
				gtk_window_set_application(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		public string DecorationButtonLayout {
			get {
				var val = (string)StyleGetProperty("decoration-button-layout");
				return val;
			}
		}

		public int DecorationResizeHandle {
			get {
				var val = (int)StyleGetProperty("decoration-resize-handle");
				return val;
			}
		}

		[GLib.Signal("enable-debugging")]
		public event Gtk.EnableDebuggingHandler EnableDebugging {
			add {
				this.AddSignalHandler ("enable-debugging", value, typeof (Gtk.EnableDebuggingArgs));
			}
			remove {
				this.RemoveSignalHandler ("enable-debugging", value);
			}
		}

		[GLib.Signal("activate-default")]
		public event System.EventHandler DefaultActivated {
			add {
				this.AddSignalHandler ("activate-default", value);
			}
			remove {
				this.RemoveSignalHandler ("activate-default", value);
			}
		}

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

		[GLib.Signal("set-focus")]
		public event Gtk.SetFocusHandler SetFocus {
			add {
				this.AddSignalHandler ("set-focus", value, typeof (Gtk.SetFocusArgs));
			}
			remove {
				this.RemoveSignalHandler ("set-focus", value);
			}
		}

		[GLib.Signal("activate-focus")]
		public event System.EventHandler FocusActivated {
			add {
				this.AddSignalHandler ("activate-focus", value);
			}
			remove {
				this.RemoveSignalHandler ("activate-focus", value);
			}
		}

		static SetFocusNativeDelegate SetFocus_cb_delegate;
		static SetFocusNativeDelegate SetFocusVMCallback {
			get {
				if (SetFocus_cb_delegate == null)
					SetFocus_cb_delegate = new SetFocusNativeDelegate (SetFocus_cb);
				return SetFocus_cb_delegate;
			}
		}

		static void OverrideSetFocus (GLib.GType gtype)
		{
			OverrideSetFocus (gtype, SetFocusVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetFocusNativeDelegate (IntPtr inst, IntPtr focus);

		static void SetFocus_cb (IntPtr inst, IntPtr focus)
		{
			try {
				Window __obj = GLib.Object.GetObject (inst, false) as Window;
				__obj.OnSetFocus (GLib.Object.GetObject(focus) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Window), ConnectionMethod="OverrideSetFocus")]
		protected virtual void OnSetFocus (Gtk.Widget focus)
		{
			InternalSetFocus (focus);
		}

		private void InternalSetFocus (Gtk.Widget focus)
		{
			SetFocusNativeDelegate unmanaged = class_abi.BaseOverride<SetFocusNativeDelegate>(this.LookupGType(), "set_focus");
			if (unmanaged == null) return;

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

		static FocusActivatedNativeDelegate FocusActivated_cb_delegate;
		static FocusActivatedNativeDelegate FocusActivatedVMCallback {
			get {
				if (FocusActivated_cb_delegate == null)
					FocusActivated_cb_delegate = new FocusActivatedNativeDelegate (FocusActivated_cb);
				return FocusActivated_cb_delegate;
			}
		}

		static void OverrideFocusActivated (GLib.GType gtype)
		{
			OverrideFocusActivated (gtype, FocusActivatedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Window), ConnectionMethod="OverrideFocusActivated")]
		protected virtual void OnFocusActivated ()
		{
			InternalFocusActivated ();
		}

		private void InternalFocusActivated ()
		{
			FocusActivatedNativeDelegate unmanaged = class_abi.BaseOverride<FocusActivatedNativeDelegate>(this.LookupGType(), "activate_focus");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static DefaultActivatedNativeDelegate DefaultActivated_cb_delegate;
		static DefaultActivatedNativeDelegate DefaultActivatedVMCallback {
			get {
				if (DefaultActivated_cb_delegate == null)
					DefaultActivated_cb_delegate = new DefaultActivatedNativeDelegate (DefaultActivated_cb);
				return DefaultActivated_cb_delegate;
			}
		}

		static void OverrideDefaultActivated (GLib.GType gtype)
		{
			OverrideDefaultActivated (gtype, DefaultActivatedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Window), ConnectionMethod="OverrideDefaultActivated")]
		protected virtual void OnDefaultActivated ()
		{
			InternalDefaultActivated ();
		}

		private void InternalDefaultActivated ()
		{
			DefaultActivatedNativeDelegate unmanaged = class_abi.BaseOverride<DefaultActivatedNativeDelegate>(this.LookupGType(), "activate_default");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

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

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

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

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

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

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

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

			unmanaged (this.Handle);
		}

		static EnableDebuggingNativeDelegate EnableDebugging_cb_delegate;
		static EnableDebuggingNativeDelegate EnableDebuggingVMCallback {
			get {
				if (EnableDebugging_cb_delegate == null)
					EnableDebugging_cb_delegate = new EnableDebuggingNativeDelegate (EnableDebugging_cb);
				return EnableDebugging_cb_delegate;
			}
		}

		static void OverrideEnableDebugging (GLib.GType gtype)
		{
			OverrideEnableDebugging (gtype, EnableDebuggingVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool EnableDebuggingNativeDelegate (IntPtr inst, bool toggle);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Window), ConnectionMethod="OverrideEnableDebugging")]
		protected virtual bool OnEnableDebugging (bool toggle)
		{
			return InternalEnableDebugging (toggle);
		}

		private bool InternalEnableDebugging (bool toggle)
		{
			EnableDebuggingNativeDelegate unmanaged = class_abi.BaseOverride<EnableDebuggingNativeDelegate>(this.LookupGType(), "enable_debugging");
			if (unmanaged == null) return false;

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


		// 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("set_focus"
							, Gtk.Bin.class_abi.Fields
							, (uint) sizeof( IntPtr ) // set_focus
							, null
							, "activate_focus"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate_focus"
							, -1
							, (uint) sizeof( IntPtr ) // activate_focus
							, "set_focus"
							, "activate_default"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate_default"
							, -1
							, (uint) sizeof( IntPtr ) // activate_default
							, "activate_focus"
							, "keys_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("keys_changed"
							, -1
							, (uint) sizeof( IntPtr ) // keys_changed
							, "activate_default"
							, "enable_debugging"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("enable_debugging"
							, -1
							, (uint) sizeof( IntPtr ) // enable_debugging
							, "keys_changed"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "enable_debugging"
							, "_gtk_reserved2"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved3
							, "_gtk_reserved2"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

		public bool ActivateDefault() {
			bool raw_ret = gtk_window_activate_default(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool ActivateFocus() {
			bool raw_ret = gtk_window_activate_focus(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool ActivateKey(Gdk.EventKey evnt) {
			bool raw_ret = gtk_window_activate_key(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_add_accel_group(IntPtr raw, IntPtr accel_group);
		static d_gtk_window_add_accel_group gtk_window_add_accel_group = FuncLoader.LoadFunction<d_gtk_window_add_accel_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_add_accel_group"));

		public void AddAccelGroup(Gtk.AccelGroup accel_group) {
			gtk_window_add_accel_group(Handle, accel_group == null ? IntPtr.Zero : accel_group.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_add_mnemonic(IntPtr raw, uint keyval, IntPtr target);
		static d_gtk_window_add_mnemonic gtk_window_add_mnemonic = FuncLoader.LoadFunction<d_gtk_window_add_mnemonic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_add_mnemonic"));

		public void AddMnemonic(uint keyval, Gtk.Widget target) {
			gtk_window_add_mnemonic(Handle, keyval, target == null ? IntPtr.Zero : target.Handle);
		}

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

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

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

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

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

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

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

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

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_fullscreen_on_monitor(IntPtr raw, IntPtr screen, int monitor);
		static d_gtk_window_fullscreen_on_monitor gtk_window_fullscreen_on_monitor = FuncLoader.LoadFunction<d_gtk_window_fullscreen_on_monitor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_fullscreen_on_monitor"));

		public void FullscreenOnMonitor(Gdk.Screen screen, int monitor) {
			gtk_window_fullscreen_on_monitor(Handle, screen == null ? IntPtr.Zero : screen.Handle, monitor);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_window_get_default_icon_name();
		static d_gtk_window_get_default_icon_name gtk_window_get_default_icon_name = FuncLoader.LoadFunction<d_gtk_window_get_default_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_get_default_icon_name"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_default_icon_name(IntPtr name);
		static d_gtk_window_set_default_icon_name gtk_window_set_default_icon_name = FuncLoader.LoadFunction<d_gtk_window_set_default_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_default_icon_name"));

		public static string DefaultIconName { 
			get {
				IntPtr raw_ret = gtk_window_get_default_icon_name();
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_window_set_default_icon_name(native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		public void GetDefaultSize(out int width, out int height) {
			gtk_window_get_default_size(Handle, out width, out height);
		}

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

		public Gtk.Widget DefaultWidget { 
			get {
				IntPtr raw_ret = gtk_window_get_default_widget(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_focus(IntPtr raw, IntPtr focus);
		static d_gtk_window_set_focus gtk_window_set_focus = FuncLoader.LoadFunction<d_gtk_window_set_focus>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_focus"));

		public Gtk.Widget Focus { 
			get {
				IntPtr raw_ret = gtk_window_get_focus(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
			set {
				gtk_window_set_focus(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public Gtk.WindowGroup Group { 
			get {
				IntPtr raw_ret = gtk_window_get_group(Handle);
				Gtk.WindowGroup ret = GLib.Object.GetObject(raw_ret) as Gtk.WindowGroup;
				return ret;
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_mnemonic_modifier(IntPtr raw, int modifier);
		static d_gtk_window_set_mnemonic_modifier gtk_window_set_mnemonic_modifier = FuncLoader.LoadFunction<d_gtk_window_set_mnemonic_modifier>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_mnemonic_modifier"));

		public Gdk.ModifierType MnemonicModifier { 
			get {
				int raw_ret = gtk_window_get_mnemonic_modifier(Handle);
				Gdk.ModifierType ret = (Gdk.ModifierType) raw_ret;
				return ret;
			}
			set {
				gtk_window_set_mnemonic_modifier(Handle, (int) value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_get_position(IntPtr raw, out int root_x, out int root_y);
		static d_gtk_window_get_position gtk_window_get_position = FuncLoader.LoadFunction<d_gtk_window_get_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_get_position"));

		public void GetPosition(out int root_x, out int root_y) {
			gtk_window_get_position(Handle, out root_x, out root_y);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_window_get_resize_grip_area(IntPtr raw, IntPtr rect);
		static d_gtk_window_get_resize_grip_area gtk_window_get_resize_grip_area = FuncLoader.LoadFunction<d_gtk_window_get_resize_grip_area>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_get_resize_grip_area"));

		[Obsolete]
		public bool GetResizeGripArea(out Gdk.Rectangle rect) {
			IntPtr native_rect = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
			bool raw_ret = gtk_window_get_resize_grip_area(Handle, native_rect);
			bool ret = raw_ret;
			rect = (Gdk.Rectangle) Marshal.PtrToStructure (native_rect, typeof (Gdk.Rectangle));
			Marshal.FreeHGlobal (native_rect);
			return ret;
		}

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

		public void GetSize(out int width, out int height) {
			gtk_window_get_size(Handle, out width, out height);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_titlebar(IntPtr raw, IntPtr titlebar);
		static d_gtk_window_set_titlebar gtk_window_set_titlebar = FuncLoader.LoadFunction<d_gtk_window_set_titlebar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_titlebar"));

		public Gtk.Widget Titlebar { 
			get {
				IntPtr raw_ret = gtk_window_get_titlebar(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
			set {
				gtk_window_set_titlebar(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_window_get_type();
		static d_gtk_window_get_type gtk_window_get_type = FuncLoader.LoadFunction<d_gtk_window_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_get_type"));

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

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

		public Gtk.WindowType WindowType { 
			get {
				int raw_ret = gtk_window_get_window_type(Handle);
				Gtk.WindowType ret = (Gtk.WindowType) raw_ret;
				return ret;
			}
		}

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

		public bool HasGroup { 
			get {
				bool raw_ret = gtk_window_has_group(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

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

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

		public bool IsMaximized { 
			get {
				bool raw_ret = gtk_window_is_maximized(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_window_list_toplevels();
		static d_gtk_window_list_toplevels gtk_window_list_toplevels = FuncLoader.LoadFunction<d_gtk_window_list_toplevels>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_list_toplevels"));

		public static Gtk.Window[] ListToplevels() {
			IntPtr raw_ret = gtk_window_list_toplevels();
			Gtk.Window[] ret = GLib.Marshaller.ListPtrToArray<Gtk.Window, Gtk.Window> (raw_ret, true, false);
			return ret;
		}

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_window_mnemonic_activate(IntPtr raw, uint keyval, int modifier);
		static d_gtk_window_mnemonic_activate gtk_window_mnemonic_activate = FuncLoader.LoadFunction<d_gtk_window_mnemonic_activate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_mnemonic_activate"));

		public bool MnemonicActivate(uint keyval, Gdk.ModifierType modifier) {
			bool raw_ret = gtk_window_mnemonic_activate(Handle, keyval, (int) modifier);
			bool ret = raw_ret;
			return ret;
		}

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_window_parse_geometry(IntPtr raw, IntPtr geometry);
		static d_gtk_window_parse_geometry gtk_window_parse_geometry = FuncLoader.LoadFunction<d_gtk_window_parse_geometry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_parse_geometry"));

		[Obsolete]
		public bool ParseGeometry(string geometry) {
			IntPtr native_geometry = GLib.Marshaller.StringToPtrGStrdup (geometry);
			bool raw_ret = gtk_window_parse_geometry(Handle, native_geometry);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_geometry);
			return ret;
		}

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

		public void Present() {
			gtk_window_present(Handle);
		}

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

		public void PresentWithTime(uint timestamp) {
			gtk_window_present_with_time(Handle, timestamp);
		}

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

		public bool PropagateKeyEvent(Gdk.EventKey evnt) {
			bool raw_ret = gtk_window_propagate_key_event(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_remove_accel_group(IntPtr raw, IntPtr accel_group);
		static d_gtk_window_remove_accel_group gtk_window_remove_accel_group = FuncLoader.LoadFunction<d_gtk_window_remove_accel_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_remove_accel_group"));

		public void RemoveAccelGroup(Gtk.AccelGroup accel_group) {
			gtk_window_remove_accel_group(Handle, accel_group == null ? IntPtr.Zero : accel_group.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_remove_mnemonic(IntPtr raw, uint keyval, IntPtr target);
		static d_gtk_window_remove_mnemonic gtk_window_remove_mnemonic = FuncLoader.LoadFunction<d_gtk_window_remove_mnemonic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_remove_mnemonic"));

		public void RemoveMnemonic(uint keyval, Gtk.Widget target) {
			gtk_window_remove_mnemonic(Handle, keyval, target == null ? IntPtr.Zero : target.Handle);
		}

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

		[Obsolete]
		public void ReshowWithInitialSize() {
			gtk_window_reshow_with_initial_size(Handle);
		}

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

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

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

		[Obsolete]
		public bool ResizeGripIsVisible() {
			bool raw_ret = gtk_window_resize_grip_is_visible(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		[Obsolete]
		public void ResizeToGeometry(int width, int height) {
			gtk_window_resize_to_geometry(Handle, width, height);
		}

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

		public static bool AutoStartupNotification { 
			set {
				gtk_window_set_auto_startup_notification(value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_default(IntPtr raw, IntPtr default_widget);
		static d_gtk_window_set_default gtk_window_set_default = FuncLoader.LoadFunction<d_gtk_window_set_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_default"));

		public Gtk.Widget Default { 
			set {
				gtk_window_set_default(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[Obsolete]
		public void SetDefaultGeometry(int width, int height) {
			gtk_window_set_default_geometry(Handle, width, height);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_default_icon(IntPtr icon);
		static d_gtk_window_set_default_icon gtk_window_set_default_icon = FuncLoader.LoadFunction<d_gtk_window_set_default_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_default_icon"));

		public static Gdk.Pixbuf DefaultIcon { 
			set {
				gtk_window_set_default_icon(value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_window_set_default_icon_from_file(IntPtr filename, out IntPtr err);
		static d_gtk_window_set_default_icon_from_file gtk_window_set_default_icon_from_file = FuncLoader.LoadFunction<d_gtk_window_set_default_icon_from_file>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_default_icon_from_file"));

		public static unsafe bool SetDefaultIconFromFile(string filename) {
			IntPtr native_filename = GLib.Marshaller.StringToPtrGStrdup (filename);
			IntPtr error = IntPtr.Zero;
			bool raw_ret = gtk_window_set_default_icon_from_file(native_filename, out error);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_filename);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

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

		public void SetDefaultSize(int width, int height) {
			gtk_window_set_default_size(Handle, width, height);
		}

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

		public void SetGeometryHints(Gtk.Widget geometry_widget, Gdk.Geometry geometry, Gdk.WindowHints geom_mask) {
			IntPtr native_geometry = GLib.Marshaller.StructureToPtrAlloc (geometry);
			gtk_window_set_geometry_hints(Handle, geometry_widget == null ? IntPtr.Zero : geometry_widget.Handle, native_geometry, (int) geom_mask);
			Marshal.FreeHGlobal (native_geometry);
		}

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

		public bool HasUserRefCount { 
			set {
				gtk_window_set_has_user_ref_count(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_window_set_icon_from_file(IntPtr raw, IntPtr filename, out IntPtr err);
		static d_gtk_window_set_icon_from_file gtk_window_set_icon_from_file = FuncLoader.LoadFunction<d_gtk_window_set_icon_from_file>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_icon_from_file"));

		public unsafe bool SetIconFromFile(string filename) {
			IntPtr native_filename = GLib.Marshaller.StringToPtrGStrdup (filename);
			IntPtr error = IntPtr.Zero;
			bool raw_ret = gtk_window_set_icon_from_file(Handle, native_filename, out error);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_filename);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_interactive_debugging(bool enable);
		static d_gtk_window_set_interactive_debugging gtk_window_set_interactive_debugging = FuncLoader.LoadFunction<d_gtk_window_set_interactive_debugging>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_interactive_debugging"));

		public static bool InteractiveDebugging { 
			set {
				gtk_window_set_interactive_debugging(value);
			}
		}

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

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

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_position(IntPtr raw, int position);
		static d_gtk_window_set_position gtk_window_set_position = FuncLoader.LoadFunction<d_gtk_window_set_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_position"));

		public void SetPosition(Gtk.WindowPosition position) {
			gtk_window_set_position(Handle, (int) position);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_window_set_wmclass(IntPtr raw, IntPtr wmclass_name, IntPtr wmclass_class);
		static d_gtk_window_set_wmclass gtk_window_set_wmclass = FuncLoader.LoadFunction<d_gtk_window_set_wmclass>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_window_set_wmclass"));

		[Obsolete]
		public void SetWmclass(string wmclass_name, string wmclass_class) {
			IntPtr native_wmclass_name = GLib.Marshaller.StringToPtrGStrdup (wmclass_name);
			IntPtr native_wmclass_class = GLib.Marshaller.StringToPtrGStrdup (wmclass_class);
			gtk_window_set_wmclass(Handle, native_wmclass_name, native_wmclass_class);
			GLib.Marshaller.Free (native_wmclass_name);
			GLib.Marshaller.Free (native_wmclass_class);
		}

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

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

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

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

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

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

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

		public void Unstick() {
			gtk_window_unstick(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 (new List<GLib.AbiField>{ 
						new GLib.AbiField("priv"
							, Gtk.Bin.abi_info.Fields
							, (uint) sizeof( IntPtr ) // priv
							, null
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
