// 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 ListBox : Gtk.Container {

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

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

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

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

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

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

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

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

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

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

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

		[GLib.Signal("row-selected")]
		public event Gtk.RowSelectedHandler RowSelected {
			add {
				this.AddSignalHandler ("row-selected", value, typeof (Gtk.RowSelectedArgs));
			}
			remove {
				this.RemoveSignalHandler ("row-selected", value);
			}
		}

		[GLib.Signal("row-activated")]
		public event Gtk.ListRowActivatedHandler ListRowActivated {
			add {
				this.AddSignalHandler ("row-activated", value, typeof (Gtk.ListRowActivatedArgs));
			}
			remove {
				this.RemoveSignalHandler ("row-activated", value);
			}
		}

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

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

		[GLib.Signal("select-all")]
		public event System.EventHandler SelectedAll {
			add {
				this.AddSignalHandler ("select-all", value);
			}
			remove {
				this.RemoveSignalHandler ("select-all", 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);
			}
		}

		static RowSelectedNativeDelegate RowSelected_cb_delegate;
		static RowSelectedNativeDelegate RowSelectedVMCallback {
			get {
				if (RowSelected_cb_delegate == null)
					RowSelected_cb_delegate = new RowSelectedNativeDelegate (RowSelected_cb);
				return RowSelected_cb_delegate;
			}
		}

		static void OverrideRowSelected (GLib.GType gtype)
		{
			OverrideRowSelected (gtype, RowSelectedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RowSelectedNativeDelegate (IntPtr inst, IntPtr row);

		static void RowSelected_cb (IntPtr inst, IntPtr row)
		{
			try {
				ListBox __obj = GLib.Object.GetObject (inst, false) as ListBox;
				__obj.OnRowSelected (GLib.Object.GetObject(row) as Gtk.ListBoxRow);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ListBox), ConnectionMethod="OverrideRowSelected")]
		protected virtual void OnRowSelected (Gtk.ListBoxRow row)
		{
			InternalRowSelected (row);
		}

		private void InternalRowSelected (Gtk.ListBoxRow row)
		{
			RowSelectedNativeDelegate unmanaged = class_abi.BaseOverride<RowSelectedNativeDelegate>(this.LookupGType(), "row_selected");
			if (unmanaged == null) return;

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

		static ListRowActivatedNativeDelegate ListRowActivated_cb_delegate;
		static ListRowActivatedNativeDelegate ListRowActivatedVMCallback {
			get {
				if (ListRowActivated_cb_delegate == null)
					ListRowActivated_cb_delegate = new ListRowActivatedNativeDelegate (ListRowActivated_cb);
				return ListRowActivated_cb_delegate;
			}
		}

		static void OverrideListRowActivated (GLib.GType gtype)
		{
			OverrideListRowActivated (gtype, ListRowActivatedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ListRowActivatedNativeDelegate (IntPtr inst, IntPtr row);

		static void ListRowActivated_cb (IntPtr inst, IntPtr row)
		{
			try {
				ListBox __obj = GLib.Object.GetObject (inst, false) as ListBox;
				__obj.OnListRowActivated (GLib.Object.GetObject(row) as Gtk.ListBoxRow);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ListBox), ConnectionMethod="OverrideListRowActivated")]
		protected virtual void OnListRowActivated (Gtk.ListBoxRow row)
		{
			InternalListRowActivated (row);
		}

		private void InternalListRowActivated (Gtk.ListBoxRow row)
		{
			ListRowActivatedNativeDelegate unmanaged = class_abi.BaseOverride<ListRowActivatedNativeDelegate>(this.LookupGType(), "row_activated");
			if (unmanaged == null) return;

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

		static ActivateCursorRowNativeDelegate ActivateCursorRow_cb_delegate;
		static ActivateCursorRowNativeDelegate ActivateCursorRowVMCallback {
			get {
				if (ActivateCursorRow_cb_delegate == null)
					ActivateCursorRow_cb_delegate = new ActivateCursorRowNativeDelegate (ActivateCursorRow_cb);
				return ActivateCursorRow_cb_delegate;
			}
		}

		static void OverrideActivateCursorRow (GLib.GType gtype)
		{
			OverrideActivateCursorRow (gtype, ActivateCursorRowVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ListBox), ConnectionMethod="OverrideActivateCursorRow")]
		protected virtual void OnActivateCursorRow ()
		{
			InternalActivateCursorRow ();
		}

		private void InternalActivateCursorRow ()
		{
			ActivateCursorRowNativeDelegate unmanaged = class_abi.BaseOverride<ActivateCursorRowNativeDelegate>(this.LookupGType(), "activate_cursor_row");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ToggleCursorRowNativeDelegate ToggleCursorRow_cb_delegate;
		static ToggleCursorRowNativeDelegate ToggleCursorRowVMCallback {
			get {
				if (ToggleCursorRow_cb_delegate == null)
					ToggleCursorRow_cb_delegate = new ToggleCursorRowNativeDelegate (ToggleCursorRow_cb);
				return ToggleCursorRow_cb_delegate;
			}
		}

		static void OverrideToggleCursorRow (GLib.GType gtype)
		{
			OverrideToggleCursorRow (gtype, ToggleCursorRowVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ListBox), ConnectionMethod="OverrideToggleCursorRow")]
		protected virtual void OnToggleCursorRow ()
		{
			InternalToggleCursorRow ();
		}

		private void InternalToggleCursorRow ()
		{
			ToggleCursorRowNativeDelegate unmanaged = class_abi.BaseOverride<ToggleCursorRowNativeDelegate>(this.LookupGType(), "toggle_cursor_row");
			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 void MoveCursorNativeDelegate (IntPtr inst, int step, int count);

		static void MoveCursor_cb (IntPtr inst, int step, int count)
		{
			try {
				ListBox __obj = GLib.Object.GetObject (inst, false) as ListBox;
				__obj.OnMoveCursor ((Gtk.MovementStep) step, count);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

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

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

			unmanaged (this.Handle, (int) step, count);
		}

		static SelectedRowsChangedNativeDelegate SelectedRowsChanged_cb_delegate;
		static SelectedRowsChangedNativeDelegate SelectedRowsChangedVMCallback {
			get {
				if (SelectedRowsChanged_cb_delegate == null)
					SelectedRowsChanged_cb_delegate = new SelectedRowsChangedNativeDelegate (SelectedRowsChanged_cb);
				return SelectedRowsChanged_cb_delegate;
			}
		}

		static void OverrideSelectedRowsChanged (GLib.GType gtype)
		{
			OverrideSelectedRowsChanged (gtype, SelectedRowsChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ListBox), ConnectionMethod="OverrideSelectedRowsChanged")]
		protected virtual void OnSelectedRowsChanged ()
		{
			InternalSelectedRowsChanged ();
		}

		private void InternalSelectedRowsChanged ()
		{
			SelectedRowsChangedNativeDelegate unmanaged = class_abi.BaseOverride<SelectedRowsChangedNativeDelegate>(this.LookupGType(), "selected_rows_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		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 {
				ListBox __obj = GLib.Object.GetObject (inst, false) as ListBox;
				__obj.OnSelectedAll ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ListBox), 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 {
				ListBox __obj = GLib.Object.GetObject (inst, false) as ListBox;
				__obj.OnUnselectedAll ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.ListBox), 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("row_selected"
							, Gtk.Container.class_abi.Fields
							, (uint) sizeof( IntPtr ) // row_selected
							, null
							, "row_activated"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("row_activated"
							, -1
							, (uint) sizeof( IntPtr ) // row_activated
							, "row_selected"
							, "activate_cursor_row"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate_cursor_row"
							, -1
							, (uint) sizeof( IntPtr ) // activate_cursor_row
							, "row_activated"
							, "toggle_cursor_row"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("toggle_cursor_row"
							, -1
							, (uint) sizeof( IntPtr ) // toggle_cursor_row
							, "activate_cursor_row"
							, "move_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // move_cursor
							, "toggle_cursor_row"
							, "selected_rows_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("selected_rows_changed"
							, -1
							, (uint) sizeof( IntPtr ) // selected_rows_changed
							, "move_cursor"
							, "select_all"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("select_all"
							, -1
							, (uint) sizeof( IntPtr ) // select_all
							, "selected_rows_changed"
							, "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"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

		public void DragHighlightRow(Gtk.ListBoxRow row) {
			gtk_list_box_drag_highlight_row(Handle, row == null ? IntPtr.Zero : row.Handle);
		}

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

		public void DragUnhighlightRow() {
			gtk_list_box_drag_unhighlight_row(Handle);
		}

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

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

		public Gtk.Adjustment Adjustment { 
			get {
				IntPtr raw_ret = gtk_list_box_get_adjustment(Handle);
				Gtk.Adjustment ret = GLib.Object.GetObject(raw_ret) as Gtk.Adjustment;
				return ret;
			}
			set {
				gtk_list_box_set_adjustment(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public Gtk.ListBoxRow GetRowAtIndex(int index_) {
			IntPtr raw_ret = gtk_list_box_get_row_at_index(Handle, index_);
			Gtk.ListBoxRow ret = GLib.Object.GetObject(raw_ret) as Gtk.ListBoxRow;
			return ret;
		}

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

		public Gtk.ListBoxRow GetRowAtY(int y) {
			IntPtr raw_ret = gtk_list_box_get_row_at_y(Handle, y);
			Gtk.ListBoxRow ret = GLib.Object.GetObject(raw_ret) as Gtk.ListBoxRow;
			return ret;
		}

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

		public Gtk.ListBoxRow SelectedRow { 
			get {
				IntPtr raw_ret = gtk_list_box_get_selected_row(Handle);
				Gtk.ListBoxRow ret = GLib.Object.GetObject(raw_ret) as Gtk.ListBoxRow;
				return ret;
			}
		}

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

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

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

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

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

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

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

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

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

		public void InvalidateHeaders() {
			gtk_list_box_invalidate_headers(Handle);
		}

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

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

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

		public void Prepend(Gtk.Widget child) {
			gtk_list_box_prepend(Handle, child == null ? IntPtr.Zero : child.Handle);
		}

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

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

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

		public void SelectRow(Gtk.ListBoxRow row) {
			gtk_list_box_select_row(Handle, row == null ? IntPtr.Zero : row.Handle);
		}

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

		public void SelectedForeach(Gtk.ListBoxForeachFunc func) {
			GtkSharp.ListBoxForeachFuncWrapper func_wrapper = new GtkSharp.ListBoxForeachFuncWrapper (func);
			gtk_list_box_selected_foreach(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
		}

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

		public Gtk.ListBoxFilterFunc FilterFunc { 
			set {
				GtkSharp.ListBoxFilterFuncWrapper value_wrapper = new GtkSharp.ListBoxFilterFuncWrapper (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_list_box_set_filter_func(Handle, value_wrapper.NativeDelegate, user_data, destroy);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_list_box_set_header_func(IntPtr raw, GtkSharp.ListBoxUpdateHeaderFuncNative update_header, IntPtr user_data, GLib.DestroyNotify destroy);
		static d_gtk_list_box_set_header_func gtk_list_box_set_header_func = FuncLoader.LoadFunction<d_gtk_list_box_set_header_func>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_list_box_set_header_func"));

		public Gtk.ListBoxUpdateHeaderFunc HeaderFunc { 
			set {
				GtkSharp.ListBoxUpdateHeaderFuncWrapper value_wrapper = new GtkSharp.ListBoxUpdateHeaderFuncWrapper (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_list_box_set_header_func(Handle, value_wrapper.NativeDelegate, user_data, destroy);
			}
		}

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

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

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

		public Gtk.ListBoxSortFunc SortFunc { 
			set {
				GtkSharp.ListBoxSortFuncWrapper value_wrapper = new GtkSharp.ListBoxSortFuncWrapper (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_list_box_set_sort_func(Handle, value_wrapper.NativeDelegate, user_data, destroy);
			}
		}

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

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

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

		public void UnselectRow(Gtk.ListBoxRow row) {
			gtk_list_box_unselect_row(Handle, row == null ? IntPtr.Zero : row.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 (Gtk.Container.abi_info.Fields);

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
