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

#region Autogenerated code
	public partial class Button : Gtk.Bin, Gtk.IActionable, Gtk.IActivatable {

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

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

		public Button () : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Button)) {
				CreateNativeObject (new string [0], new GLib.Value[0]);
				return;
			}
			Raw = gtk_button_new();
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_button_new_from_icon_name(IntPtr icon_name, int size);

		public Button (string icon_name, Gtk.IconSize size) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Button)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			IntPtr native_icon_name = GLib.Marshaller.StringToPtrGStrdup (icon_name);
			Raw = gtk_button_new_from_icon_name(native_icon_name, (int) size);
			GLib.Marshaller.Free (native_icon_name);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_button_new_with_label(IntPtr label);

		public static Button NewWithLabel(string label)
		{
			IntPtr native_label = GLib.Marshaller.StringToPtrGStrdup (label);
			Button result = new Button (gtk_button_new_with_label(native_label));
			GLib.Marshaller.Free (native_label);
			return result;
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_button_new_with_mnemonic(IntPtr label);

		public static Button NewWithMnemonic(string label)
		{
			IntPtr native_label = GLib.Marshaller.StringToPtrGStrdup (label);
			Button result = new Button (gtk_button_new_with_mnemonic(native_label));
			GLib.Marshaller.Free (native_label);
			return result;
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_label(IntPtr raw, IntPtr label);

		[GLib.Property ("label")]
		public string Label {
			get  {
				IntPtr raw_ret = gtk_button_get_label(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_button_set_label(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_use_underline(IntPtr raw, bool use_underline);

		[GLib.Property ("use-underline")]
		public bool UseUnderline {
			get  {
				bool raw_ret = gtk_button_get_use_underline(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_button_set_use_underline(Handle, value);
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_use_stock(IntPtr raw, bool use_stock);

		[Obsolete]
		[GLib.Property ("use-stock")]
		public bool UseStock {
			get  {
				bool raw_ret = gtk_button_get_use_stock(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_button_set_use_stock(Handle, value);
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_relief(IntPtr raw, int relief);

		[GLib.Property ("relief")]
		public Gtk.ReliefStyle Relief {
			get  {
				int raw_ret = gtk_button_get_relief(Handle);
				Gtk.ReliefStyle ret = (Gtk.ReliefStyle) raw_ret;
				return ret;
			}
			set  {
				gtk_button_set_relief(Handle, (int) value);
			}
		}

		[GLib.Property ("xalign")]
		public float Xalign {
			get {
				GLib.Value val = GetProperty ("xalign");
				float ret = (float) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("xalign", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("yalign")]
		public float Yalign {
			get {
				GLib.Value val = GetProperty ("yalign");
				float ret = (float) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("yalign", val);
				val.Dispose ();
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_image(IntPtr raw, IntPtr image);

		[GLib.Property ("image")]
		public Gtk.Widget Image {
			get  {
				IntPtr raw_ret = gtk_button_get_image(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
			set  {
				gtk_button_set_image(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_image_position(IntPtr raw, int position);

		[GLib.Property ("image-position")]
		public Gtk.PositionType ImagePosition {
			get  {
				int raw_ret = gtk_button_get_image_position(Handle);
				Gtk.PositionType ret = (Gtk.PositionType) raw_ret;
				return ret;
			}
			set  {
				gtk_button_set_image_position(Handle, (int) value);
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_always_show_image(IntPtr raw, bool always_show);

		[GLib.Property ("always-show-image")]
		public bool AlwaysShowImage {
			get  {
				bool raw_ret = gtk_button_get_always_show_image(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_button_set_always_show_image(Handle, value);
			}
		}

		[GLib.Property ("default-border")]
		public Gtk.Border DefaultBorder {
			get {
				GLib.Value val = GetProperty ("default-border");
				Gtk.Border ret = (Gtk.Border) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("default-outside-border")]
		public Gtk.Border DefaultOutsideBorder {
			get {
				GLib.Value val = GetProperty ("default-outside-border");
				Gtk.Border ret = (Gtk.Border) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("child-displacement-x")]
		public int ChildDisplacementX {
			get {
				GLib.Value val = GetProperty ("child-displacement-x");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("child-displacement-y")]
		public int ChildDisplacementY {
			get {
				GLib.Value val = GetProperty ("child-displacement-y");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

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

		[GLib.Property ("inner-border")]
		public Gtk.Border InnerBorder {
			get {
				GLib.Value val = GetProperty ("inner-border");
				Gtk.Border ret = (Gtk.Border) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("image-spacing")]
		public int ImageSpacing {
			get {
				GLib.Value val = GetProperty ("image-spacing");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

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

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

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

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

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

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

		static PressedNativeDelegate Pressed_cb_delegate;
		static PressedNativeDelegate PressedVMCallback {
			get {
				if (Pressed_cb_delegate == null)
					Pressed_cb_delegate = new PressedNativeDelegate (Pressed_cb);
				return Pressed_cb_delegate;
			}
		}

		static void OverridePressed (GLib.GType gtype)
		{
			OverridePressed (gtype, PressedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Button), ConnectionMethod="OverridePressed")]
		protected virtual void OnPressed ()
		{
			InternalPressed ();
		}

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

			unmanaged (this.Handle);
		}

		static ReleasedNativeDelegate Released_cb_delegate;
		static ReleasedNativeDelegate ReleasedVMCallback {
			get {
				if (Released_cb_delegate == null)
					Released_cb_delegate = new ReleasedNativeDelegate (Released_cb);
				return Released_cb_delegate;
			}
		}

		static void OverrideReleased (GLib.GType gtype)
		{
			OverrideReleased (gtype, ReleasedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Button), ConnectionMethod="OverrideReleased")]
		protected virtual void OnReleased ()
		{
			InternalReleased ();
		}

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

			unmanaged (this.Handle);
		}

		static ClickedNativeDelegate Clicked_cb_delegate;
		static ClickedNativeDelegate ClickedVMCallback {
			get {
				if (Clicked_cb_delegate == null)
					Clicked_cb_delegate = new ClickedNativeDelegate (Clicked_cb);
				return Clicked_cb_delegate;
			}
		}

		static void OverrideClicked (GLib.GType gtype)
		{
			OverrideClicked (gtype, ClickedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Button), ConnectionMethod="OverrideClicked")]
		protected virtual void OnClicked ()
		{
			InternalClicked ();
		}

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

			unmanaged (this.Handle);
		}

		static EnteredNativeDelegate Entered_cb_delegate;
		static EnteredNativeDelegate EnteredVMCallback {
			get {
				if (Entered_cb_delegate == null)
					Entered_cb_delegate = new EnteredNativeDelegate (Entered_cb);
				return Entered_cb_delegate;
			}
		}

		static void OverrideEntered (GLib.GType gtype)
		{
			OverrideEntered (gtype, EnteredVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Button), ConnectionMethod="OverrideEntered")]
		protected virtual void OnEntered ()
		{
			InternalEntered ();
		}

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

			unmanaged (this.Handle);
		}

		static LeftNativeDelegate Left_cb_delegate;
		static LeftNativeDelegate LeftVMCallback {
			get {
				if (Left_cb_delegate == null)
					Left_cb_delegate = new LeftNativeDelegate (Left_cb);
				return Left_cb_delegate;
			}
		}

		static void OverrideLeft (GLib.GType gtype)
		{
			OverrideLeft (gtype, LeftVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Button), ConnectionMethod="OverrideLeft")]
		protected virtual void OnLeft ()
		{
			InternalLeft ();
		}

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

			unmanaged (this.Handle);
		}

		static ActivatedNativeDelegate Activated_cb_delegate;
		static ActivatedNativeDelegate ActivatedVMCallback {
			get {
				if (Activated_cb_delegate == null)
					Activated_cb_delegate = new ActivatedNativeDelegate (Activated_cb);
				return Activated_cb_delegate;
			}
		}

		static void OverrideActivated (GLib.GType gtype)
		{
			OverrideActivated (gtype, ActivatedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Button), ConnectionMethod="OverrideActivated")]
		protected virtual void OnActivated ()
		{
			InternalActivated ();
		}

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

			unmanaged (this.Handle);
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("pressed"
							, Gtk.Bin.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pressed
							, null
							, "released"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("released"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // released
							, "pressed"
							, "clicked"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("clicked"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // clicked
							, "released"
							, "enter"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("enter"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // enter
							, "clicked"
							, "leave"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("leave"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // leave
							, "enter"
							, "activate"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("activate"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activate
							, "leave"
							, "_gtk_reserved1"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved1
							, "activate"
							, "_gtk_reserved2"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved3
							, "_gtk_reserved2"
							, "_gtk_reserved4"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved4"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved4
							, "_gtk_reserved3"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

		public void Click() {
			gtk_button_clicked(Handle);
		}

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

		[Obsolete]
		public void Enter() {
			gtk_button_enter(Handle);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_get_alignment(IntPtr raw, out float xalign, out float yalign);

		[Obsolete]
		public void GetAlignment(out float xalign, out float yalign) {
			gtk_button_get_alignment(Handle, out xalign, out yalign);
		}

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

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

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

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

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

		[Obsolete]
		public void Leave() {
			gtk_button_leave(Handle);
		}

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

		[Obsolete]
		public void Press() {
			gtk_button_pressed(Handle);
		}

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

		[Obsolete]
		public void Release() {
			gtk_button_released(Handle);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_button_set_alignment(IntPtr raw, float xalign, float yalign);

		[Obsolete]
		public void SetAlignment(float xalign, float yalign) {
			gtk_button_set_alignment(Handle, xalign, yalign);
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_actionable_set_action_name(IntPtr raw, IntPtr action_name);

		public string ActionName { 
			get {
				IntPtr raw_ret = gtk_actionable_get_action_name(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_actionable_set_action_name(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_actionable_set_action_target_value(IntPtr raw, IntPtr target_value);

		public GLib.Variant ActionTargetValue { 
			get {
				IntPtr raw_ret = gtk_actionable_get_action_target_value(Handle);
				GLib.Variant ret = new GLib.Variant(raw_ret);
				return ret;
			}
			set {
				gtk_actionable_set_action_target_value(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_actionable_set_detailed_action_name(IntPtr raw, IntPtr detailed_action_name);

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_activatable_do_set_related_action(IntPtr raw, IntPtr action);

		[Obsolete]
		public void DoSetRelatedAction(Gtk.Action action) {
			gtk_activatable_do_set_related_action(Handle, action == null ? IntPtr.Zero : action.Handle);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_activatable_sync_action_properties(IntPtr raw, IntPtr action);

		[Obsolete]
		public void SyncActionProperties(Gtk.Action action) {
			gtk_activatable_sync_action_properties(Handle, action == null ? IntPtr.Zero : action.Handle);
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_activatable_set_related_action(IntPtr raw, IntPtr action);

		[Obsolete]
		[GLib.Property ("related-action")]
		public Gtk.Action RelatedAction {
			get  {
				IntPtr raw_ret = gtk_activatable_get_related_action(Handle);
				Gtk.Action ret = GLib.Object.GetObject(raw_ret) as Gtk.Action;
				return ret;
			}
			set  {
				gtk_activatable_set_related_action(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_activatable_set_use_action_appearance(IntPtr raw, bool use_appearance);

		[Obsolete]
		[GLib.Property ("use-action-appearance")]
		public bool UseActionAppearance {
			get  {
				bool raw_ret = gtk_activatable_get_use_action_appearance(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_activatable_set_use_action_appearance(Handle, value);
			}
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("priv"
							, Gtk.Bin.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
							, null
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}