// 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 FlowBox : Gtk.Container, Gtk.IOrientable {

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

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

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

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

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

		[GLib.Property ("selection-mode")]
		public Gtk.SelectionMode SelectionMode {
			get  {
				int raw_ret = gtk_flow_box_get_selection_mode(Handle);
				Gtk.SelectionMode ret = (Gtk.SelectionMode) raw_ret;
				return ret;
			}
			set  {
				gtk_flow_box_set_selection_mode(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("activate-on-single-click")]
		public bool ActivateOnSingleClick {
			get  {
				bool raw_ret = gtk_flow_box_get_activate_on_single_click(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_flow_box_set_activate_on_single_click(Handle, value);
			}
		}

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

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

		[GLib.Property ("homogeneous")]
		public bool Homogeneous {
			get  {
				bool raw_ret = gtk_flow_box_get_homogeneous(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_flow_box_set_homogeneous(Handle, value);
			}
		}

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

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

		[GLib.Property ("min-children-per-line")]
		public uint MinChildrenPerLine {
			get  {
				uint raw_ret = gtk_flow_box_get_min_children_per_line(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gtk_flow_box_set_min_children_per_line(Handle, value);
			}
		}

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

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

		[GLib.Property ("max-children-per-line")]
		public uint MaxChildrenPerLine {
			get  {
				uint raw_ret = gtk_flow_box_get_max_children_per_line(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gtk_flow_box_set_max_children_per_line(Handle, value);
			}
		}

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

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

		[GLib.Property ("row-spacing")]
		public uint RowSpacing {
			get  {
				uint raw_ret = gtk_flow_box_get_row_spacing(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gtk_flow_box_set_row_spacing(Handle, value);
			}
		}

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

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

		[GLib.Property ("column-spacing")]
		public uint ColumnSpacing {
			get  {
				uint raw_ret = gtk_flow_box_get_column_spacing(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gtk_flow_box_set_column_spacing(Handle, value);
			}
		}

		[GLib.Signal("move-cursor")]
		public event Gtk.MoveCursorHandler MoveCursor {
			add {
				this.AddSignalHandler ("move-cursor", value, typeof (Gtk.MoveCursorArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-cursor", value);
			}
		}

		[GLib.Signal("unselect-all")]
		public event System.EventHandler UnselectedAll {
			add {
				this.AddSignalHandler ("unselect-all", value);
			}
			remove {
				this.RemoveSignalHandler ("unselect-all", value);
			}
		}

		[GLib.Signal("toggle-cursor-child")]
		public event System.EventHandler ToggleCursorChild {
			add {
				this.AddSignalHandler ("toggle-cursor-child", value);
			}
			remove {
				this.RemoveSignalHandler ("toggle-cursor-child", value);
			}
		}

		[GLib.Signal("child-activated")]
		public event Gtk.ChildActivatedHandler ChildActivated {
			add {
				this.AddSignalHandler ("child-activated", value, typeof (Gtk.ChildActivatedArgs));
			}
			remove {
				this.RemoveSignalHandler ("child-activated", value);
			}
		}

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

		[GLib.Signal("select-all")]
		public event System.EventHandler SelectedAll {
			add {
				this.AddSignalHandler ("select-all", value);
			}
			remove {
				this.RemoveSignalHandler ("select-all", value);
			}
		}

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

		static ChildActivatedNativeDelegate ChildActivated_cb_delegate;
		static ChildActivatedNativeDelegate ChildActivatedVMCallback {
			get {
				if (ChildActivated_cb_delegate == null)
					ChildActivated_cb_delegate = new ChildActivatedNativeDelegate (ChildActivated_cb);
				return ChildActivated_cb_delegate;
			}
		}

		static void OverrideChildActivated (GLib.GType gtype)
		{
			OverrideChildActivated (gtype, ChildActivatedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChildActivatedNativeDelegate (IntPtr inst, IntPtr child);

		static void ChildActivated_cb (IntPtr inst, IntPtr child)
		{
			try {
				FlowBox __obj = GLib.Object.GetObject (inst, false) as FlowBox;
				__obj.OnChildActivated (GLib.Object.GetObject(child) as Gtk.FlowBoxChild);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.FlowBox), ConnectionMethod="OverrideChildActivated")]
		protected virtual void OnChildActivated (Gtk.FlowBoxChild child)
		{
			InternalChildActivated (child);
		}

		private void InternalChildActivated (Gtk.FlowBoxChild child)
		{
			ChildActivatedNativeDelegate unmanaged = class_abi.BaseOverride<ChildActivatedNativeDelegate>(this.LookupGType(), "child_activated");
			if (unmanaged == null) return;

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

		static SelectedChildrenChangedNativeDelegate SelectedChildrenChanged_cb_delegate;
		static SelectedChildrenChangedNativeDelegate SelectedChildrenChangedVMCallback {
			get {
				if (SelectedChildrenChanged_cb_delegate == null)
					SelectedChildrenChanged_cb_delegate = new SelectedChildrenChangedNativeDelegate (SelectedChildrenChanged_cb);
				return SelectedChildrenChanged_cb_delegate;
			}
		}

		static void OverrideSelectedChildrenChanged (GLib.GType gtype)
		{
			OverrideSelectedChildrenChanged (gtype, SelectedChildrenChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.FlowBox), ConnectionMethod="OverrideSelectedChildrenChanged")]
		protected virtual void OnSelectedChildrenChanged ()
		{
			InternalSelectedChildrenChanged ();
		}

		private void InternalSelectedChildrenChanged ()
		{
			SelectedChildrenChangedNativeDelegate unmanaged = class_abi.BaseOverride<SelectedChildrenChangedNativeDelegate>(this.LookupGType(), "selected_children_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ActivateCursorChildNativeDelegate ActivateCursorChild_cb_delegate;
		static ActivateCursorChildNativeDelegate ActivateCursorChildVMCallback {
			get {
				if (ActivateCursorChild_cb_delegate == null)
					ActivateCursorChild_cb_delegate = new ActivateCursorChildNativeDelegate (ActivateCursorChild_cb);
				return ActivateCursorChild_cb_delegate;
			}
		}

		static void OverrideActivateCursorChild (GLib.GType gtype)
		{
			OverrideActivateCursorChild (gtype, ActivateCursorChildVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.FlowBox), ConnectionMethod="OverrideActivateCursorChild")]
		protected virtual void OnActivateCursorChild ()
		{
			InternalActivateCursorChild ();
		}

		private void InternalActivateCursorChild ()
		{
			ActivateCursorChildNativeDelegate unmanaged = class_abi.BaseOverride<ActivateCursorChildNativeDelegate>(this.LookupGType(), "activate_cursor_child");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ToggleCursorChildNativeDelegate ToggleCursorChild_cb_delegate;
		static ToggleCursorChildNativeDelegate ToggleCursorChildVMCallback {
			get {
				if (ToggleCursorChild_cb_delegate == null)
					ToggleCursorChild_cb_delegate = new ToggleCursorChildNativeDelegate (ToggleCursorChild_cb);
				return ToggleCursorChild_cb_delegate;
			}
		}

		static void OverrideToggleCursorChild (GLib.GType gtype)
		{
			OverrideToggleCursorChild (gtype, ToggleCursorChildVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.FlowBox), ConnectionMethod="OverrideToggleCursorChild")]
		protected virtual void OnToggleCursorChild ()
		{
			InternalToggleCursorChild ();
		}

		private void InternalToggleCursorChild ()
		{
			ToggleCursorChildNativeDelegate unmanaged = class_abi.BaseOverride<ToggleCursorChildNativeDelegate>(this.LookupGType(), "toggle_cursor_child");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static MoveCursorNativeDelegate MoveCursor_cb_delegate;
		static MoveCursorNativeDelegate MoveCursorVMCallback {
			get {
				if (MoveCursor_cb_delegate == null)
					MoveCursor_cb_delegate = new MoveCursorNativeDelegate (MoveCursor_cb);
				return MoveCursor_cb_delegate;
			}
		}

		static void OverrideMoveCursor (GLib.GType gtype)
		{
			OverrideMoveCursor (gtype, MoveCursorVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool MoveCursorNativeDelegate (IntPtr inst, int step, int count);

		static bool MoveCursor_cb (IntPtr inst, int step, int count)
		{
			try {
				FlowBox __obj = GLib.Object.GetObject (inst, false) as FlowBox;
				bool __result;
				__result = __obj.OnMoveCursor ((Gtk.MovementStep) step, count);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.FlowBox), ConnectionMethod="OverrideMoveCursor")]
		protected virtual bool OnMoveCursor (Gtk.MovementStep step, int count)
		{
			return InternalMoveCursor (step, count);
		}

		private bool InternalMoveCursor (Gtk.MovementStep step, int count)
		{
			MoveCursorNativeDelegate unmanaged = class_abi.BaseOverride<MoveCursorNativeDelegate>(this.LookupGType(), "move_cursor");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, (int) step, count);
			return __result;
		}

		static SelectedAllNativeDelegate SelectedAll_cb_delegate;
		static SelectedAllNativeDelegate SelectedAllVMCallback {
			get {
				if (SelectedAll_cb_delegate == null)
					SelectedAll_cb_delegate = new SelectedAllNativeDelegate (SelectedAll_cb);
				return SelectedAll_cb_delegate;
			}
		}

		static void OverrideSelectedAll (GLib.GType gtype)
		{
			OverrideSelectedAll (gtype, SelectedAllVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.FlowBox), ConnectionMethod="OverrideSelectedAll")]
		protected virtual void OnSelectedAll ()
		{
			InternalSelectedAll ();
		}

		private void InternalSelectedAll ()
		{
			SelectedAllNativeDelegate unmanaged = class_abi.BaseOverride<SelectedAllNativeDelegate>(this.LookupGType(), "select_all");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static UnselectedAllNativeDelegate UnselectedAll_cb_delegate;
		static UnselectedAllNativeDelegate UnselectedAllVMCallback {
			get {
				if (UnselectedAll_cb_delegate == null)
					UnselectedAll_cb_delegate = new UnselectedAllNativeDelegate (UnselectedAll_cb);
				return UnselectedAll_cb_delegate;
			}
		}

		static void OverrideUnselectedAll (GLib.GType gtype)
		{
			OverrideUnselectedAll (gtype, UnselectedAllVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.FlowBox), ConnectionMethod="OverrideUnselectedAll")]
		protected virtual void OnUnselectedAll ()
		{
			InternalUnselectedAll ();
		}

		private void InternalUnselectedAll ()
		{
			UnselectedAllNativeDelegate unmanaged = class_abi.BaseOverride<UnselectedAllNativeDelegate>(this.LookupGType(), "unselect_all");
			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("child_activated"
							, Gtk.Container.class_abi.Fields
							, (uint) sizeof( IntPtr ) // child_activated
							, null
							, "selected_children_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("selected_children_changed"
							, -1
							, (uint) sizeof( IntPtr ) // selected_children_changed
							, "child_activated"
							, "activate_cursor_child"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate_cursor_child"
							, -1
							, (uint) sizeof( IntPtr ) // activate_cursor_child
							, "selected_children_changed"
							, "toggle_cursor_child"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("toggle_cursor_child"
							, -1
							, (uint) sizeof( IntPtr ) // toggle_cursor_child
							, "activate_cursor_child"
							, "move_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // move_cursor
							, "toggle_cursor_child"
							, "select_all"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("select_all"
							, -1
							, (uint) sizeof( IntPtr ) // select_all
							, "move_cursor"
							, "unselect_all"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("unselect_all"
							, -1
							, (uint) sizeof( IntPtr ) // unselect_all
							, "select_all"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "unselect_all"
							, "_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"
							, "_gtk_reserved5"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved5"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved5
							, "_gtk_reserved4"
							, "_gtk_reserved6"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved6"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved6
							, "_gtk_reserved5"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

		public Gtk.FlowBoxChild GetChildAtIndex(int idx) {
			IntPtr raw_ret = gtk_flow_box_get_child_at_index(Handle, idx);
			Gtk.FlowBoxChild ret = GLib.Object.GetObject(raw_ret) as Gtk.FlowBoxChild;
			return ret;
		}

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

		public Gtk.FlowBoxChild GetChildAtPos(int x, int y) {
			IntPtr raw_ret = gtk_flow_box_get_child_at_pos(Handle, x, y);
			Gtk.FlowBoxChild ret = GLib.Object.GetObject(raw_ret) as Gtk.FlowBoxChild;
			return ret;
		}

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

		public Gtk.FlowBoxChild[] SelectedChildren { 
			get {
				IntPtr raw_ret = gtk_flow_box_get_selected_children(Handle);
				Gtk.FlowBoxChild[] ret = GLib.Marshaller.ListPtrToArray<Gtk.FlowBoxChild, Gtk.FlowBoxChild> (raw_ret, true, false);
				return ret;
			}
		}

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

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

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

		public void Insert(Gtk.Widget widget, int position) {
			gtk_flow_box_insert(Handle, widget == null ? IntPtr.Zero : widget.Handle, position);
		}

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

		public void InvalidateFilter() {
			gtk_flow_box_invalidate_filter(Handle);
		}

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

		public void InvalidateSort() {
			gtk_flow_box_invalidate_sort(Handle);
		}

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

		public void SelectAll() {
			gtk_flow_box_select_all(Handle);
		}

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

		public void SelectChild(Gtk.FlowBoxChild child) {
			gtk_flow_box_select_child(Handle, child == null ? IntPtr.Zero : child.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_flow_box_selected_foreach(IntPtr raw, GtkSharp.FlowBoxForeachFuncNative func, IntPtr data);
		static d_gtk_flow_box_selected_foreach gtk_flow_box_selected_foreach = FuncLoader.LoadFunction<d_gtk_flow_box_selected_foreach>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_flow_box_selected_foreach"));

		public void SelectedForeach(Gtk.FlowBoxForeachFunc func) {
			GtkSharp.FlowBoxForeachFuncWrapper func_wrapper = new GtkSharp.FlowBoxForeachFuncWrapper (func);
			gtk_flow_box_selected_foreach(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_flow_box_set_filter_func(IntPtr raw, GtkSharp.FlowBoxFilterFuncNative filter_func, IntPtr user_data, GLib.DestroyNotify destroy);
		static d_gtk_flow_box_set_filter_func gtk_flow_box_set_filter_func = FuncLoader.LoadFunction<d_gtk_flow_box_set_filter_func>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_flow_box_set_filter_func"));

		public Gtk.FlowBoxFilterFunc FilterFunc { 
			set {
				GtkSharp.FlowBoxFilterFuncWrapper value_wrapper = new GtkSharp.FlowBoxFilterFuncWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify destroy;
				if (value == null) {
					user_data = IntPtr.Zero;
					destroy = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					destroy = GLib.DestroyHelper.NotifyHandler;
				}
				gtk_flow_box_set_filter_func(Handle, value_wrapper.NativeDelegate, user_data, destroy);
			}
		}

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

		public Gtk.Adjustment Hadjustment { 
			set {
				gtk_flow_box_set_hadjustment(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_flow_box_set_sort_func(IntPtr raw, GtkSharp.FlowBoxSortFuncNative sort_func, IntPtr user_data, GLib.DestroyNotify destroy);
		static d_gtk_flow_box_set_sort_func gtk_flow_box_set_sort_func = FuncLoader.LoadFunction<d_gtk_flow_box_set_sort_func>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_flow_box_set_sort_func"));

		public Gtk.FlowBoxSortFunc SortFunc { 
			set {
				GtkSharp.FlowBoxSortFuncWrapper value_wrapper = new GtkSharp.FlowBoxSortFuncWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify destroy;
				if (value == null) {
					user_data = IntPtr.Zero;
					destroy = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					destroy = GLib.DestroyHelper.NotifyHandler;
				}
				gtk_flow_box_set_sort_func(Handle, value_wrapper.NativeDelegate, user_data, destroy);
			}
		}

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

		public Gtk.Adjustment Vadjustment { 
			set {
				gtk_flow_box_set_vadjustment(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public void UnselectAll() {
			gtk_flow_box_unselect_all(Handle);
		}

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

		public void UnselectChild(Gtk.FlowBoxChild child) {
			gtk_flow_box_unselect_child(Handle, child == null ? IntPtr.Zero : child.Handle);
		}

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

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

		[GLib.Property ("orientation")]
		public Gtk.Orientation Orientation {
			get  {
				int raw_ret = gtk_orientable_get_orientation(Handle);
				Gtk.Orientation ret = (Gtk.Orientation) raw_ret;
				return ret;
			}
			set  {
				gtk_orientable_set_orientation(Handle, (int) 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 (Gtk.Container.abi_info.Fields);

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
