// 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 ToolItem : Gtk.Bin, Gtk.IActivatable {

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

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

		public ToolItem () : base (IntPtr.Zero)
		{
			if (GetType () != typeof (ToolItem)) {
				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
				return;
			}
			Raw = gtk_tool_item_new();
		}

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

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

		[GLib.Property ("visible-horizontal")]
		public bool VisibleHorizontal {
			get  {
				bool raw_ret = gtk_tool_item_get_visible_horizontal(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_tool_item_set_visible_horizontal(Handle, value);
			}
		}

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

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

		[GLib.Property ("visible-vertical")]
		public bool VisibleVertical {
			get  {
				bool raw_ret = gtk_tool_item_get_visible_vertical(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_tool_item_set_visible_vertical(Handle, value);
			}
		}

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

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

		[GLib.Property ("is-important")]
		public bool IsImportant {
			get  {
				bool raw_ret = gtk_tool_item_get_is_important(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_tool_item_set_is_important(Handle, value);
			}
		}

		[GLib.Signal("toolbar-reconfigured")]
		public event System.EventHandler ToolbarReconfigured {
			add {
				this.AddSignalHandler ("toolbar-reconfigured", value);
			}
			remove {
				this.RemoveSignalHandler ("toolbar-reconfigured", value);
			}
		}

		[GLib.Signal("create-menu-proxy")]
		public event Gtk.CreateMenuProxyHandler CreateMenuProxy {
			add {
				this.AddSignalHandler ("create-menu-proxy", value, typeof (Gtk.CreateMenuProxyArgs));
			}
			remove {
				this.RemoveSignalHandler ("create-menu-proxy", value);
			}
		}

		static CreateMenuProxyNativeDelegate CreateMenuProxy_cb_delegate;
		static CreateMenuProxyNativeDelegate CreateMenuProxyVMCallback {
			get {
				if (CreateMenuProxy_cb_delegate == null)
					CreateMenuProxy_cb_delegate = new CreateMenuProxyNativeDelegate (CreateMenuProxy_cb);
				return CreateMenuProxy_cb_delegate;
			}
		}

		static void OverrideCreateMenuProxy (GLib.GType gtype)
		{
			OverrideCreateMenuProxy (gtype, CreateMenuProxyVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ToolItem), ConnectionMethod="OverrideCreateMenuProxy")]
		protected virtual bool OnCreateMenuProxy ()
		{
			return InternalCreateMenuProxy ();
		}

		private bool InternalCreateMenuProxy ()
		{
			CreateMenuProxyNativeDelegate unmanaged = class_abi.BaseOverride<CreateMenuProxyNativeDelegate>(this.LookupGType(), "create_menu_proxy");
			if (unmanaged == null) return false;

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

		static ToolbarReconfiguredNativeDelegate ToolbarReconfigured_cb_delegate;
		static ToolbarReconfiguredNativeDelegate ToolbarReconfiguredVMCallback {
			get {
				if (ToolbarReconfigured_cb_delegate == null)
					ToolbarReconfigured_cb_delegate = new ToolbarReconfiguredNativeDelegate (ToolbarReconfigured_cb);
				return ToolbarReconfigured_cb_delegate;
			}
		}

		static void OverrideToolbarReconfigured (GLib.GType gtype)
		{
			OverrideToolbarReconfigured (gtype, ToolbarReconfiguredVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ToolItem), ConnectionMethod="OverrideToolbarReconfigured")]
		protected virtual void OnToolbarReconfigured ()
		{
			InternalToolbarReconfigured ();
		}

		private void InternalToolbarReconfigured ()
		{
			ToolbarReconfiguredNativeDelegate unmanaged = class_abi.BaseOverride<ToolbarReconfiguredNativeDelegate>(this.LookupGType(), "toolbar_reconfigured");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}


		// 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("create_menu_proxy"
							, Gtk.Bin.class_abi.Fields
							, (uint) sizeof( IntPtr ) // create_menu_proxy
							, null
							, "toolbar_reconfigured"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("toolbar_reconfigured"
							, -1
							, (uint) sizeof( IntPtr ) // toolbar_reconfigured
							, "create_menu_proxy"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "toolbar_reconfigured"
							, "_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"
							, "_gtk_reserved4"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved4"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved4
							, "_gtk_reserved3"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

		public Pango.EllipsizeMode EllipsizeMode { 
			get {
				int raw_ret = gtk_tool_item_get_ellipsize_mode(Handle);
				Pango.EllipsizeMode ret = (Pango.EllipsizeMode) raw_ret;
				return ret;
			}
		}

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

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

		public new bool Expand { 
			get {
				bool raw_ret = gtk_tool_item_get_expand(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_tool_item_set_expand(Handle, value);
			}
		}

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

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

		public bool Homogeneous { 
			get {
				bool raw_ret = gtk_tool_item_get_homogeneous(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_tool_item_set_homogeneous(Handle, value);
			}
		}

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

		public Gtk.IconSize IconSize { 
			get {
				int raw_ret = gtk_tool_item_get_icon_size(Handle);
				Gtk.IconSize ret = (Gtk.IconSize) raw_ret;
				return ret;
			}
		}

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

		public Gtk.Orientation Orientation { 
			get {
				int raw_ret = gtk_tool_item_get_orientation(Handle);
				Gtk.Orientation ret = (Gtk.Orientation) raw_ret;
				return ret;
			}
		}

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

		public Gtk.Widget GetProxyMenuItem(string menu_item_id) {
			IntPtr native_menu_item_id = GLib.Marshaller.StringToPtrGStrdup (menu_item_id);
			IntPtr raw_ret = gtk_tool_item_get_proxy_menu_item(Handle, native_menu_item_id);
			Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
			GLib.Marshaller.Free (native_menu_item_id);
			return ret;
		}

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

		public Gtk.ReliefStyle ReliefStyle { 
			get {
				int raw_ret = gtk_tool_item_get_relief_style(Handle);
				Gtk.ReliefStyle ret = (Gtk.ReliefStyle) raw_ret;
				return ret;
			}
		}

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

		public float TextAlignment { 
			get {
				float raw_ret = gtk_tool_item_get_text_alignment(Handle);
				float ret = raw_ret;
				return ret;
			}
		}

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

		public Gtk.Orientation TextOrientation { 
			get {
				int raw_ret = gtk_tool_item_get_text_orientation(Handle);
				Gtk.Orientation ret = (Gtk.Orientation) raw_ret;
				return ret;
			}
		}

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

		public Gtk.SizeGroup TextSizeGroup { 
			get {
				IntPtr raw_ret = gtk_tool_item_get_text_size_group(Handle);
				Gtk.SizeGroup ret = GLib.Object.GetObject(raw_ret) as Gtk.SizeGroup;
				return ret;
			}
		}

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

		public Gtk.ToolbarStyle ToolbarStyle { 
			get {
				int raw_ret = gtk_tool_item_get_toolbar_style(Handle);
				Gtk.ToolbarStyle ret = (Gtk.ToolbarStyle) raw_ret;
				return ret;
			}
		}

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

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

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

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

		public bool UseDragWindow { 
			get {
				bool raw_ret = gtk_tool_item_get_use_drag_window(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_tool_item_set_use_drag_window(Handle, value);
			}
		}

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

		public void RebuildMenu() {
			gtk_tool_item_rebuild_menu(Handle);
		}

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

		public Gtk.Widget RetrieveProxyMenuItem() {
			IntPtr raw_ret = gtk_tool_item_retrieve_proxy_menu_item(Handle);
			Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
			return ret;
		}

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

		public void SetProxyMenuItem(string menu_item_id, Gtk.Widget menu_item) {
			IntPtr native_menu_item_id = GLib.Marshaller.StringToPtrGStrdup (menu_item_id);
			gtk_tool_item_set_proxy_menu_item(Handle, native_menu_item_id, menu_item == null ? IntPtr.Zero : menu_item.Handle);
			GLib.Marshaller.Free (native_menu_item_id);
		}

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

		public void EmitToolbarReconfigured() {
			gtk_tool_item_toolbar_reconfigured(Handle);
		}

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

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

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

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_activatable_set_related_action(IntPtr raw, IntPtr action);
		static d_gtk_activatable_set_related_action gtk_activatable_set_related_action = FuncLoader.LoadFunction<d_gtk_activatable_set_related_action>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_activatable_set_related_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);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_activatable_set_use_action_appearance(IntPtr raw, bool use_appearance);
		static d_gtk_activatable_set_use_action_appearance gtk_activatable_set_use_action_appearance = FuncLoader.LoadFunction<d_gtk_activatable_set_use_action_appearance>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_activatable_set_use_action_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 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
	}
}
