context: // 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 TreeView : Gtk.Container, Gtk.IScrollable {
  
  		public TreeView (IntPtr raw) : base(raw) {}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gtk_tree_view_new();
  
  		public TreeView () : base (IntPtr.Zero)
  		{
  			if (GetType () != typeof (TreeView)) {
  				CreateNativeObject (new string [0], new GLib.Value[0]);
  				return;
  			}
  			Raw = gtk_tree_view_new();
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gtk_tree_view_new_with_model(IntPtr model);
  
  		public TreeView (Gtk.ITreeModel model) : base (IntPtr.Zero)
  		{
  			if (GetType () != typeof (TreeView)) {
  				var vals = new List<GLib.Value> ();
  				var names = new List<string> ();
  				if (model != null) {
  					names.Add ("model");
  					vals.Add (new GLib.Value (model));
  				}
  				CreateNativeObject (names.ToArray (), vals.ToArray ());
  				return;
  			}
  			Raw = gtk_tree_view_new_with_model(model == null ? IntPtr.Zero : ((model is GLib.Object) ? (model as GLib.Object).Handle : (model as Gtk.TreeModelAdapter).Handle));
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gtk_tree_view_get_model(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_model(IntPtr raw, IntPtr model);
  
  		[GLib.Property ("model")]
  		public Gtk.ITreeModel Model {
  			get  {
  				IntPtr raw_ret = gtk_tree_view_get_model(Handle);
  				Gtk.ITreeModel ret = Gtk.TreeModelAdapter.GetObject (raw_ret, false);
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_model(Handle, value == null ? IntPtr.Zero : ((value is GLib.Object) ? (value as GLib.Object).Handle : (value as Gtk.TreeModelAdapter).Handle));
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_headers_visible(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_headers_visible(IntPtr raw, bool headers_visible);
  
  		[GLib.Property ("headers-visible")]
  		public bool HeadersVisible {
  			get  {
  				bool raw_ret = gtk_tree_view_get_headers_visible(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_headers_visible(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_headers_clickable(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_headers_clickable(IntPtr raw, bool setting);
  
  		[GLib.Property ("headers-clickable")]
  		public bool HeadersClickable {
  			get  {
  				bool raw_ret = gtk_tree_view_get_headers_clickable(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_headers_clickable(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gtk_tree_view_get_expander_column(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_expander_column(IntPtr raw, IntPtr column);
  
  		[GLib.Property ("expander-column")]
  		public Gtk.TreeViewColumn ExpanderColumn {
  			get  {
  				IntPtr raw_ret = gtk_tree_view_get_expander_column(Handle);
  				Gtk.TreeViewColumn ret = GLib.Object.GetObject(raw_ret) as Gtk.TreeViewColumn;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_expander_column(Handle, value == null ? IntPtr.Zero : value.Handle);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_reorderable(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_reorderable(IntPtr raw, bool reorderable);
  
  		[GLib.Property ("reorderable")]
  		public bool Reorderable {
  			get  {
  				bool raw_ret = gtk_tree_view_get_reorderable(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_reorderable(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_rules_hint(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_rules_hint(IntPtr raw, bool setting);
  
  		[GLib.Property ("rules-hint")]
  		public bool RulesHint {
  			get  {
  				bool raw_ret = gtk_tree_view_get_rules_hint(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_rules_hint(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_enable_search(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_enable_search(IntPtr raw, bool enable_search);
  
  		[GLib.Property ("enable-search")]
  		public bool EnableSearch {
  			get  {
  				bool raw_ret = gtk_tree_view_get_enable_search(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_enable_search(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern int gtk_tree_view_get_search_column(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_search_column(IntPtr raw, int column);
  
  		[GLib.Property ("search-column")]
  		public int SearchColumn {
  			get  {
  				int raw_ret = gtk_tree_view_get_search_column(Handle);
  				int ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_search_column(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_fixed_height_mode(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_fixed_height_mode(IntPtr raw, bool enable);
  
  		[GLib.Property ("fixed-height-mode")]
  		public bool FixedHeightMode {
  			get  {
  				bool raw_ret = gtk_tree_view_get_fixed_height_mode(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_fixed_height_mode(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_hover_selection(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_hover_selection(IntPtr raw, bool hover);
  
  		[GLib.Property ("hover-selection")]
  		public bool HoverSelection {
  			get  {
  				bool raw_ret = gtk_tree_view_get_hover_selection(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_hover_selection(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_hover_expand(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_hover_expand(IntPtr raw, bool expand);
  
  		[GLib.Property ("hover-expand")]
  		public bool HoverExpand {
  			get  {
  				bool raw_ret = gtk_tree_view_get_hover_expand(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_hover_expand(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_show_expanders(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_show_expanders(IntPtr raw, bool enabled);
  
  		[GLib.Property ("show-expanders")]
  		public bool ShowExpanders {
  			get  {
  				bool raw_ret = gtk_tree_view_get_show_expanders(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_show_expanders(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern int gtk_tree_view_get_level_indentation(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_level_indentation(IntPtr raw, int indentation);
  
  		[GLib.Property ("level-indentation")]
  		public int LevelIndentation {
  			get  {
  				int raw_ret = gtk_tree_view_get_level_indentation(Handle);
  				int ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_level_indentation(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_rubber_banding(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_rubber_banding(IntPtr raw, bool enable);
  
  		[GLib.Property ("rubber-banding")]
  		public bool RubberBanding {
  			get  {
  				bool raw_ret = gtk_tree_view_get_rubber_banding(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_rubber_banding(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern int gtk_tree_view_get_grid_lines(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_grid_lines(IntPtr raw, int grid_lines);
  
  		[GLib.Property ("enable-grid-lines")]
  		public Gtk.TreeViewGridLines EnableGridLines {
  			get  {
  				int raw_ret = gtk_tree_view_get_grid_lines(Handle);
  				Gtk.TreeViewGridLines ret = (Gtk.TreeViewGridLines) raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_grid_lines(Handle, (int) value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gtk_tree_view_get_enable_tree_lines(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_enable_tree_lines(IntPtr raw, bool enabled);
  
  		[GLib.Property ("enable-tree-lines")]
  		public bool EnableTreeLines {
  			get  {
  				bool raw_ret = gtk_tree_view_get_enable_tree_lines(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_enable_tree_lines(Handle, value);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern int gtk_tree_view_get_tooltip_column(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_tree_view_set_tooltip_column(IntPtr raw, int column);
  
  		[GLib.Property ("tooltip-column")]
  		public int TooltipColumn {
  			get  {
  				int raw_ret = gtk_tree_view_get_tooltip_column(Handle);
  				int ret = raw_ret;
  				return ret;
  			}
  			set  {
  				gtk_tree_view_set_tooltip_column(Handle, value);
  			}
  		}
  
  		[GLib.Signal("cursor-changed")]
  		public event System.EventHandler CursorChanged {
  			add {
  				this.AddSignalHandler ("cursor-changed", value);
  			}
  			remove {
  				this.RemoveSignalHandler ("cursor-changed", value);
  			}
  		}
  
  		[GLib.Signal("test-collapse-row")]
  		public event Gtk.TestCollapseRowHandler TestCollapseRow {
  			add {
  				this.AddSignalHandler ("test-collapse-row", value, typeof (Gtk.TestCollapseRowArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("test-collapse-row", value);
  			}
  		}
  
  		[GLib.Signal("row-activated")]
  		public event Gtk.RowActivatedHandler RowActivated {
  			add {
  				this.AddSignalHandler ("row-activated", value, typeof (Gtk.RowActivatedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("row-activated", value);
  			}
  		}
  
  		[GLib.Signal("expand-collapse-cursor-row")]
  		public event Gtk.ExpandCollapseCursorRowHandler ExpandCollapseCursorRow {
  			add {
  				this.AddSignalHandler ("expand-collapse-cursor-row", value, typeof (Gtk.ExpandCollapseCursorRowArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("expand-collapse-cursor-row", value);
  			}
  		}
  
  		[GLib.Signal("columns-changed")]
  		public event System.EventHandler ColumnsChanged {
  			add {
  				this.AddSignalHandler ("columns-changed", value);
  			}
  			remove {
  				this.RemoveSignalHandler ("columns-changed", value);
  			}
  		}
  
  		[GLib.Signal("unselect-all")]
  		public event Gtk.UnselectAllHandler UnselectAll {
  			add {
  				this.AddSignalHandler ("unselect-all", value, typeof (Gtk.UnselectAllArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("unselect-all", value);
  			}
  		}
  
  		[GLib.Signal("select-cursor-parent")]
  		public event Gtk.SelectCursorParentHandler SelectCursorParent {
  			add {
  				this.AddSignalHandler ("select-cursor-parent", value, typeof (Gtk.SelectCursorParentArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("select-cursor-parent", value);
  			}
  		}
  
  		[GLib.Signal("row-collapsed")]
  		public event Gtk.RowCollapsedHandler RowCollapsed {
  			add {
  				this.AddSignalHandler ("row-collapsed", value, typeof (Gtk.RowCollapsedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("row-collapsed", value);
  			}
  		}
  
  		[GLib.Signal("select-all")]
  		public event Gtk.SelectAllHandler SelectAll {
  			add {
  				this.AddSignalHandler ("select-all", value, typeof (Gtk.SelectAllArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("select-all", value);
  			}
  		}
  
  		[GLib.Signal("select-cursor-row")]
  		public event Gtk.SelectCursorRowHandler SelectCursorRow {
  			add {
  				this.AddSignalHandler ("select-cursor-row", value, typeof (Gtk.SelectCursorRowArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("select-cursor-row", value);
  			}
  		}
  
  		[GLib.Signal("test-expand-row")]
  		public event Gtk.TestExpandRowHandler TestExpandRow {
  			add {
  				this.AddSignalHandler ("test-expand-row", value, typeof (Gtk.TestExpandRowArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("test-expand-row", value);
  			}
  		}
  
  		[GLib.Signal("start-interactive-search")]
  		public event Gtk.StartInteractiveSearchHandler StartInteractiveSearch {
  			add {
  				this.AddSignalHandler ("start-interactive-search", value, typeof (Gtk.StartInteractiveSearchArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("start-interactive-search", 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("row-expanded")]
  		public event Gtk.RowExpandedHandler RowExpanded {
  			add {
  				this.AddSignalHandler ("row-expanded", value, typeof (Gtk.RowExpandedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("row-expanded", value);
  			}
  		}
  
  		[GLib.Signal("toggle-cursor-row")]
  		public event Gtk.ToggleCursorRowHandler ToggleCursorRow {
  			add {
  				this.AddSignalHandler ("toggle-cursor-row", value, typeof (Gtk.ToggleCursorRowArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("toggle-cursor-row", value);
  			}
  		}
  
  		static RowActivatedNativeDelegate RowActivated_cb_delegate;
  		static RowActivatedNativeDelegate RowActivatedVMCallback {
  			get {
  				if (RowActivated_cb_delegate == null)
  					RowActivated_cb_delegate = new RowActivatedNativeDelegate (RowActivated_cb);
  				return RowActivated_cb_delegate;
  			}
  		}
  
  		static void OverrideRowActivated (GLib.GType gtype)
  		{
  			OverrideRowActivated (gtype, RowActivatedVMCallback);
  		}
  
  		static void OverrideRowActivated (GLib.GType gtype, RowActivatedNativeDelegate callback)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.RowActivated = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void RowActivatedNativeDelegate (IntPtr inst, IntPtr path, IntPtr column);
  
  		static void RowActivated_cb (IntPtr inst, IntPtr path, IntPtr column)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				__obj.OnRowActivated (path == IntPtr.Zero ? null : (Gtk.TreePath) GLib.Opaque.GetOpaque (path, typeof (Gtk.TreePath), false), GLib.Object.GetObject(column) as Gtk.TreeViewColumn);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), ConnectionMethod="OverrideRowActivated")]
  		protected virtual void OnRowActivated (Gtk.TreePath path, Gtk.TreeViewColumn column)
  		{
  			InternalRowActivated (path, column);
  		}
  
  		private void InternalRowActivated (Gtk.TreePath path, Gtk.TreeViewColumn column)
  		{
  			RowActivatedNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).RowActivated;
  			if (unmanaged == null) return;
  
  			unmanaged (this.Handle, path == null ? IntPtr.Zero : path.Handle, column == null ? IntPtr.Zero : column.Handle);
  		}
  
  		static TestExpandRowNativeDelegate TestExpandRow_cb_delegate;
  		static TestExpandRowNativeDelegate TestExpandRowVMCallback {
  			get {
  				if (TestExpandRow_cb_delegate == null)
  					TestExpandRow_cb_delegate = new TestExpandRowNativeDelegate (TestExpandRow_cb);
  				return TestExpandRow_cb_delegate;
  			}
  		}
  
  		static void OverrideTestExpandRow (GLib.GType gtype)
  		{
  			OverrideTestExpandRow (gtype, TestExpandRowVMCallback);
  		}
  
  		static void OverrideTestExpandRow (GLib.GType gtype, TestExpandRowNativeDelegate callback)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.TestExpandRow = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool TestExpandRowNativeDelegate (IntPtr inst, IntPtr iter, IntPtr path);
  
  		static bool TestExpandRow_cb (IntPtr inst, IntPtr iter, IntPtr path)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				bool __result;
  				__result = __obj.OnTestExpandRow (Gtk.TreeIter.New (iter), path == IntPtr.Zero ? null : (Gtk.TreePath) GLib.Opaque.GetOpaque (path, typeof (Gtk.TreePath), false));
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), ConnectionMethod="OverrideTestExpandRow")]
  		protected virtual bool OnTestExpandRow (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			return InternalTestExpandRow (iter, path);
  		}
  
  		private bool InternalTestExpandRow (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			TestExpandRowNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).TestExpandRow;
  			if (unmanaged == null) return false;
  
  			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
  			bool __result = unmanaged (this.Handle, native_iter, path == null ? IntPtr.Zero : path.Handle);
  			iter = Gtk.TreeIter.New (native_iter);
  			Marshal.FreeHGlobal (native_iter);
  			return __result;
  		}
  
  		static TestCollapseRowNativeDelegate TestCollapseRow_cb_delegate;
  		static TestCollapseRowNativeDelegate TestCollapseRowVMCallback {
  			get {
  				if (TestCollapseRow_cb_delegate == null)
  					TestCollapseRow_cb_delegate = new TestCollapseRowNativeDelegate (TestCollapseRow_cb);
  				return TestCollapseRow_cb_delegate;
  			}
  		}
  
  		static void OverrideTestCollapseRow (GLib.GType gtype)
  		{
  			OverrideTestCollapseRow (gtype, TestCollapseRowVMCallback);
  		}
  
  		static void OverrideTestCollapseRow (GLib.GType gtype, TestCollapseRowNativeDelegate callback)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.TestCollapseRow = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool TestCollapseRowNativeDelegate (IntPtr inst, IntPtr iter, IntPtr path);
  
  		static bool TestCollapseRow_cb (IntPtr inst, IntPtr iter, IntPtr path)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				bool __result;
  				__result = __obj.OnTestCollapseRow (Gtk.TreeIter.New (iter), path == IntPtr.Zero ? null : (Gtk.TreePath) GLib.Opaque.GetOpaque (path, typeof (Gtk.TreePath), false));
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), ConnectionMethod="OverrideTestCollapseRow")]
  		protected virtual bool OnTestCollapseRow (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			return InternalTestCollapseRow (iter, path);
  		}
  
  		private bool InternalTestCollapseRow (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			TestCollapseRowNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).TestCollapseRow;
  			if (unmanaged == null) return false;
  
  			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
  			bool __result = unmanaged (this.Handle, native_iter, path == null ? IntPtr.Zero : path.Handle);
  			iter = Gtk.TreeIter.New (native_iter);
  			Marshal.FreeHGlobal (native_iter);
  			return __result;
  		}
  
  		static RowExpandedNativeDelegate RowExpanded_cb_delegate;
  		static RowExpandedNativeDelegate RowExpandedVMCallback {
  			get {
  				if (RowExpanded_cb_delegate == null)
  					RowExpanded_cb_delegate = new RowExpandedNativeDelegate (RowExpanded_cb);
  				return RowExpanded_cb_delegate;
  			}
  		}
  
  		static void OverrideRowExpanded (GLib.GType gtype)
  		{
  			OverrideRowExpanded (gtype, RowExpandedVMCallback);
  		}
  
  		static void OverrideRowExpanded (GLib.GType gtype, RowExpandedNativeDelegate callback)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.RowExpanded = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void RowExpandedNativeDelegate (IntPtr inst, IntPtr iter, IntPtr path);
  
  		static void RowExpanded_cb (IntPtr inst, IntPtr iter, IntPtr path)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				__obj.OnRowExpanded (Gtk.TreeIter.New (iter), path == IntPtr.Zero ? null : (Gtk.TreePath) GLib.Opaque.GetOpaque (path, typeof (Gtk.TreePath), false));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), ConnectionMethod="OverrideRowExpanded")]
  		protected virtual void OnRowExpanded (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			InternalRowExpanded (iter, path);
  		}
  
  		private void InternalRowExpanded (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			RowExpandedNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).RowExpanded;
  			if (unmanaged == null) return;
  
  			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
  			unmanaged (this.Handle, native_iter, path == null ? IntPtr.Zero : path.Handle);
  			iter = Gtk.TreeIter.New (native_iter);
  			Marshal.FreeHGlobal (native_iter);
  		}
  
  		static RowCollapsedNativeDelegate RowCollapsed_cb_delegate;
  		static RowCollapsedNativeDelegate RowCollapsedVMCallback {
  			get {
  				if (RowCollapsed_cb_delegate == null)
  					RowCollapsed_cb_delegate = new RowCollapsedNativeDelegate (RowCollapsed_cb);
  				return RowCollapsed_cb_delegate;
  			}
  		}
  
  		static void OverrideRowCollapsed (GLib.GType gtype)
  		{
  			OverrideRowCollapsed (gtype, RowCollapsedVMCallback);
  		}
  
  		static void OverrideRowCollapsed (GLib.GType gtype, RowCollapsedNativeDelegate callback)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.RowCollapsed = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void RowCollapsedNativeDelegate (IntPtr inst, IntPtr iter, IntPtr path);
  
  		static void RowCollapsed_cb (IntPtr inst, IntPtr iter, IntPtr path)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				__obj.OnRowCollapsed (Gtk.TreeIter.New (iter), path == IntPtr.Zero ? null : (Gtk.TreePath) GLib.Opaque.GetOpaque (path, typeof (Gtk.TreePath), false));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), ConnectionMethod="OverrideRowCollapsed")]
  		protected virtual void OnRowCollapsed (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			InternalRowCollapsed (iter, path);
  		}
  
  		private void InternalRowCollapsed (Gtk.TreeIter iter, Gtk.TreePath path)
  		{
  			RowCollapsedNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).RowCollapsed;
  			if (unmanaged == null) return;
  
  			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
  			unmanaged (this.Handle, native_iter, path == null ? IntPtr.Zero : path.Handle);
  			iter = Gtk.TreeIter.New (native_iter);
  			Marshal.FreeHGlobal (native_iter);
  		}
  
  		static ColumnsChangedNativeDelegate ColumnsChanged_cb_delegate;
  		static ColumnsChangedNativeDelegate ColumnsChangedVMCallback {
  			get {
  				if (ColumnsChanged_cb_delegate == null)
  					ColumnsChanged_cb_delegate = new ColumnsChangedNativeDelegate (ColumnsChanged_cb);
  				return ColumnsChanged_cb_delegate;
  			}
  		}
  
  		static void OverrideColumnsChanged (GLib.GType gtype)
  		{
  			OverrideColumnsChanged (gtype, ColumnsChangedVMCallback);
  		}
  
  		static void OverrideColumnsChanged (GLib.GType gtype, ColumnsChangedNativeDelegate callback)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.ColumnsChanged = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ColumnsChangedNativeDelegate (IntPtr inst);
  
  		static void ColumnsChanged_cb (IntPtr inst)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				__obj.OnColumnsChanged ();
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), ConnectionMethod="OverrideColumnsChanged")]
  		protected virtual void OnColumnsChanged ()
  		{
  			InternalColumnsChanged ();
  		}
  
  		private void InternalColumnsChanged ()
  		{
  			ColumnsChangedNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).ColumnsChanged;
  			if (unmanaged == null) return;
  
  			unmanaged (this.Handle);
  		}
  
  		static CursorChangedNativeDelegate CursorChanged_cb_delegate;
  		static CursorChangedNativeDelegate CursorChangedVMCallback {
  			get {
  				if (CursorChanged_cb_delegate == null)
  					CursorChanged_cb_delegate = new CursorChangedNativeDelegate (CursorChanged_cb);
  				return CursorChanged_cb_delegate;
  			}
  		}
  
  		static void OverrideCursorChanged (GLib.GType gtype)
  		{
  			OverrideCursorChanged (gtype, CursorChangedVMCallback);
  		}
  
  		static void OverrideCursorChanged (GLib.GType gtype, CursorChangedNativeDelegate callback)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.CursorChanged = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void CursorChangedNativeDelegate (IntPtr inst);
  
  		static void CursorChanged_cb (IntPtr inst)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				__obj.OnCursorChanged ();
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), ConnectionMethod="OverrideCursorChanged")]
  		protected virtual void OnCursorChanged ()
  		{
  			InternalCursorChanged ();
  		}
  
  		private void InternalCursorChanged ()
  		{
  			CursorChangedNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).CursorChanged;
  			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)
  		{
  			GtkTreeViewClass class_iface = GetClassStruct (gtype, false);
  			class_iface.MoveCursor = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool MoveCursorNativeDelegate (IntPtr inst, int step, int count);
  
  		static bool MoveCursor_cb (IntPtr inst, int step, int count)
  		{
  			try {
  				TreeView __obj = GLib.Object.GetObject (inst, false) as TreeView;
  				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 e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TreeView), 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 = GetClassStruct (this.LookupGType ().GetThresholdType (), true).MoveCursor;
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle, (int) step, count);
  			return __result;
  		}
  
  		static SelectAllNativeDelegate SelectAll_cb_delegate;
  		static SelectAllNativeDelegate SelectAllVMCallback {
  			get {
  				if (SelectAll_cb_delegate == null)
  					SelectAll_cb_delegate = new SelectAllNativeDelegate (SelectAll_cb);
  				return SelectAll_cb_delegate;
  			}
  		}
  
  		static void OverrideSelectAll (GLib.GType gtype)
  		{
  
gt: 			OverrideSelectAll (gtype, SelectAllVMCallback);