gtktreeview.go RawHistoryFolder

1// Package gtk was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gtk
3
4import (
5	"structs"
6	"unsafe"
7
8	"github.com/ebitengine/purego"
9
10	"github.com/bnema/puregotk/pkg/core"
11	"github.com/bnema/puregotk/v4/gdk"
12	"github.com/bnema/puregotk/v4/glib"
13	"github.com/bnema/puregotk/v4/gobject"
14	"github.com/bnema/puregotk/v4/gobject/types"
15)
16
17// Function type for determining whether @column can be dropped in a
18// particular spot (as determined by @prev_column and @next_column).  In
19// left to right locales, @prev_column is on the left of the potential drop
20// spot, and @next_column is on the right.  In right to left mode, this is
21// reversed.  This function should return %TRUE if the spot is a valid drop
22// spot.  Please note that returning %TRUE does not actually indicate that
23// the column drop was made, but is meant only to indicate a possible drop
24// spot to the user.
25type TreeViewColumnDropFunc func(uintptr, uintptr, uintptr, uintptr, uintptr) bool
26
27// Function used for gtk_tree_view_map_expanded_rows().
28type TreeViewMappingFunc func(uintptr, *TreePath, uintptr)
29
30// Function type for determining whether the row pointed to by @iter should
31// be rendered as a separator. A common way to implement this is to have a
32// boolean column in the model, whose values the `GtkTreeViewRowSeparatorFunc`
33// returns.
34type TreeViewRowSeparatorFunc func(uintptr, *TreeIter, uintptr) bool
35
36// A function used for checking whether a row in @model matches
37// a search key string entered by the user. Note the return value
38// is reversed from what you would normally expect, though it
39// has some similarity to strcmp() returning 0 for equal strings.
40type TreeViewSearchEqualFunc func(uintptr, int, string, *TreeIter, uintptr) bool
41
42type TreeViewClass struct {
43	_ structs.HostLayout
44
45	ParentClass WidgetClass
46
47	xRowActivated uintptr
48
49	xTestExpandRow uintptr
50
51	xTestCollapseRow uintptr
52
53	xRowExpanded uintptr
54
55	xRowCollapsed uintptr
56
57	xColumnsChanged uintptr
58
59	xCursorChanged uintptr
60
61	xMoveCursor uintptr
62
63	xSelectAll uintptr
64
65	xUnselectAll uintptr
66
67	xSelectCursorRow uintptr
68
69	xToggleCursorRow uintptr
70
71	xExpandCollapseCursorRow uintptr
72
73	xSelectCursorParent uintptr
74
75	xStartInteractiveSearch uintptr
76
77	Reserved [16]uintptr
78}
79
80func (x *TreeViewClass) GoPointer() uintptr {
81	return uintptr(unsafe.Pointer(x))
82}
83
84// OverrideRowActivated sets the "row_activated" callback function.
85func (x *TreeViewClass) OverrideRowActivated(cb func(*TreeView, *TreePath, *TreeViewColumn)) {
86	if cb == nil {
87		x.xRowActivated = 0
88	} else {
89		x.xRowActivated = purego.NewCallback(func(TreeViewVarp uintptr, PathVarp *TreePath, ColumnVarp uintptr) {
90			cb(TreeViewNewFromInternalPtr(TreeViewVarp), PathVarp, TreeViewColumnNewFromInternalPtr(ColumnVarp))
91		})
92	}
93}
94
95// GetRowActivated gets the "row_activated" callback function.
96func (x *TreeViewClass) GetRowActivated() func(*TreeView, *TreePath, *TreeViewColumn) {
97	if x.xRowActivated == 0 {
98		return nil
99	}
100	var rawCallback func(TreeViewVarp uintptr, PathVarp *TreePath, ColumnVarp uintptr)
101	purego.RegisterFunc(&rawCallback, x.xRowActivated)
102	return func(TreeViewVar *TreeView, PathVar *TreePath, ColumnVar *TreeViewColumn) {
103		rawCallback(TreeViewVar.GoPointer(), PathVar, ColumnVar.GoPointer())
104	}
105}
106
107// OverrideTestExpandRow sets the "test_expand_row" callback function.
108func (x *TreeViewClass) OverrideTestExpandRow(cb func(*TreeView, *TreeIter, *TreePath) bool) {
109	if cb == nil {
110		x.xTestExpandRow = 0
111	} else {
112		x.xTestExpandRow = purego.NewCallback(func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath) bool {
113			return cb(TreeViewNewFromInternalPtr(TreeViewVarp), IterVarp, PathVarp)
114		})
115	}
116}
117
118// GetTestExpandRow gets the "test_expand_row" callback function.
119func (x *TreeViewClass) GetTestExpandRow() func(*TreeView, *TreeIter, *TreePath) bool {
120	if x.xTestExpandRow == 0 {
121		return nil
122	}
123	var rawCallback func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath) bool
124	purego.RegisterFunc(&rawCallback, x.xTestExpandRow)
125	return func(TreeViewVar *TreeView, IterVar *TreeIter, PathVar *TreePath) bool {
126		return rawCallback(TreeViewVar.GoPointer(), IterVar, PathVar)
127	}
128}
129
130// OverrideTestCollapseRow sets the "test_collapse_row" callback function.
131func (x *TreeViewClass) OverrideTestCollapseRow(cb func(*TreeView, *TreeIter, *TreePath) bool) {
132	if cb == nil {
133		x.xTestCollapseRow = 0
134	} else {
135		x.xTestCollapseRow = purego.NewCallback(func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath) bool {
136			return cb(TreeViewNewFromInternalPtr(TreeViewVarp), IterVarp, PathVarp)
137		})
138	}
139}
140
141// GetTestCollapseRow gets the "test_collapse_row" callback function.
142func (x *TreeViewClass) GetTestCollapseRow() func(*TreeView, *TreeIter, *TreePath) bool {
143	if x.xTestCollapseRow == 0 {
144		return nil
145	}
146	var rawCallback func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath) bool
147	purego.RegisterFunc(&rawCallback, x.xTestCollapseRow)
148	return func(TreeViewVar *TreeView, IterVar *TreeIter, PathVar *TreePath) bool {
149		return rawCallback(TreeViewVar.GoPointer(), IterVar, PathVar)
150	}
151}
152
153// OverrideRowExpanded sets the "row_expanded" callback function.
154func (x *TreeViewClass) OverrideRowExpanded(cb func(*TreeView, *TreeIter, *TreePath)) {
155	if cb == nil {
156		x.xRowExpanded = 0
157	} else {
158		x.xRowExpanded = purego.NewCallback(func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath) {
159			cb(TreeViewNewFromInternalPtr(TreeViewVarp), IterVarp, PathVarp)
160		})
161	}
162}
163
164// GetRowExpanded gets the "row_expanded" callback function.
165func (x *TreeViewClass) GetRowExpanded() func(*TreeView, *TreeIter, *TreePath) {
166	if x.xRowExpanded == 0 {
167		return nil
168	}
169	var rawCallback func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath)
170	purego.RegisterFunc(&rawCallback, x.xRowExpanded)
171	return func(TreeViewVar *TreeView, IterVar *TreeIter, PathVar *TreePath) {
172		rawCallback(TreeViewVar.GoPointer(), IterVar, PathVar)
173	}
174}
175
176// OverrideRowCollapsed sets the "row_collapsed" callback function.
177func (x *TreeViewClass) OverrideRowCollapsed(cb func(*TreeView, *TreeIter, *TreePath)) {
178	if cb == nil {
179		x.xRowCollapsed = 0
180	} else {
181		x.xRowCollapsed = purego.NewCallback(func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath) {
182			cb(TreeViewNewFromInternalPtr(TreeViewVarp), IterVarp, PathVarp)
183		})
184	}
185}
186
187// GetRowCollapsed gets the "row_collapsed" callback function.
188func (x *TreeViewClass) GetRowCollapsed() func(*TreeView, *TreeIter, *TreePath) {
189	if x.xRowCollapsed == 0 {
190		return nil
191	}
192	var rawCallback func(TreeViewVarp uintptr, IterVarp *TreeIter, PathVarp *TreePath)
193	purego.RegisterFunc(&rawCallback, x.xRowCollapsed)
194	return func(TreeViewVar *TreeView, IterVar *TreeIter, PathVar *TreePath) {
195		rawCallback(TreeViewVar.GoPointer(), IterVar, PathVar)
196	}
197}
198
199// OverrideColumnsChanged sets the "columns_changed" callback function.
200func (x *TreeViewClass) OverrideColumnsChanged(cb func(*TreeView)) {
201	if cb == nil {
202		x.xColumnsChanged = 0
203	} else {
204		x.xColumnsChanged = purego.NewCallback(func(TreeViewVarp uintptr) {
205			cb(TreeViewNewFromInternalPtr(TreeViewVarp))
206		})
207	}
208}
209
210// GetColumnsChanged gets the "columns_changed" callback function.
211func (x *TreeViewClass) GetColumnsChanged() func(*TreeView) {
212	if x.xColumnsChanged == 0 {
213		return nil
214	}
215	var rawCallback func(TreeViewVarp uintptr)
216	purego.RegisterFunc(&rawCallback, x.xColumnsChanged)
217	return func(TreeViewVar *TreeView) {
218		rawCallback(TreeViewVar.GoPointer())
219	}
220}
221
222// OverrideCursorChanged sets the "cursor_changed" callback function.
223func (x *TreeViewClass) OverrideCursorChanged(cb func(*TreeView)) {
224	if cb == nil {
225		x.xCursorChanged = 0
226	} else {
227		x.xCursorChanged = purego.NewCallback(func(TreeViewVarp uintptr) {
228			cb(TreeViewNewFromInternalPtr(TreeViewVarp))
229		})
230	}
231}
232
233// GetCursorChanged gets the "cursor_changed" callback function.
234func (x *TreeViewClass) GetCursorChanged() func(*TreeView) {
235	if x.xCursorChanged == 0 {
236		return nil
237	}
238	var rawCallback func(TreeViewVarp uintptr)
239	purego.RegisterFunc(&rawCallback, x.xCursorChanged)
240	return func(TreeViewVar *TreeView) {
241		rawCallback(TreeViewVar.GoPointer())
242	}
243}
244
245// OverrideMoveCursor sets the "move_cursor" callback function.
246func (x *TreeViewClass) OverrideMoveCursor(cb func(*TreeView, MovementStep, int, bool, bool) bool) {
247	if cb == nil {
248		x.xMoveCursor = 0
249	} else {
250		x.xMoveCursor = purego.NewCallback(func(TreeViewVarp uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool, ModifyVarp bool) bool {
251			return cb(TreeViewNewFromInternalPtr(TreeViewVarp), StepVarp, CountVarp, ExtendVarp, ModifyVarp)
252		})
253	}
254}
255
256// GetMoveCursor gets the "move_cursor" callback function.
257func (x *TreeViewClass) GetMoveCursor() func(*TreeView, MovementStep, int, bool, bool) bool {
258	if x.xMoveCursor == 0 {
259		return nil
260	}
261	var rawCallback func(TreeViewVarp uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool, ModifyVarp bool) bool
262	purego.RegisterFunc(&rawCallback, x.xMoveCursor)
263	return func(TreeViewVar *TreeView, StepVar MovementStep, CountVar int, ExtendVar bool, ModifyVar bool) bool {
264		return rawCallback(TreeViewVar.GoPointer(), StepVar, CountVar, ExtendVar, ModifyVar)
265	}
266}
267
268// OverrideSelectAll sets the "select_all" callback function.
269func (x *TreeViewClass) OverrideSelectAll(cb func(*TreeView) bool) {
270	if cb == nil {
271		x.xSelectAll = 0
272	} else {
273		x.xSelectAll = purego.NewCallback(func(TreeViewVarp uintptr) bool {
274			return cb(TreeViewNewFromInternalPtr(TreeViewVarp))
275		})
276	}
277}
278
279// GetSelectAll gets the "select_all" callback function.
280func (x *TreeViewClass) GetSelectAll() func(*TreeView) bool {
281	if x.xSelectAll == 0 {
282		return nil
283	}
284	var rawCallback func(TreeViewVarp uintptr) bool
285	purego.RegisterFunc(&rawCallback, x.xSelectAll)
286	return func(TreeViewVar *TreeView) bool {
287		return rawCallback(TreeViewVar.GoPointer())
288	}
289}
290
291// OverrideUnselectAll sets the "unselect_all" callback function.
292func (x *TreeViewClass) OverrideUnselectAll(cb func(*TreeView) bool) {
293	if cb == nil {
294		x.xUnselectAll = 0
295	} else {
296		x.xUnselectAll = purego.NewCallback(func(TreeViewVarp uintptr) bool {
297			return cb(TreeViewNewFromInternalPtr(TreeViewVarp))
298		})
299	}
300}
301
302// GetUnselectAll gets the "unselect_all" callback function.
303func (x *TreeViewClass) GetUnselectAll() func(*TreeView) bool {
304	if x.xUnselectAll == 0 {
305		return nil
306	}
307	var rawCallback func(TreeViewVarp uintptr) bool
308	purego.RegisterFunc(&rawCallback, x.xUnselectAll)
309	return func(TreeViewVar *TreeView) bool {
310		return rawCallback(TreeViewVar.GoPointer())
311	}
312}
313
314// OverrideSelectCursorRow sets the "select_cursor_row" callback function.
315func (x *TreeViewClass) OverrideSelectCursorRow(cb func(*TreeView, bool) bool) {
316	if cb == nil {
317		x.xSelectCursorRow = 0
318	} else {
319		x.xSelectCursorRow = purego.NewCallback(func(TreeViewVarp uintptr, StartEditingVarp bool) bool {
320			return cb(TreeViewNewFromInternalPtr(TreeViewVarp), StartEditingVarp)
321		})
322	}
323}
324
325// GetSelectCursorRow gets the "select_cursor_row" callback function.
326func (x *TreeViewClass) GetSelectCursorRow() func(*TreeView, bool) bool {
327	if x.xSelectCursorRow == 0 {
328		return nil
329	}
330	var rawCallback func(TreeViewVarp uintptr, StartEditingVarp bool) bool
331	purego.RegisterFunc(&rawCallback, x.xSelectCursorRow)
332	return func(TreeViewVar *TreeView, StartEditingVar bool) bool {
333		return rawCallback(TreeViewVar.GoPointer(), StartEditingVar)
334	}
335}
336
337// OverrideToggleCursorRow sets the "toggle_cursor_row" callback function.
338func (x *TreeViewClass) OverrideToggleCursorRow(cb func(*TreeView) bool) {
339	if cb == nil {
340		x.xToggleCursorRow = 0
341	} else {
342		x.xToggleCursorRow = purego.NewCallback(func(TreeViewVarp uintptr) bool {
343			return cb(TreeViewNewFromInternalPtr(TreeViewVarp))
344		})
345	}
346}
347
348// GetToggleCursorRow gets the "toggle_cursor_row" callback function.
349func (x *TreeViewClass) GetToggleCursorRow() func(*TreeView) bool {
350	if x.xToggleCursorRow == 0 {
351		return nil
352	}
353	var rawCallback func(TreeViewVarp uintptr) bool
354	purego.RegisterFunc(&rawCallback, x.xToggleCursorRow)
355	return func(TreeViewVar *TreeView) bool {
356		return rawCallback(TreeViewVar.GoPointer())
357	}
358}
359
360// OverrideExpandCollapseCursorRow sets the "expand_collapse_cursor_row" callback function.
361func (x *TreeViewClass) OverrideExpandCollapseCursorRow(cb func(*TreeView, bool, bool, bool) bool) {
362	if cb == nil {
363		x.xExpandCollapseCursorRow = 0
364	} else {
365		x.xExpandCollapseCursorRow = purego.NewCallback(func(TreeViewVarp uintptr, LogicalVarp bool, ExpandVarp bool, OpenAllVarp bool) bool {
366			return cb(TreeViewNewFromInternalPtr(TreeViewVarp), LogicalVarp, ExpandVarp, OpenAllVarp)
367		})
368	}
369}
370
371// GetExpandCollapseCursorRow gets the "expand_collapse_cursor_row" callback function.
372func (x *TreeViewClass) GetExpandCollapseCursorRow() func(*TreeView, bool, bool, bool) bool {
373	if x.xExpandCollapseCursorRow == 0 {
374		return nil
375	}
376	var rawCallback func(TreeViewVarp uintptr, LogicalVarp bool, ExpandVarp bool, OpenAllVarp bool) bool
377	purego.RegisterFunc(&rawCallback, x.xExpandCollapseCursorRow)
378	return func(TreeViewVar *TreeView, LogicalVar bool, ExpandVar bool, OpenAllVar bool) bool {
379		return rawCallback(TreeViewVar.GoPointer(), LogicalVar, ExpandVar, OpenAllVar)
380	}
381}
382
383// OverrideSelectCursorParent sets the "select_cursor_parent" callback function.
384func (x *TreeViewClass) OverrideSelectCursorParent(cb func(*TreeView) bool) {
385	if cb == nil {
386		x.xSelectCursorParent = 0
387	} else {
388		x.xSelectCursorParent = purego.NewCallback(func(TreeViewVarp uintptr) bool {
389			return cb(TreeViewNewFromInternalPtr(TreeViewVarp))
390		})
391	}
392}
393
394// GetSelectCursorParent gets the "select_cursor_parent" callback function.
395func (x *TreeViewClass) GetSelectCursorParent() func(*TreeView) bool {
396	if x.xSelectCursorParent == 0 {
397		return nil
398	}
399	var rawCallback func(TreeViewVarp uintptr) bool
400	purego.RegisterFunc(&rawCallback, x.xSelectCursorParent)
401	return func(TreeViewVar *TreeView) bool {
402		return rawCallback(TreeViewVar.GoPointer())
403	}
404}
405
406// OverrideStartInteractiveSearch sets the "start_interactive_search" callback function.
407func (x *TreeViewClass) OverrideStartInteractiveSearch(cb func(*TreeView) bool) {
408	if cb == nil {
409		x.xStartInteractiveSearch = 0
410	} else {
411		x.xStartInteractiveSearch = purego.NewCallback(func(TreeViewVarp uintptr) bool {
412			return cb(TreeViewNewFromInternalPtr(TreeViewVarp))
413		})
414	}
415}
416
417// GetStartInteractiveSearch gets the "start_interactive_search" callback function.
418func (x *TreeViewClass) GetStartInteractiveSearch() func(*TreeView) bool {
419	if x.xStartInteractiveSearch == 0 {
420		return nil
421	}
422	var rawCallback func(TreeViewVarp uintptr) bool
423	purego.RegisterFunc(&rawCallback, x.xStartInteractiveSearch)
424	return func(TreeViewVar *TreeView) bool {
425		return rawCallback(TreeViewVar.GoPointer())
426	}
427}
428
429// An enum for determining where a dropped row goes.
430type TreeViewDropPosition int
431
432var xTreeViewDropPositionGLibType func() types.GType
433
434func TreeViewDropPositionGLibType() types.GType {
435	return xTreeViewDropPositionGLibType()
436}
437
438const (
439
440	// dropped row is inserted before
441	TreeViewDropBeforeValue TreeViewDropPosition = 0
442	// dropped row is inserted after
443	TreeViewDropAfterValue TreeViewDropPosition = 1
444	// dropped row becomes a child or is inserted before
445	TreeViewDropIntoOrBeforeValue TreeViewDropPosition = 2
446	// dropped row becomes a child or is inserted after
447	TreeViewDropIntoOrAfterValue TreeViewDropPosition = 3
448)
449
450// A widget for displaying both trees and lists
451//
452// <picture>
453//
454//	<source srcset="list-and-tree-dark.png" media="(prefers-color-scheme: dark)">
455//	<img alt="An example GtkTreeView" src="list-and-tree.png">
456//
457// </picture>
458//
459// Widget that displays any object that implements the [iface@Gtk.TreeModel] interface.
460//
461// Please refer to the [tree widget conceptual overview](section-tree-widget.html)
462// for an overview of all the objects and data types related to the tree
463// widget and how they work together.
464//
465// ## Coordinate systems in GtkTreeView API
466//
467// Several different coordinate systems are exposed in the `GtkTreeView` API.
468// These are:
469//
470// ![](tree-view-coordinates.png)
471//
472// - Widget coordinates: Coordinates relative to the widget (usually `widget->window`).
473//
474// - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
475//
476//   - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
477//     coordinates start at (0, 0) for row 0 of the tree.
478//
479// Several functions are available for converting between the different
480// coordinate systems.  The most common translations are between widget and bin
481// window coordinates and between bin window and tree coordinates. For the
482// former you can use [method@Gtk.TreeView.convert_widget_to_bin_window_coords]
483// (and vice versa), for the latter [method@Gtk.TreeView.convert_bin_window_to_tree_coords]
484// (and vice versa).
485//
486// ## `GtkTreeView` as `GtkBuildable`
487//
488// The `GtkTreeView` implementation of the `GtkBuildable` interface accepts
489// [class@Gtk.TreeViewColumn] objects as `<child>` elements and exposes the
490// internal [class@Gtk.TreeSelection] in UI definitions.
491//
492// An example of a UI definition fragment with `GtkTreeView`:
493//
494// ```xml
495// <object class="GtkTreeView" id="treeview">
496//
497//	<property name="model">liststore1</property>
498//	<child>
499//	  <object class="GtkTreeViewColumn" id="test-column">
500//	    <property name="title">Test</property>
501//	    <child>
502//	      <object class="GtkCellRendererText" id="test-renderer"/>
503//	      <attributes>
504//	        <attribute name="text">1</attribute>
505//	      </attributes>
506//	    </child>
507//	  </object>
508//	</child>
509//	<child internal-child="selection">
510//	  <object class="GtkTreeSelection" id="selection">
511//	    <signal name="changed" handler="on_treeview_selection_changed"/>
512//	  </object>
513//	</child>
514//
515// </object>
516// ```
517//
518// ## CSS nodes
519//
520// ```
521// treeview.view
522// ├── header
523// │   ├── button
524// │   │   ╰── [sort-indicator]
525// ┊   ┊
526// │   ╰── button
527// │       ╰── [sort-indicator]
528// │
529// ├── [rubberband]
530// ╰── [dndtarget]
531// ```
532//
533// `GtkTreeView` has a main CSS node with name `treeview` and style class `.view`.
534// It has a subnode with name `header`, which is the parent for all the column
535// header widgets' CSS nodes.
536//
537// Each column header consists of a `button`, which among other content, has a
538// child with name `sort-indicator`, which carries the `.ascending` or `.descending`
539// style classes when the column header should show a sort indicator. The CSS
540// is expected to provide a suitable image using the `-gtk-icon-source` property.
541//
542// For rubberband selection, a subnode with name `rubberband` is used.
543//
544// For the drop target location during DND, a subnode with name `dndtarget` is used.
545type TreeView struct {
546	Widget
547}
548
549var xTreeViewGLibType func() types.GType
550
551func TreeViewGLibType() types.GType {
552	return xTreeViewGLibType()
553}
554
555func TreeViewNewFromInternalPtr(ptr uintptr) *TreeView {
556	cls := &TreeView{}
557	cls.Ptr = ptr
558	return cls
559}
560
561var xNewTreeView func() uintptr
562
563// Creates a new `GtkTreeView` widget.
564func NewTreeView() *TreeView {
565	var cls *TreeView
566
567	cret := xNewTreeView()
568
569	if cret == 0 {
570		return nil
571	}
572	gobject.IncreaseRef(cret)
573	cls = &TreeView{}
574	cls.Ptr = cret
575	return cls
576}
577
578var xNewTreeViewWithModel func(uintptr) uintptr
579
580// Creates a new `GtkTreeView` widget with the model initialized to @model.
581func NewTreeViewWithModel(ModelVar TreeModel) *TreeView {
582	var cls *TreeView
583
584	cret := xNewTreeViewWithModel(ModelVar.GoPointer())
585
586	if cret == 0 {
587		return nil
588	}
589	gobject.IncreaseRef(cret)
590	cls = &TreeView{}
591	cls.Ptr = cret
592	return cls
593}
594
595var xTreeViewAppendColumn func(uintptr, uintptr) int
596
597// Appends @column to the list of columns. If @tree_view has “fixed_height”
598// mode enabled, then @column must have its “sizing” property set to be
599// GTK_TREE_VIEW_COLUMN_FIXED.
600func (x *TreeView) AppendColumn(ColumnVar *TreeViewColumn) int {
601
602	cret := xTreeViewAppendColumn(x.GoPointer(), ColumnVar.GoPointer())
603	return cret
604}
605
606var xTreeViewCollapseAll func(uintptr)
607
608// Recursively collapses all visible, expanded nodes in @tree_view.
609func (x *TreeView) CollapseAll() {
610
611	xTreeViewCollapseAll(x.GoPointer())
612
613}
614
615var xTreeViewCollapseRow func(uintptr, *TreePath) bool
616
617// Collapses a row (hides its child rows, if they exist).
618func (x *TreeView) CollapseRow(PathVar *TreePath) bool {
619
620	cret := xTreeViewCollapseRow(x.GoPointer(), PathVar)
621	return cret
622}
623
624var xTreeViewColumnsAutosize func(uintptr)
625
626// Resizes all columns to their optimal width. Only works after the
627// treeview has been realized.
628func (x *TreeView) ColumnsAutosize() {
629
630	xTreeViewColumnsAutosize(x.GoPointer())
631
632}
633
634var xTreeViewConvertBinWindowToTreeCoords func(uintptr, int, int, *int, *int)
635
636// Converts bin_window coordinates to coordinates for the
637// tree (the full scrollable area of the tree).
638func (x *TreeView) ConvertBinWindowToTreeCoords(BxVar int, ByVar int, TxVar *int, TyVar *int) {
639
640	xTreeViewConvertBinWindowToTreeCoords(x.GoPointer(), BxVar, ByVar, TxVar, TyVar)
641
642}
643
644var xTreeViewConvertBinWindowToWidgetCoords func(uintptr, int, int, *int, *int)
645
646// Converts bin_window coordinates to widget relative coordinates.
647func (x *TreeView) ConvertBinWindowToWidgetCoords(BxVar int, ByVar int, WxVar *int, WyVar *int) {
648
649	xTreeViewConvertBinWindowToWidgetCoords(x.GoPointer(), BxVar, ByVar, WxVar, WyVar)
650
651}
652
653var xTreeViewConvertTreeToBinWindowCoords func(uintptr, int, int, *int, *int)
654
655// Converts tree coordinates (coordinates in full scrollable area of the tree)
656// to bin_window coordinates.
657func (x *TreeView) ConvertTreeToBinWindowCoords(TxVar int, TyVar int, BxVar *int, ByVar *int) {
658
659	xTreeViewConvertTreeToBinWindowCoords(x.GoPointer(), TxVar, TyVar, BxVar, ByVar)
660
661}
662
663var xTreeViewConvertTreeToWidgetCoords func(uintptr, int, int, *int, *int)
664
665// Converts tree coordinates (coordinates in full scrollable area of the tree)
666// to widget coordinates.
667func (x *TreeView) ConvertTreeToWidgetCoords(TxVar int, TyVar int, WxVar *int, WyVar *int) {
668
669	xTreeViewConvertTreeToWidgetCoords(x.GoPointer(), TxVar, TyVar, WxVar, WyVar)
670
671}
672
673var xTreeViewConvertWidgetToBinWindowCoords func(uintptr, int, int, *int, *int)
674
675// Converts widget coordinates to coordinates for the bin_window.
676func (x *TreeView) ConvertWidgetToBinWindowCoords(WxVar int, WyVar int, BxVar *int, ByVar *int) {
677
678	xTreeViewConvertWidgetToBinWindowCoords(x.GoPointer(), WxVar, WyVar, BxVar, ByVar)
679
680}
681
682var xTreeViewConvertWidgetToTreeCoords func(uintptr, int, int, *int, *int)
683
684// Converts widget coordinates to coordinates for the
685// tree (the full scrollable area of the tree).
686func (x *TreeView) ConvertWidgetToTreeCoords(WxVar int, WyVar int, TxVar *int, TyVar *int) {
687
688	xTreeViewConvertWidgetToTreeCoords(x.GoPointer(), WxVar, WyVar, TxVar, TyVar)
689
690}
691
692var xTreeViewCreateRowDragIcon func(uintptr, *TreePath) uintptr
693
694// Creates a `cairo_surface_t` representation of the row at @path.
695// This image is used for a drag icon.
696func (x *TreeView) CreateRowDragIcon(PathVar *TreePath) *gdk.PaintableBase {
697	var cls *gdk.PaintableBase
698
699	cret := xTreeViewCreateRowDragIcon(x.GoPointer(), PathVar)
700
701	if cret == 0 {
702		return nil
703	}
704	cls = &gdk.PaintableBase{}
705	cls.Ptr = cret
706	return cls
707}
708
709var xTreeViewEnableModelDragDest func(uintptr, *gdk.ContentFormats, gdk.DragAction)
710
711// Turns @tree_view into a drop destination for automatic DND. Calling
712// this method sets `GtkTreeView`:reorderable to %FALSE.
713func (x *TreeView) EnableModelDragDest(FormatsVar *gdk.ContentFormats, ActionsVar gdk.DragAction) {
714
715	xTreeViewEnableModelDragDest(x.GoPointer(), FormatsVar, ActionsVar)
716
717}
718
719var xTreeViewEnableModelDragSource func(uintptr, gdk.ModifierType, *gdk.ContentFormats, gdk.DragAction)
720
721// Turns @tree_view into a drag source for automatic DND. Calling this
722// method sets `GtkTreeView`:reorderable to %FALSE.
723func (x *TreeView) EnableModelDragSource(StartButtonMaskVar gdk.ModifierType, FormatsVar *gdk.ContentFormats, ActionsVar gdk.DragAction) {
724
725	xTreeViewEnableModelDragSource(x.GoPointer(), StartButtonMaskVar, FormatsVar, ActionsVar)
726
727}
728
729var xTreeViewExpandAll func(uintptr)
730
731// Recursively expands all nodes in the @tree_view.
732func (x *TreeView) ExpandAll() {
733
734	xTreeViewExpandAll(x.GoPointer())
735
736}
737
738var xTreeViewExpandRow func(uintptr, *TreePath, bool) bool
739
740// Opens the row so its children are visible.
741func (x *TreeView) ExpandRow(PathVar *TreePath, OpenAllVar bool) bool {
742
743	cret := xTreeViewExpandRow(x.GoPointer(), PathVar, OpenAllVar)
744	return cret
745}
746
747var xTreeViewExpandToPath func(uintptr, *TreePath)
748
749// Expands the row at @path. This will also expand all parent rows of
750// @path as necessary.
751func (x *TreeView) ExpandToPath(PathVar *TreePath) {
752
753	xTreeViewExpandToPath(x.GoPointer(), PathVar)
754
755}
756
757var xTreeViewGetActivateOnSingleClick func(uintptr) bool
758
759// Gets the setting set by gtk_tree_view_set_activate_on_single_click().
760func (x *TreeView) GetActivateOnSingleClick() bool {
761
762	cret := xTreeViewGetActivateOnSingleClick(x.GoPointer())
763	return cret
764}
765
766var xTreeViewGetBackgroundArea func(uintptr, *TreePath, uintptr, *gdk.Rectangle)
767
768// Fills the bounding rectangle in bin_window coordinates for the cell at the
769// row specified by @path and the column specified by @column.  If @path is
770// %NULL, or points to a node not found in the tree, the @y and @height fields of
771// the rectangle will be filled with 0. If @column is %NULL, the @x and @width
772// fields will be filled with 0.  The returned rectangle is equivalent to the
773// @background_area passed to gtk_cell_renderer_render().  These background
774// areas tile to cover the entire bin window.  Contrast with the @cell_area,
775// returned by gtk_tree_view_get_cell_area(), which returns only the cell
776// itself, excluding surrounding borders and the tree expander area.
777func (x *TreeView) GetBackgroundArea(PathVar *TreePath, ColumnVar *TreeViewColumn, RectVar *gdk.Rectangle) {
778
779	xTreeViewGetBackgroundArea(x.GoPointer(), PathVar, ColumnVar.GoPointer(), RectVar)
780
781}
782
783var xTreeViewGetCellArea func(uintptr, *TreePath, uintptr, *gdk.Rectangle)
784
785// Fills the bounding rectangle in bin_window coordinates for the cell at the
786// row specified by @path and the column specified by @column.  If @path is
787// %NULL, or points to a path not currently displayed, the @y and @height fields
788// of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
789// fields will be filled with 0.  The sum of all cell rects does not cover the
790// entire tree; there are extra pixels in between rows, for example. The
791// returned rectangle is equivalent to the @cell_area passed to
792// gtk_cell_renderer_render().  This function is only valid if @tree_view is
793// realized.
794func (x *TreeView) GetCellArea(PathVar *TreePath, ColumnVar *TreeViewColumn, RectVar *gdk.Rectangle) {
795
796	xTreeViewGetCellArea(x.GoPointer(), PathVar, ColumnVar.GoPointer(), RectVar)
797
798}
799
800var xTreeViewGetColumn func(uintptr, int) uintptr
801
802// Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
803func (x *TreeView) GetColumn(NVar int) *TreeViewColumn {
804	var cls *TreeViewColumn
805
806	cret := xTreeViewGetColumn(x.GoPointer(), NVar)
807
808	if cret == 0 {
809		return nil
810	}
811	gobject.IncreaseRef(cret)
812	cls = &TreeViewColumn{}
813	cls.Ptr = cret
814	return cls
815}
816
817var xTreeViewGetColumns func(uintptr) *glib.List
818
819// Returns a `GList` of all the `GtkTreeViewColumn`s currently in @tree_view.
820// The returned list must be freed with g_list_free ().
821func (x *TreeView) GetColumns() *glib.List {
822
823	cret := xTreeViewGetColumns(x.GoPointer())
824	return cret
825}
826
827var xTreeViewGetCursor func(uintptr, **TreePath, **TreeViewColumn)
828
829// Fills in @path and @focus_column with the current path and focus column.  If
830// the cursor isn’t currently set, then *@path will be %NULL.  If no column
831// currently has focus, then *@focus_column will be %NULL.
832//
833// The returned `GtkTreePath` must be freed with gtk_tree_path_free() when
834// you are done with it.
835func (x *TreeView) GetCursor(PathVar **TreePath, FocusColumnVar **TreeViewColumn) {
836
837	xTreeViewGetCursor(x.GoPointer(), PathVar, FocusColumnVar)
838
839}
840
841var xTreeViewGetDestRowAtPos func(uintptr, int, int, **TreePath, *TreeViewDropPosition) bool
842
843// Determines the destination row for a given position.  @drag_x and
844// @drag_y are expected to be in widget coordinates.  This function is only
845// meaningful if @tree_view is realized.  Therefore this function will always
846// return %FALSE if @tree_view is not realized or does not have a model.
847func (x *TreeView) GetDestRowAtPos(DragXVar int, DragYVar int, PathVar **TreePath, PosVar *TreeViewDropPosition) bool {
848
849	cret := xTreeViewGetDestRowAtPos(x.GoPointer(), DragXVar, DragYVar, PathVar, PosVar)
850	return cret
851}
852
853var xTreeViewGetDragDestRow func(uintptr, **TreePath, *TreeViewDropPosition)
854
855// Gets information about the row that is highlighted for feedback.
856func (x *TreeView) GetDragDestRow(PathVar **TreePath, PosVar *TreeViewDropPosition) {
857
858	xTreeViewGetDragDestRow(x.GoPointer(), PathVar, PosVar)
859
860}
861
862var xTreeViewGetEnableSearch func(uintptr) bool
863
864// Returns whether or not the tree allows to start interactive searching
865// by typing in text.
866func (x *TreeView) GetEnableSearch() bool {
867
868	cret := xTreeViewGetEnableSearch(x.GoPointer())
869	return cret
870}
871
872var xTreeViewGetEnableTreeLines func(uintptr) bool
873
874// Returns whether or not tree lines are drawn in @tree_view.
875func (x *TreeView) GetEnableTreeLines() bool {
876
877	cret := xTreeViewGetEnableTreeLines(x.GoPointer())
878	return cret
879}
880
881var xTreeViewGetExpanderColumn func(uintptr) uintptr
882
883// Returns the column that is the current expander column,
884// or %NULL if none has been set.
885// This column has the expander arrow drawn next to it.
886func (x *TreeView) GetExpanderColumn() *TreeViewColumn {
887	var cls *TreeViewColumn
888
889	cret := xTreeViewGetExpanderColumn(x.GoPointer())
890
891	if cret == 0 {
892		return nil
893	}
894	gobject.IncreaseRef(cret)
895	cls = &TreeViewColumn{}
896	cls.Ptr = cret
897	return cls
898}
899
900var xTreeViewGetFixedHeightMode func(uintptr) bool
901
902// Returns whether fixed height mode is turned on for @tree_view.
903func (x *TreeView) GetFixedHeightMode() bool {
904
905	cret := xTreeViewGetFixedHeightMode(x.GoPointer())
906	return cret
907}
908
909var xTreeViewGetGridLines func(uintptr) TreeViewGridLines
910
911// Returns which grid lines are enabled in @tree_view.
912func (x *TreeView) GetGridLines() TreeViewGridLines {
913
914	cret := xTreeViewGetGridLines(x.GoPointer())
915	return cret
916}
917
918var xTreeViewGetHeadersClickable func(uintptr) bool
919
920// Returns whether all header columns are clickable.
921func (x *TreeView) GetHeadersClickable() bool {
922
923	cret := xTreeViewGetHeadersClickable(x.GoPointer())
924	return cret
925}
926
927var xTreeViewGetHeadersVisible func(uintptr) bool
928
929// Returns %TRUE if the headers on the @tree_view are visible.
930func (x *TreeView) GetHeadersVisible() bool {
931
932	cret := xTreeViewGetHeadersVisible(x.GoPointer())
933	return cret
934}
935
936var xTreeViewGetHoverExpand func(uintptr) bool
937
938// Returns whether hover expansion mode is turned on for @tree_view.
939func (x *TreeView) GetHoverExpand() bool {
940
941	cret := xTreeViewGetHoverExpand(x.GoPointer())
942	return cret
943}
944
945var xTreeViewGetHoverSelection func(uintptr) bool
946
947// Returns whether hover selection mode is turned on for @tree_view.
948func (x *TreeView) GetHoverSelection() bool {
949
950	cret := xTreeViewGetHoverSelection(x.GoPointer())
951	return cret
952}
953
954var xTreeViewGetLevelIndentation func(uintptr) int
955
956// Returns the amount, in pixels, of extra indentation for child levels
957// in @tree_view.
958func (x *TreeView) GetLevelIndentation() int {
959
960	cret := xTreeViewGetLevelIndentation(x.GoPointer())
961	return cret
962}
963
964var xTreeViewGetModel func(uintptr) uintptr
965
966// Returns the model the `GtkTreeView` is based on.  Returns %NULL if the
967// model is unset.
968func (x *TreeView) GetModel() *TreeModelBase {
969	var cls *TreeModelBase
970
971	cret := xTreeViewGetModel(x.GoPointer())
972
973	if cret == 0 {
974		return nil
975	}
976	gobject.IncreaseRef(cret)
977	cls = &TreeModelBase{}
978	cls.Ptr = cret
979	return cls
980}
981
982var xTreeViewGetNColumns func(uintptr) uint
983
984// Queries the number of columns in the given @tree_view.
985func (x *TreeView) GetNColumns() uint {
986
987	cret := xTreeViewGetNColumns(x.GoPointer())
988	return cret
989}
990
991var xTreeViewGetPathAtPos func(uintptr, int, int, **TreePath, **TreeViewColumn, *int, *int) bool
992
993// Finds the path at the point (@x, @y), relative to bin_window coordinates.
994// That is, @x and @y are relative to an events coordinates. Widget-relative
995// coordinates must be converted using
996// gtk_tree_view_convert_widget_to_bin_window_coords(). It is primarily for
997// things like popup menus. If @path is non-%NULL, then it will be filled
998// with the `GtkTreePath` at that point.  This path should be freed with
999// gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
1000// with the column at that point.  @cell_x and @cell_y return the coordinates
1001// relative to the cell background (i.e. the @background_area passed to
1002// gtk_cell_renderer_render()).  This function is only meaningful if
1003// @tree_view is realized.  Therefore this function will always return %FALSE
1004// if @tree_view is not realized or does not have a model.
1005//
1006// For converting widget coordinates (eg. the ones you get from
1007// GtkWidget::query-tooltip), please see
1008// gtk_tree_view_convert_widget_to_bin_window_coords().
1009func (x *TreeView) GetPathAtPos(XVar int, YVar int, PathVar **TreePath, ColumnVar **TreeViewColumn, CellXVar *int, CellYVar *int) bool {
1010
1011	cret := xTreeViewGetPathAtPos(x.GoPointer(), XVar, YVar, PathVar, ColumnVar, CellXVar, CellYVar)
1012	return cret
1013}
1014
1015var xTreeViewGetReorderable func(uintptr) bool
1016
1017// Retrieves whether the user can reorder the tree via drag-and-drop. See
1018// gtk_tree_view_set_reorderable().
1019func (x *TreeView) GetReorderable() bool {
1020
1021	cret := xTreeViewGetReorderable(x.GoPointer())
1022	return cret
1023}
1024
1025var xTreeViewGetRowSeparatorFunc func(uintptr) uintptr
1026
1027// Returns the current row separator function.
1028func (x *TreeView) GetRowSeparatorFunc() uintptr {
1029
1030	cret := xTreeViewGetRowSeparatorFunc(x.GoPointer())
1031	return cret
1032}
1033
1034var xTreeViewGetRubberBanding func(uintptr) bool
1035
1036// Returns whether rubber banding is turned on for @tree_view.  If the
1037// selection mode is %GTK_SELECTION_MULTIPLE, rubber banding will allow the
1038// user to select multiple rows by dragging the mouse.
1039func (x *TreeView) GetRubberBanding() bool {
1040
1041	cret := xTreeViewGetRubberBanding(x.GoPointer())
1042	return cret
1043}
1044
1045var xTreeViewGetSearchColumn func(uintptr) int
1046
1047// Gets the column searched on by the interactive search code.
1048func (x *TreeView) GetSearchColumn() int {
1049
1050	cret := xTreeViewGetSearchColumn(x.GoPointer())
1051	return cret
1052}
1053
1054var xTreeViewGetSearchEntry func(uintptr) uintptr
1055
1056// Returns the `GtkEntry` which is currently in use as interactive search
1057// entry for @tree_view.  In case the built-in entry is being used, %NULL
1058// will be returned.
1059func (x *TreeView) GetSearchEntry() *EditableBase {
1060	var cls *EditableBase
1061
1062	cret := xTreeViewGetSearchEntry(x.GoPointer())
1063
1064	if cret == 0 {
1065		return nil
1066	}
1067	gobject.IncreaseRef(cret)
1068	cls = &EditableBase{}
1069	cls.Ptr = cret
1070	return cls
1071}
1072
1073var xTreeViewGetSearchEqualFunc func(uintptr) uintptr
1074
1075// Returns the compare function currently in use.
1076func (x *TreeView) GetSearchEqualFunc() uintptr {
1077
1078	cret := xTreeViewGetSearchEqualFunc(x.GoPointer())
1079	return cret
1080}
1081
1082var xTreeViewGetSelection func(uintptr) uintptr
1083
1084// Gets the `GtkTreeSelection` associated with @tree_view.
1085func (x *TreeView) GetSelection() *TreeSelection {
1086	var cls *TreeSelection
1087
1088	cret := xTreeViewGetSelection(x.GoPointer())
1089
1090	if cret == 0 {
1091		return nil
1092	}
1093	gobject.IncreaseRef(cret)
1094	cls = &TreeSelection{}
1095	cls.Ptr = cret
1096	return cls
1097}
1098
1099var xTreeViewGetShowExpanders func(uintptr) bool
1100
1101// Returns whether or not expanders are drawn in @tree_view.
1102func (x *TreeView) GetShowExpanders() bool {
1103
1104	cret := xTreeViewGetShowExpanders(x.GoPointer())
1105	return cret
1106}
1107
1108var xTreeViewGetTooltipColumn func(uintptr) int
1109
1110// Returns the column of @tree_view’s model which is being used for
1111// displaying tooltips on @tree_view’s rows.
1112func (x *TreeView) GetTooltipColumn() int {
1113
1114	cret := xTreeViewGetTooltipColumn(x.GoPointer())
1115	return cret
1116}
1117
1118var xTreeViewGetTooltipContext func(uintptr, int, int, bool, **TreeModel, **TreePath, *TreeIter) bool
1119
1120// This function is supposed to be used in a ::query-tooltip
1121// signal handler for `GtkTreeView`. The @x, @y and @keyboard_tip values
1122// which are received in the signal handler, should be passed to this
1123// function without modification.
1124//
1125// The return value indicates whether there is a tree view row at the given
1126// coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
1127// tooltips the row returned will be the cursor row. When %TRUE, then any of
1128// @model, @path and @iter which have been provided will be set to point to
1129// that row and the corresponding model. @x and @y will always be converted
1130// to be relative to @tree_view’s bin_window if @keyboard_tooltip is %FALSE.
1131func (x *TreeView) GetTooltipContext(XVar int, YVar int, KeyboardTipVar bool, ModelVar **TreeModel, PathVar **TreePath, IterVar *TreeIter) bool {
1132
1133	cret := xTreeViewGetTooltipContext(x.GoPointer(), XVar, YVar, KeyboardTipVar, ModelVar, PathVar, IterVar)
1134	return cret
1135}
1136
1137var xTreeViewGetVisibleRange func(uintptr, **TreePath, **TreePath) bool
1138
1139// Sets @start_path and @end_path to be the first and last visible path.
1140// Note that there may be invisible paths in between.
1141//
1142// The paths should be freed with gtk_tree_path_free() after use.
1143func (x *TreeView) GetVisibleRange(StartPathVar **TreePath, EndPathVar **TreePath) bool {
1144
1145	cret := xTreeViewGetVisibleRange(x.GoPointer(), StartPathVar, EndPathVar)
1146	return cret
1147}
1148
1149var xTreeViewGetVisibleRect func(uintptr, *gdk.Rectangle)
1150
1151// Fills @visible_rect with the currently-visible region of the
1152// buffer, in tree coordinates. Convert to bin_window coordinates with
1153// gtk_tree_view_convert_tree_to_bin_window_coords().
1154// Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
1155// scrollable area of the tree.
1156func (x *TreeView) GetVisibleRect(VisibleRectVar *gdk.Rectangle) {
1157
1158	xTreeViewGetVisibleRect(x.GoPointer(), VisibleRectVar)
1159
1160}
1161
1162var xTreeViewInsertColumn func(uintptr, uintptr, int) int
1163
1164// This inserts the @column into the @tree_view at @position.  If @position is
1165// -1, then the column is inserted at the end. If @tree_view has
1166// “fixed_height” mode enabled, then @column must have its “sizing” property
1167// set to be GTK_TREE_VIEW_COLUMN_FIXED.
1168func (x *TreeView) InsertColumn(ColumnVar *TreeViewColumn, PositionVar int) int {
1169
1170	cret := xTreeViewInsertColumn(x.GoPointer(), ColumnVar.GoPointer(), PositionVar)
1171	return cret
1172}
1173
1174var xTreeViewInsertColumnWithAttributes func(uintptr, int, string, uintptr, ...interface{}) int
1175
1176// Creates a new `GtkTreeViewColumn` and inserts it into the @tree_view at
1177// @position.  If @position is -1, then the newly created column is inserted at
1178// the end.  The column is initialized with the attributes given. If @tree_view
1179// has “fixed_height” mode enabled, then the new column will have its sizing
1180// property set to be GTK_TREE_VIEW_COLUMN_FIXED.
1181func (x *TreeView) InsertColumnWithAttributes(PositionVar int, TitleVar string, CellVar *CellRenderer, varArgs ...interface{}) int {
1182
1183	cret := xTreeViewInsertColumnWithAttributes(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), varArgs...)
1184	return cret
1185}
1186
1187var xTreeViewInsertColumnWithDataFunc func(uintptr, int, string, uintptr, uintptr, uintptr, uintptr) int
1188
1189// Convenience function that inserts a new column into the `GtkTreeView`
1190// with the given cell renderer and a `GtkTreeCellDataFunc` to set cell renderer
1191// attributes (normally using data from the model). See also
1192// gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
1193// If @tree_view has “fixed_height” mode enabled, then the new column will have its
1194// “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
1195func (x *TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar *CellRenderer, FuncVar *TreeCellDataFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) int {
1196
1197	var FuncVarRef uintptr
1198	if FuncVar != nil {
1199		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1200		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1201			FuncVarRef = cbRefPtr
1202		} else {
1203			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 *TreeIter, arg4 uintptr) {
1204				cbFn := *FuncVar
1205				cbFn(arg0, arg1, arg2, arg3, arg4)
1206			}
1207			FuncVarRef = purego.NewCallback(fcb)
1208			glib.SaveCallbackWithClosure(FuncVarPtr, FuncVarRef, FuncVar)
1209		}
1210	}
1211
1212	var DnotifyVarRef uintptr
1213	if DnotifyVar != nil {
1214		DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
1215		if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
1216			DnotifyVarRef = cbRefPtr
1217		} else {
1218			fcb := func(arg0 uintptr) {
1219				cbFn := *DnotifyVar
1220				cbFn(arg0)
1221			}
1222			DnotifyVarRef = purego.NewCallback(fcb)
1223			glib.SaveCallbackWithClosure(DnotifyVarPtr, DnotifyVarRef, DnotifyVar)
1224		}
1225	}
1226
1227	cret := xTreeViewInsertColumnWithDataFunc(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), FuncVarRef, DataVar, DnotifyVarRef)
1228	return cret
1229}
1230
1231var xTreeViewIsBlankAtPos func(uintptr, int, int, **TreePath, **TreeViewColumn, *int, *int) bool
1232
1233// Determine whether the point (@x, @y) in @tree_view is blank, that is no
1234// cell content nor an expander arrow is drawn at the location. If so, the
1235// location can be considered as the background. You might wish to take
1236// special action on clicks on the background, such as clearing a current
1237// selection, having a custom context menu or starting rubber banding.
1238//
1239// The @x and @y coordinate that are provided must be relative to bin_window
1240// coordinates.  Widget-relative coordinates must be converted using
1241// gtk_tree_view_convert_widget_to_bin_window_coords().
1242//
1243// For converting widget coordinates (eg. the ones you get from
1244// GtkWidget::query-tooltip), please see
1245// gtk_tree_view_convert_widget_to_bin_window_coords().
1246//
1247// The @path, @column, @cell_x and @cell_y arguments will be filled in
1248// likewise as for gtk_tree_view_get_path_at_pos().  Please see
1249// gtk_tree_view_get_path_at_pos() for more information.
1250func (x *TreeView) IsBlankAtPos(XVar int, YVar int, PathVar **TreePath, ColumnVar **TreeViewColumn, CellXVar *int, CellYVar *int) bool {
1251
1252	cret := xTreeViewIsBlankAtPos(x.GoPointer(), XVar, YVar, PathVar, ColumnVar, CellXVar, CellYVar)
1253	return cret
1254}
1255
1256var xTreeViewIsRubberBandingActive func(uintptr) bool
1257
1258// Returns whether a rubber banding operation is currently being done
1259// in @tree_view.
1260func (x *TreeView) IsRubberBandingActive() bool {
1261
1262	cret := xTreeViewIsRubberBandingActive(x.GoPointer())
1263	return cret
1264}
1265
1266var xTreeViewMapExpandedRows func(uintptr, uintptr, uintptr)
1267
1268// Calls @func on all expanded rows.
1269func (x *TreeView) MapExpandedRows(FuncVar *TreeViewMappingFunc, DataVar uintptr) {
1270
1271	var FuncVarRef uintptr
1272	if FuncVar != nil {
1273		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1274		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1275			FuncVarRef = cbRefPtr
1276		} else {
1277			fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
1278				cbFn := *FuncVar
1279				cbFn(arg0, arg1, arg2)
1280			}
1281			FuncVarRef = purego.NewCallback(fcb)
1282			glib.SaveCallbackWithClosure(FuncVarPtr, FuncVarRef, FuncVar)
1283		}
1284	}
1285
1286	xTreeViewMapExpandedRows(x.GoPointer(), FuncVarRef, DataVar)
1287
1288}
1289
1290var xTreeViewMoveColumnAfter func(uintptr, uintptr, uintptr)
1291
1292// Moves @column to be after to @base_column.  If @base_column is %NULL, then
1293// @column is placed in the first position.
1294func (x *TreeView) MoveColumnAfter(ColumnVar *TreeViewColumn, BaseColumnVar *TreeViewColumn) {
1295
1296	xTreeViewMoveColumnAfter(x.GoPointer(), ColumnVar.GoPointer(), BaseColumnVar.GoPointer())
1297
1298}
1299
1300var xTreeViewRemoveColumn func(uintptr, uintptr) int
1301
1302// Removes @column from @tree_view.
1303func (x *TreeView) RemoveColumn(ColumnVar *TreeViewColumn) int {
1304
1305	cret := xTreeViewRemoveColumn(x.GoPointer(), ColumnVar.GoPointer())
1306	return cret
1307}
1308
1309var xTreeViewRowActivated func(uintptr, *TreePath, uintptr)
1310
1311// Activates the cell determined by @path and @column.
1312func (x *TreeView) RowActivated(PathVar *TreePath, ColumnVar *TreeViewColumn) {
1313
1314	xTreeViewRowActivated(x.GoPointer(), PathVar, ColumnVar.GoPointer())
1315
1316}
1317
1318var xTreeViewRowExpanded func(uintptr, *TreePath) bool
1319
1320// Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
1321func (x *TreeView) RowExpanded(PathVar *TreePath) bool {
1322
1323	cret := xTreeViewRowExpanded(x.GoPointer(), PathVar)
1324	return cret
1325}
1326
1327var xTreeViewScrollToCell func(uintptr, *TreePath, uintptr, bool, float32, float32)
1328
1329// Moves the alignments of @tree_view to the position specified by @column and
1330// @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
1331// if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
1332// or @path need to be non-%NULL.  @row_align determines where the row is
1333// placed, and @col_align determines where @column is placed.  Both are expected
1334// to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
1335// right/bottom alignment, 0.5 means center.
1336//
1337// If @use_align is %FALSE, then the alignment arguments are ignored, and the
1338// tree does the minimum amount of work to scroll the cell onto the screen.
1339// This means that the cell will be scrolled to the edge closest to its current
1340// position.  If the cell is currently visible on the screen, nothing is done.
1341//
1342// This function only works if the model is set, and @path is a valid row on the
1343// model.  If the model changes before the @tree_view is realized, the centered
1344// path will be modified to reflect this change.
1345func (x *TreeView) ScrollToCell(PathVar *TreePath, ColumnVar *TreeViewColumn, UseAlignVar bool, RowAlignVar float32, ColAlignVar float32) {
1346
1347	xTreeViewScrollToCell(x.GoPointer(), PathVar, ColumnVar.GoPointer(), UseAlignVar, RowAlignVar, ColAlignVar)
1348
1349}
1350
1351var xTreeViewScrollToPoint func(uintptr, int, int)
1352
1353// Scrolls the tree view such that the top-left corner of the visible
1354// area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
1355// in tree coordinates.  The @tree_view must be realized before
1356// this function is called.  If it isn't, you probably want to be
1357// using gtk_tree_view_scroll_to_cell().
1358//
1359// If either @tree_x or @tree_y are -1, then that direction isn’t scrolled.
1360func (x *TreeView) ScrollToPoint(TreeXVar int, TreeYVar int) {
1361
1362	xTreeViewScrollToPoint(x.GoPointer(), TreeXVar, TreeYVar)
1363
1364}
1365
1366var xTreeViewSetActivateOnSingleClick func(uintptr, bool)
1367
1368// Cause the `GtkTreeView`::row-activated signal to be emitted
1369// on a single click instead of a double click.
1370func (x *TreeView) SetActivateOnSingleClick(SingleVar bool) {
1371
1372	xTreeViewSetActivateOnSingleClick(x.GoPointer(), SingleVar)
1373
1374}
1375
1376var xTreeViewSetColumnDragFunction func(uintptr, uintptr, uintptr, uintptr)
1377
1378// Sets a user function for determining where a column may be dropped when
1379// dragged.  This function is called on every column pair in turn at the
1380// beginning of a column drag to determine where a drop can take place.  The
1381// arguments passed to @func are: the @tree_view, the `GtkTreeViewColumn` being
1382// dragged, the two `GtkTreeViewColumn`s determining the drop spot, and
1383// @user_data.  If either of the `GtkTreeViewColumn` arguments for the drop spot
1384// are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
1385// @tree_view reverts to the default behavior of allowing all columns to be
1386// dropped everywhere.
1387func (x *TreeView) SetColumnDragFunction(FuncVar *TreeViewColumnDropFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
1388
1389	var FuncVarRef uintptr
1390	if FuncVar != nil {
1391		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1392		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1393			FuncVarRef = cbRefPtr
1394		} else {
1395			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr, arg4 uintptr) bool {
1396				cbFn := *FuncVar
1397				return cbFn(arg0, arg1, arg2, arg3, arg4)
1398			}
1399			FuncVarRef = purego.NewCallback(fcb)
1400			glib.SaveCallbackWithClosure(FuncVarPtr, FuncVarRef, FuncVar)
1401		}
1402	}
1403
1404	var DestroyVarRef uintptr
1405	if DestroyVar != nil {
1406		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
1407		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
1408			DestroyVarRef = cbRefPtr
1409		} else {
1410			fcb := func(arg0 uintptr) {
1411				cbFn := *DestroyVar
1412				cbFn(arg0)
1413			}
1414			DestroyVarRef = purego.NewCallback(fcb)
1415			glib.SaveCallbackWithClosure(DestroyVarPtr, DestroyVarRef, DestroyVar)
1416		}
1417	}
1418
1419	xTreeViewSetColumnDragFunction(x.GoPointer(), FuncVarRef, UserDataVar, DestroyVarRef)
1420
1421}
1422
1423var xTreeViewSetCursor func(uintptr, *TreePath, uintptr, bool)
1424
1425// Sets the current keyboard focus to be at @path, and selects it.  This is
1426// useful when you want to focus the user’s attention on a particular row.  If
1427// @focus_column is not %NULL, then focus is given to the column specified by
1428// it. Additionally, if @focus_column is specified, and @start_editing is
1429// %TRUE, then editing should be started in the specified cell.
1430// This function is often followed by @gtk_widget_grab_focus (@tree_view)
1431// in order to give keyboard focus to the widget.  Please note that editing
1432// can only happen when the widget is realized.
1433//
1434// If @path is invalid for @model, the current cursor (if any) will be unset
1435// and the function will return without failing.
1436func (x *TreeView) SetCursor(PathVar *TreePath, FocusColumnVar *TreeViewColumn, StartEditingVar bool) {
1437
1438	xTreeViewSetCursor(x.GoPointer(), PathVar, FocusColumnVar.GoPointer(), StartEditingVar)
1439
1440}
1441
1442var xTreeViewSetCursorOnCell func(uintptr, *TreePath, uintptr, uintptr, bool)
1443
1444// Sets the current keyboard focus to be at @path, and selects it.  This is
1445// useful when you want to focus the user’s attention on a particular row.  If
1446// @focus_column is not %NULL, then focus is given to the column specified by
1447// it. If @focus_column and @focus_cell are not %NULL, and @focus_column
1448// contains 2 or more editable or activatable cells, then focus is given to
1449// the cell specified by @focus_cell. Additionally, if @focus_column is
1450// specified, and @start_editing is %TRUE, then editing should be started in
1451// the specified cell.  This function is often followed by
1452// @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
1453// widget.  Please note that editing can only happen when the widget is
1454// realized.
1455//
1456// If @path is invalid for @model, the current cursor (if any) will be unset
1457// and the function will return without failing.
1458func (x *TreeView) SetCursorOnCell(PathVar *TreePath, FocusColumnVar *TreeViewColumn, FocusCellVar *CellRenderer, StartEditingVar bool) {
1459
1460	xTreeViewSetCursorOnCell(x.GoPointer(), PathVar, FocusColumnVar.GoPointer(), FocusCellVar.GoPointer(), StartEditingVar)
1461
1462}
1463
1464var xTreeViewSetDragDestRow func(uintptr, *TreePath, TreeViewDropPosition)
1465
1466// Sets the row that is highlighted for feedback.
1467// If @path is %NULL, an existing highlight is removed.
1468func (x *TreeView) SetDragDestRow(PathVar *TreePath, PosVar TreeViewDropPosition) {
1469
1470	xTreeViewSetDragDestRow(x.GoPointer(), PathVar, PosVar)
1471
1472}
1473
1474var xTreeViewSetEnableSearch func(uintptr, bool)
1475
1476// If @enable_search is set, then the user can type in text to search through
1477// the tree interactively (this is sometimes called "typeahead find").
1478//
1479// Note that even if this is %FALSE, the user can still initiate a search
1480// using the “start-interactive-search” key binding.
1481func (x *TreeView) SetEnableSearch(EnableSearchVar bool) {
1482
1483	xTreeViewSetEnableSearch(x.GoPointer(), EnableSearchVar)
1484
1485}
1486
1487var xTreeViewSetEnableTreeLines func(uintptr, bool)
1488
1489// Sets whether to draw lines interconnecting the expanders in @tree_view.
1490// This does not have any visible effects for lists.
1491func (x *TreeView) SetEnableTreeLines(EnabledVar bool) {
1492
1493	xTreeViewSetEnableTreeLines(x.GoPointer(), EnabledVar)
1494
1495}
1496
1497var xTreeViewSetExpanderColumn func(uintptr, uintptr)
1498
1499// Sets the column to draw the expander arrow at. It must be in @tree_view.
1500// If @column is %NULL, then the expander arrow is always at the first
1501// visible column.
1502//
1503// If you do not want expander arrow to appear in your tree, set the
1504// expander column to a hidden column.
1505func (x *TreeView) SetExpanderColumn(ColumnVar *TreeViewColumn) {
1506
1507	xTreeViewSetExpanderColumn(x.GoPointer(), ColumnVar.GoPointer())
1508
1509}
1510
1511var xTreeViewSetFixedHeightMode func(uintptr, bool)
1512
1513// Enables or disables the fixed height mode of @tree_view.
1514// Fixed height mode speeds up `GtkTreeView` by assuming that all
1515// rows have the same height.
1516// Only enable this option if all rows are the same height and all
1517// columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
1518func (x *TreeView) SetFixedHeightMode(EnableVar bool) {
1519
1520	xTreeViewSetFixedHeightMode(x.GoPointer(), EnableVar)
1521
1522}
1523
1524var xTreeViewSetGridLines func(uintptr, TreeViewGridLines)
1525
1526// Sets which grid lines to draw in @tree_view.
1527func (x *TreeView) SetGridLines(GridLinesVar TreeViewGridLines) {
1528
1529	xTreeViewSetGridLines(x.GoPointer(), GridLinesVar)
1530
1531}
1532
1533var xTreeViewSetHeadersClickable func(uintptr, bool)
1534
1535// Allow the column title buttons to be clicked.
1536func (x *TreeView) SetHeadersClickable(SettingVar bool) {
1537
1538	xTreeViewSetHeadersClickable(x.GoPointer(), SettingVar)
1539
1540}
1541
1542var xTreeViewSetHeadersVisible func(uintptr, bool)
1543
1544// Sets the visibility state of the headers.
1545func (x *TreeView) SetHeadersVisible(HeadersVisibleVar bool) {
1546
1547	xTreeViewSetHeadersVisible(x.GoPointer(), HeadersVisibleVar)
1548
1549}
1550
1551var xTreeViewSetHoverExpand func(uintptr, bool)
1552
1553// Enables or disables the hover expansion mode of @tree_view.
1554// Hover expansion makes rows expand or collapse if the pointer
1555// moves over them.
1556func (x *TreeView) SetHoverExpand(ExpandVar bool) {
1557
1558	xTreeViewSetHoverExpand(x.GoPointer(), ExpandVar)
1559
1560}
1561
1562var xTreeViewSetHoverSelection func(uintptr, bool)
1563
1564// Enables or disables the hover selection mode of @tree_view.
1565// Hover selection makes the selected row follow the pointer.
1566// Currently, this works only for the selection modes
1567// %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1568func (x *TreeView) SetHoverSelection(HoverVar bool) {
1569
1570	xTreeViewSetHoverSelection(x.GoPointer(), HoverVar)
1571
1572}
1573
1574var xTreeViewSetLevelIndentation func(uintptr, int)
1575
1576// Sets the amount of extra indentation for child levels to use in @tree_view
1577// in addition to the default indentation.  The value should be specified in
1578// pixels, a value of 0 disables this feature and in this case only the default
1579// indentation will be used.
1580// This does not have any visible effects for lists.
1581func (x *TreeView) SetLevelIndentation(IndentationVar int) {
1582
1583	xTreeViewSetLevelIndentation(x.GoPointer(), IndentationVar)
1584
1585}
1586
1587var xTreeViewSetModel func(uintptr, uintptr)
1588
1589// Sets the model for a `GtkTreeView`.  If the @tree_view already has a model
1590// set, it will remove it before setting the new model.  If @model is %NULL,
1591// then it will unset the old model.
1592func (x *TreeView) SetModel(ModelVar TreeModel) {
1593
1594	xTreeViewSetModel(x.GoPointer(), ModelVar.GoPointer())
1595
1596}
1597
1598var xTreeViewSetReorderable func(uintptr, bool)
1599
1600// This function is a convenience function to allow you to reorder
1601// models that support the `GtkTreeDragSourceIface` and the
1602// `GtkTreeDragDestIface`.  Both `GtkTreeStore` and `GtkListStore` support
1603// these.  If @reorderable is %TRUE, then the user can reorder the
1604// model by dragging and dropping rows. The developer can listen to
1605// these changes by connecting to the model’s `GtkTreeModel::row-inserted`
1606// and `GtkTreeModel::row-deleted` signals. The reordering is implemented
1607// by setting up the tree view as a drag source and destination.
1608// Therefore, drag and drop can not be used in a reorderable view for any
1609// other purpose.
1610//
1611// This function does not give you any degree of control over the order -- any
1612// reordering is allowed.  If more control is needed, you should probably
1613// handle drag and drop manually.
1614func (x *TreeView) SetReorderable(ReorderableVar bool) {
1615
1616	xTreeViewSetReorderable(x.GoPointer(), ReorderableVar)
1617
1618}
1619
1620var xTreeViewSetRowSeparatorFunc func(uintptr, uintptr, uintptr, uintptr)
1621
1622// Sets the row separator function, which is used to determine
1623// whether a row should be drawn as a separator. If the row separator
1624// function is %NULL, no separators are drawn. This is the default value.
1625func (x *TreeView) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
1626
1627	var FuncVarRef uintptr
1628	if FuncVar != nil {
1629		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1630		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1631			FuncVarRef = cbRefPtr
1632		} else {
1633			fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
1634				cbFn := *FuncVar
1635				return cbFn(arg0, arg1, arg2)
1636			}
1637			FuncVarRef = purego.NewCallback(fcb)
1638			glib.SaveCallbackWithClosure(FuncVarPtr, FuncVarRef, FuncVar)
1639		}
1640	}
1641
1642	var DestroyVarRef uintptr
1643	if DestroyVar != nil {
1644		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
1645		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
1646			DestroyVarRef = cbRefPtr
1647		} else {
1648			fcb := func(arg0 uintptr) {
1649				cbFn := *DestroyVar
1650				cbFn(arg0)
1651			}
1652			DestroyVarRef = purego.NewCallback(fcb)
1653			glib.SaveCallbackWithClosure(DestroyVarPtr, DestroyVarRef, DestroyVar)
1654		}
1655	}
1656
1657	xTreeViewSetRowSeparatorFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)
1658
1659}
1660
1661var xTreeViewSetRubberBanding func(uintptr, bool)
1662
1663// Enables or disables rubber banding in @tree_view.  If the selection mode
1664// is %GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
1665// multiple rows by dragging the mouse.
1666func (x *TreeView) SetRubberBanding(EnableVar bool) {
1667
1668	xTreeViewSetRubberBanding(x.GoPointer(), EnableVar)
1669
1670}
1671
1672var xTreeViewSetSearchColumn func(uintptr, int)
1673
1674// Sets @column as the column where the interactive search code should
1675// search in for the current model.
1676//
1677// If the search column is set, users can use the “start-interactive-search”
1678// key binding to bring up search popup. The enable-search property controls
1679// whether simply typing text will also start an interactive search.
1680//
1681// Note that @column refers to a column of the current model. The search
1682// column is reset to -1 when the model is changed.
1683func (x *TreeView) SetSearchColumn(ColumnVar int) {
1684
1685	xTreeViewSetSearchColumn(x.GoPointer(), ColumnVar)
1686
1687}
1688
1689var xTreeViewSetSearchEntry func(uintptr, uintptr)
1690
1691// Sets the entry which the interactive search code will use for this
1692// @tree_view.  This is useful when you want to provide a search entry
1693// in our interface at all time at a fixed position.  Passing %NULL for
1694// @entry will make the interactive search code use the built-in popup
1695// entry again.
1696func (x *TreeView) SetSearchEntry(EntryVar Editable) {
1697
1698	xTreeViewSetSearchEntry(x.GoPointer(), EntryVar.GoPointer())
1699
1700}
1701
1702var xTreeViewSetSearchEqualFunc func(uintptr, uintptr, uintptr, uintptr)
1703
1704// Sets the compare function for the interactive search capabilities; note
1705// that somewhat like strcmp() returning 0 for equality
1706// `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
1707func (x *TreeView) SetSearchEqualFunc(SearchEqualFuncVar *TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar *glib.DestroyNotify) {
1708
1709	var SearchEqualFuncVarRef uintptr
1710	if SearchEqualFuncVar != nil {
1711		SearchEqualFuncVarPtr := uintptr(unsafe.Pointer(SearchEqualFuncVar))
1712		if cbRefPtr, ok := glib.GetCallback(SearchEqualFuncVarPtr); ok {
1713			SearchEqualFuncVarRef = cbRefPtr
1714		} else {
1715			fcb := func(arg0 uintptr, arg1 int, arg2 uintptr, arg3 *TreeIter, arg4 uintptr) bool {
1716				cbFn := *SearchEqualFuncVar
1717				return cbFn(arg0, arg1, core.GoString(arg2), arg3, arg4)
1718			}
1719			SearchEqualFuncVarRef = purego.NewCallback(fcb)
1720			glib.SaveCallbackWithClosure(SearchEqualFuncVarPtr, SearchEqualFuncVarRef, SearchEqualFuncVar)
1721		}
1722	}
1723
1724	var SearchDestroyVarRef uintptr
1725	if SearchDestroyVar != nil {
1726		SearchDestroyVarPtr := uintptr(unsafe.Pointer(SearchDestroyVar))
1727		if cbRefPtr, ok := glib.GetCallback(SearchDestroyVarPtr); ok {
1728			SearchDestroyVarRef = cbRefPtr
1729		} else {
1730			fcb := func(arg0 uintptr) {
1731				cbFn := *SearchDestroyVar
1732				cbFn(arg0)
1733			}
1734			SearchDestroyVarRef = purego.NewCallback(fcb)
1735			glib.SaveCallbackWithClosure(SearchDestroyVarPtr, SearchDestroyVarRef, SearchDestroyVar)
1736		}
1737	}
1738
1739	xTreeViewSetSearchEqualFunc(x.GoPointer(), SearchEqualFuncVarRef, SearchUserDataVar, SearchDestroyVarRef)
1740
1741}
1742
1743var xTreeViewSetShowExpanders func(uintptr, bool)
1744
1745// Sets whether to draw and enable expanders and indent child rows in
1746// @tree_view.  When disabled there will be no expanders visible in trees
1747// and there will be no way to expand and collapse rows by default.  Also
1748// note that hiding the expanders will disable the default indentation.  You
1749// can set a custom indentation in this case using
1750// gtk_tree_view_set_level_indentation().
1751// This does not have any visible effects for lists.
1752func (x *TreeView) SetShowExpanders(EnabledVar bool) {
1753
1754	xTreeViewSetShowExpanders(x.GoPointer(), EnabledVar)
1755
1756}
1757
1758var xTreeViewSetTooltipCell func(uintptr, uintptr, *TreePath, uintptr, uintptr)
1759
1760// Sets the tip area of @tooltip to the area @path, @column and @cell have
1761// in common.  For example if @path is %NULL and @column is set, the tip
1762// area will be set to the full area covered by @column.  See also
1763// gtk_tooltip_set_tip_area().
1764//
1765// Note that if @path is not specified and @cell is set and part of a column
1766// containing the expander, the tooltip might not show and hide at the correct
1767// position.  In such cases @path must be set to the current node under the
1768// mouse cursor for this function to operate correctly.
1769//
1770// See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
1771func (x *TreeView) SetTooltipCell(TooltipVar *Tooltip, PathVar *TreePath, ColumnVar *TreeViewColumn, CellVar *CellRenderer) {
1772
1773	xTreeViewSetTooltipCell(x.GoPointer(), TooltipVar.GoPointer(), PathVar, ColumnVar.GoPointer(), CellVar.GoPointer())
1774
1775}
1776
1777var xTreeViewSetTooltipColumn func(uintptr, int)
1778
1779// If you only plan to have simple (text-only) tooltips on full rows, you
1780// can use this function to have `GtkTreeView` handle these automatically
1781// for you. @column should be set to the column in @tree_view’s model
1782// containing the tooltip texts, or -1 to disable this feature.
1783//
1784// When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
1785// @tree_view will connect a `GtkWidget::query-tooltip` signal handler.
1786//
1787// Note that the signal handler sets the text with gtk_tooltip_set_markup(),
1788// so &, <, etc have to be escaped in the text.
1789func (x *TreeView) SetTooltipColumn(ColumnVar int) {
1790
1791	xTreeViewSetTooltipColumn(x.GoPointer(), ColumnVar)
1792
1793}
1794
1795var xTreeViewSetTooltipRow func(uintptr, uintptr, *TreePath)
1796
1797// Sets the tip area of @tooltip to be the area covered by the row at @path.
1798// See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
1799// See also gtk_tooltip_set_tip_area().
1800func (x *TreeView) SetTooltipRow(TooltipVar *Tooltip, PathVar *TreePath) {
1801
1802	xTreeViewSetTooltipRow(x.GoPointer(), TooltipVar.GoPointer(), PathVar)
1803
1804}
1805
1806var xTreeViewUnsetRowsDragDest func(uintptr)
1807
1808// Undoes the effect of
1809// gtk_tree_view_enable_model_drag_dest(). Calling this method sets
1810// `GtkTreeView`:reorderable to %FALSE.
1811func (x *TreeView) UnsetRowsDragDest() {
1812
1813	xTreeViewUnsetRowsDragDest(x.GoPointer())
1814
1815}
1816
1817var xTreeViewUnsetRowsDragSource func(uintptr)
1818
1819// Undoes the effect of
1820// gtk_tree_view_enable_model_drag_source(). Calling this method sets
1821// `GtkTreeView`:reorderable to %FALSE.
1822func (x *TreeView) UnsetRowsDragSource() {
1823
1824	xTreeViewUnsetRowsDragSource(x.GoPointer())
1825
1826}
1827
1828func (c *TreeView) GoPointer() uintptr {
1829	if c == nil {
1830		return 0
1831	}
1832	return c.Ptr
1833}
1834
1835func (c *TreeView) SetGoPointer(ptr uintptr) {
1836	c.Ptr = ptr
1837}
1838
1839// SetPropertyActivateOnSingleClick sets the "activate-on-single-click" property.
1840// The activate-on-single-click property specifies whether the "row-activated" signal
1841// will be emitted after a single click.
1842func (x *TreeView) SetPropertyActivateOnSingleClick(value bool) {
1843	var v gobject.Value
1844	v.Init(gobject.TypeBooleanVal)
1845	v.SetBoolean(value)
1846	x.SetProperty("activate-on-single-click", &v)
1847}
1848
1849// GetPropertyActivateOnSingleClick gets the "activate-on-single-click" property.
1850// The activate-on-single-click property specifies whether the "row-activated" signal
1851// will be emitted after a single click.
1852func (x *TreeView) GetPropertyActivateOnSingleClick() bool {
1853	var v gobject.Value
1854	x.GetProperty("activate-on-single-click", &v)
1855	return v.GetBoolean()
1856}
1857
1858// SetPropertyEnableSearch sets the "enable-search" property.
1859func (x *TreeView) SetPropertyEnableSearch(value bool) {
1860	var v gobject.Value
1861	v.Init(gobject.TypeBooleanVal)
1862	v.SetBoolean(value)
1863	x.SetProperty("enable-search", &v)
1864}
1865
1866// GetPropertyEnableSearch gets the "enable-search" property.
1867func (x *TreeView) GetPropertyEnableSearch() bool {
1868	var v gobject.Value
1869	x.GetProperty("enable-search", &v)
1870	return v.GetBoolean()
1871}
1872
1873// SetPropertyEnableTreeLines sets the "enable-tree-lines" property.
1874func (x *TreeView) SetPropertyEnableTreeLines(value bool) {
1875	var v gobject.Value
1876	v.Init(gobject.TypeBooleanVal)
1877	v.SetBoolean(value)
1878	x.SetProperty("enable-tree-lines", &v)
1879}
1880
1881// GetPropertyEnableTreeLines gets the "enable-tree-lines" property.
1882func (x *TreeView) GetPropertyEnableTreeLines() bool {
1883	var v gobject.Value
1884	x.GetProperty("enable-tree-lines", &v)
1885	return v.GetBoolean()
1886}
1887
1888// SetPropertyFixedHeightMode sets the "fixed-height-mode" property.
1889// Setting the ::fixed-height-mode property to %TRUE speeds up
1890// `GtkTreeView` by assuming that all rows have the same height.
1891// Only enable this option if all rows are the same height.
1892// Please see gtk_tree_view_set_fixed_height_mode() for more
1893// information on this option.
1894func (x *TreeView) SetPropertyFixedHeightMode(value bool) {
1895	var v gobject.Value
1896	v.Init(gobject.TypeBooleanVal)
1897	v.SetBoolean(value)
1898	x.SetProperty("fixed-height-mode", &v)
1899}
1900
1901// GetPropertyFixedHeightMode gets the "fixed-height-mode" property.
1902// Setting the ::fixed-height-mode property to %TRUE speeds up
1903// `GtkTreeView` by assuming that all rows have the same height.
1904// Only enable this option if all rows are the same height.
1905// Please see gtk_tree_view_set_fixed_height_mode() for more
1906// information on this option.
1907func (x *TreeView) GetPropertyFixedHeightMode() bool {
1908	var v gobject.Value
1909	x.GetProperty("fixed-height-mode", &v)
1910	return v.GetBoolean()
1911}
1912
1913// SetPropertyHeadersClickable sets the "headers-clickable" property.
1914func (x *TreeView) SetPropertyHeadersClickable(value bool) {
1915	var v gobject.Value
1916	v.Init(gobject.TypeBooleanVal)
1917	v.SetBoolean(value)
1918	x.SetProperty("headers-clickable", &v)
1919}
1920
1921// GetPropertyHeadersClickable gets the "headers-clickable" property.
1922func (x *TreeView) GetPropertyHeadersClickable() bool {
1923	var v gobject.Value
1924	x.GetProperty("headers-clickable", &v)
1925	return v.GetBoolean()
1926}
1927
1928// SetPropertyHeadersVisible sets the "headers-visible" property.
1929func (x *TreeView) SetPropertyHeadersVisible(value bool) {
1930	var v gobject.Value
1931	v.Init(gobject.TypeBooleanVal)
1932	v.SetBoolean(value)
1933	x.SetProperty("headers-visible", &v)
1934}
1935
1936// GetPropertyHeadersVisible gets the "headers-visible" property.
1937func (x *TreeView) GetPropertyHeadersVisible() bool {
1938	var v gobject.Value
1939	x.GetProperty("headers-visible", &v)
1940	return v.GetBoolean()
1941}
1942
1943// SetPropertyHoverExpand sets the "hover-expand" property.
1944// Enables or disables the hover expansion mode of @tree_view.
1945// Hover expansion makes rows expand or collapse if the pointer moves
1946// over them.
1947//
1948// This mode is primarily intended for treeviews in popups, e.g.
1949// in `GtkComboBox` or `GtkEntryCompletion`.
1950func (x *TreeView) SetPropertyHoverExpand(value bool) {
1951	var v gobject.Value
1952	v.Init(gobject.TypeBooleanVal)
1953	v.SetBoolean(value)
1954	x.SetProperty("hover-expand", &v)
1955}
1956
1957// GetPropertyHoverExpand gets the "hover-expand" property.
1958// Enables or disables the hover expansion mode of @tree_view.
1959// Hover expansion makes rows expand or collapse if the pointer moves
1960// over them.
1961//
1962// This mode is primarily intended for treeviews in popups, e.g.
1963// in `GtkComboBox` or `GtkEntryCompletion`.
1964func (x *TreeView) GetPropertyHoverExpand() bool {
1965	var v gobject.Value
1966	x.GetProperty("hover-expand", &v)
1967	return v.GetBoolean()
1968}
1969
1970// SetPropertyHoverSelection sets the "hover-selection" property.
1971// Enables or disables the hover selection mode of @tree_view.
1972// Hover selection makes the selected row follow the pointer.
1973// Currently, this works only for the selection modes
1974// %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1975//
1976// This mode is primarily intended for treeviews in popups, e.g.
1977// in `GtkComboBox` or `GtkEntryCompletion`.
1978func (x *TreeView) SetPropertyHoverSelection(value bool) {
1979	var v gobject.Value
1980	v.Init(gobject.TypeBooleanVal)
1981	v.SetBoolean(value)
1982	x.SetProperty("hover-selection", &v)
1983}
1984
1985// GetPropertyHoverSelection gets the "hover-selection" property.
1986// Enables or disables the hover selection mode of @tree_view.
1987// Hover selection makes the selected row follow the pointer.
1988// Currently, this works only for the selection modes
1989// %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1990//
1991// This mode is primarily intended for treeviews in popups, e.g.
1992// in `GtkComboBox` or `GtkEntryCompletion`.
1993func (x *TreeView) GetPropertyHoverSelection() bool {
1994	var v gobject.Value
1995	x.GetProperty("hover-selection", &v)
1996	return v.GetBoolean()
1997}
1998
1999// SetPropertyLevelIndentation sets the "level-indentation" property.
2000// Extra indentation for each level.
2001func (x *TreeView) SetPropertyLevelIndentation(value int) {
2002	var v gobject.Value
2003	v.Init(gobject.TypeIntVal)
2004	v.SetInt(value)
2005	x.SetProperty("level-indentation", &v)
2006}
2007
2008// GetPropertyLevelIndentation gets the "level-indentation" property.
2009// Extra indentation for each level.
2010func (x *TreeView) GetPropertyLevelIndentation() int {
2011	var v gobject.Value
2012	x.GetProperty("level-indentation", &v)
2013	return v.GetInt()
2014}
2015
2016// SetPropertyReorderable sets the "reorderable" property.
2017func (x *TreeView) SetPropertyReorderable(value bool) {
2018	var v gobject.Value
2019	v.Init(gobject.TypeBooleanVal)
2020	v.SetBoolean(value)
2021	x.SetProperty("reorderable", &v)
2022}
2023
2024// GetPropertyReorderable gets the "reorderable" property.
2025func (x *TreeView) GetPropertyReorderable() bool {
2026	var v gobject.Value
2027	x.GetProperty("reorderable", &v)
2028	return v.GetBoolean()
2029}
2030
2031// SetPropertyRubberBanding sets the "rubber-banding" property.
2032func (x *TreeView) SetPropertyRubberBanding(value bool) {
2033	var v gobject.Value
2034	v.Init(gobject.TypeBooleanVal)
2035	v.SetBoolean(value)
2036	x.SetProperty("rubber-banding", &v)
2037}
2038
2039// GetPropertyRubberBanding gets the "rubber-banding" property.
2040func (x *TreeView) GetPropertyRubberBanding() bool {
2041	var v gobject.Value
2042	x.GetProperty("rubber-banding", &v)
2043	return v.GetBoolean()
2044}
2045
2046// SetPropertySearchColumn sets the "search-column" property.
2047func (x *TreeView) SetPropertySearchColumn(value int) {
2048	var v gobject.Value
2049	v.Init(gobject.TypeIntVal)
2050	v.SetInt(value)
2051	x.SetProperty("search-column", &v)
2052}
2053
2054// GetPropertySearchColumn gets the "search-column" property.
2055func (x *TreeView) GetPropertySearchColumn() int {
2056	var v gobject.Value
2057	x.GetProperty("search-column", &v)
2058	return v.GetInt()
2059}
2060
2061// SetPropertyShowExpanders sets the "show-expanders" property.
2062// %TRUE if the view has expanders.
2063func (x *TreeView) SetPropertyShowExpanders(value bool) {
2064	var v gobject.Value
2065	v.Init(gobject.TypeBooleanVal)
2066	v.SetBoolean(value)
2067	x.SetProperty("show-expanders", &v)
2068}
2069
2070// GetPropertyShowExpanders gets the "show-expanders" property.
2071// %TRUE if the view has expanders.
2072func (x *TreeView) GetPropertyShowExpanders() bool {
2073	var v gobject.Value
2074	x.GetProperty("show-expanders", &v)
2075	return v.GetBoolean()
2076}
2077
2078// SetPropertyTooltipColumn sets the "tooltip-column" property.
2079func (x *TreeView) SetPropertyTooltipColumn(value int) {
2080	var v gobject.Value
2081	v.Init(gobject.TypeIntVal)
2082	v.SetInt(value)
2083	x.SetProperty("tooltip-column", &v)
2084}
2085
2086// GetPropertyTooltipColumn gets the "tooltip-column" property.
2087func (x *TreeView) GetPropertyTooltipColumn() int {
2088	var v gobject.Value
2089	x.GetProperty("tooltip-column", &v)
2090	return v.GetInt()
2091}
2092
2093// The number of columns of the treeview has changed.
2094func (x *TreeView) ConnectColumnsChanged(cb *func(TreeView)) uint {
2095	cbPtr := uintptr(unsafe.Pointer(cb))
2096	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2097		handlerID := gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
2098		glib.SaveHandlerMapping(handlerID, cbPtr)
2099		return handlerID
2100	}
2101
2102	fcb := func(clsPtr uintptr) {
2103		fa := TreeView{}
2104		fa.Ptr = clsPtr
2105		cbFn := *cb
2106
2107		cbFn(fa)
2108
2109	}
2110	cbRefPtr := purego.NewCallback(fcb)
2111	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2112	handlerID := gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
2113	glib.SaveHandlerMapping(handlerID, cbPtr)
2114	return handlerID
2115}
2116
2117// The position of the cursor (focused cell) has changed.
2118func (x *TreeView) ConnectCursorChanged(cb *func(TreeView)) uint {
2119	cbPtr := uintptr(unsafe.Pointer(cb))
2120	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2121		handlerID := gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
2122		glib.SaveHandlerMapping(handlerID, cbPtr)
2123		return handlerID
2124	}
2125
2126	fcb := func(clsPtr uintptr) {
2127		fa := TreeView{}
2128		fa.Ptr = clsPtr
2129		cbFn := *cb
2130
2131		cbFn(fa)
2132
2133	}
2134	cbRefPtr := purego.NewCallback(fcb)
2135	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2136	handlerID := gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
2137	glib.SaveHandlerMapping(handlerID, cbPtr)
2138	return handlerID
2139}
2140
2141func (x *TreeView) ConnectExpandCollapseCursorRow(cb *func(TreeView, bool, bool, bool) bool) uint {
2142	cbPtr := uintptr(unsafe.Pointer(cb))
2143	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2144		handlerID := gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
2145		glib.SaveHandlerMapping(handlerID, cbPtr)
2146		return handlerID
2147	}
2148
2149	fcb := func(clsPtr uintptr, ObjectVarp bool, P0Varp bool, P1Varp bool) bool {
2150		fa := TreeView{}
2151		fa.Ptr = clsPtr
2152		cbFn := *cb
2153
2154		return cbFn(fa, ObjectVarp, P0Varp, P1Varp)
2155
2156	}
2157	cbRefPtr := purego.NewCallback(fcb)
2158	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2159	handlerID := gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
2160	glib.SaveHandlerMapping(handlerID, cbPtr)
2161	return handlerID
2162}
2163
2164// The `GtkTreeView`::move-cursor signal is a [keybinding
2165// signal][class@Gtk.SignalAction] which gets emitted when the user
2166// presses one of the cursor keys.
2167//
2168// Applications should not connect to it, but may emit it with
2169// g_signal_emit_by_name() if they need to control the cursor
2170// programmatically. In contrast to gtk_tree_view_set_cursor() and
2171// gtk_tree_view_set_cursor_on_cell() when moving horizontally
2172// `GtkTreeView`::move-cursor does not reset the current selection.
2173func (x *TreeView) ConnectMoveCursor(cb *func(TreeView, MovementStep, int, bool, bool) bool) uint {
2174	cbPtr := uintptr(unsafe.Pointer(cb))
2175	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2176		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
2177		glib.SaveHandlerMapping(handlerID, cbPtr)
2178		return handlerID
2179	}
2180
2181	fcb := func(clsPtr uintptr, StepVarp MovementStep, DirectionVarp int, ExtendVarp bool, ModifyVarp bool) bool {
2182		fa := TreeView{}
2183		fa.Ptr = clsPtr
2184		cbFn := *cb
2185
2186		return cbFn(fa, StepVarp, DirectionVarp, ExtendVarp, ModifyVarp)
2187
2188	}
2189	cbRefPtr := purego.NewCallback(fcb)
2190	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2191	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
2192	glib.SaveHandlerMapping(handlerID, cbPtr)
2193	return handlerID
2194}
2195
2196// The "row-activated" signal is emitted when the method
2197// [method@Gtk.TreeView.row_activated] is called.
2198//
2199// This signal is emitted when the user double-clicks a treeview row with the
2200// [property@Gtk.TreeView:activate-on-single-click] property set to %FALSE,
2201// or when the user single-clicks a row when that property set to %TRUE.
2202//
2203// This signal is also emitted when a non-editable row is selected and one
2204// of the keys: <kbd>Space</kbd>, <kbd>Shift</kbd>+<kbd>Space</kbd>,
2205// <kbd>Return</kbd> or <kbd>Enter</kbd> is pressed.
2206//
2207// For selection handling refer to the
2208// [tree widget conceptual overview](section-tree-widget.html)
2209// as well as `GtkTreeSelection`.
2210func (x *TreeView) ConnectRowActivated(cb *func(TreeView, uintptr, uintptr)) uint {
2211	cbPtr := uintptr(unsafe.Pointer(cb))
2212	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2213		handlerID := gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
2214		glib.SaveHandlerMapping(handlerID, cbPtr)
2215		return handlerID
2216	}
2217
2218	fcb := func(clsPtr uintptr, PathVarp uintptr, ColumnVarp uintptr) {
2219		fa := TreeView{}
2220		fa.Ptr = clsPtr
2221		cbFn := *cb
2222
2223		cbFn(fa, PathVarp, ColumnVarp)
2224
2225	}
2226	cbRefPtr := purego.NewCallback(fcb)
2227	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2228	handlerID := gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
2229	glib.SaveHandlerMapping(handlerID, cbPtr)
2230	return handlerID
2231}
2232
2233// The given row has been collapsed (child nodes are hidden).
2234func (x *TreeView) ConnectRowCollapsed(cb *func(TreeView, uintptr, uintptr)) uint {
2235	cbPtr := uintptr(unsafe.Pointer(cb))
2236	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2237		handlerID := gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
2238		glib.SaveHandlerMapping(handlerID, cbPtr)
2239		return handlerID
2240	}
2241
2242	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) {
2243		fa := TreeView{}
2244		fa.Ptr = clsPtr
2245		cbFn := *cb
2246
2247		cbFn(fa, IterVarp, PathVarp)
2248
2249	}
2250	cbRefPtr := purego.NewCallback(fcb)
2251	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2252	handlerID := gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
2253	glib.SaveHandlerMapping(handlerID, cbPtr)
2254	return handlerID
2255}
2256
2257// The given row has been expanded (child nodes are shown).
2258func (x *TreeView) ConnectRowExpanded(cb *func(TreeView, uintptr, uintptr)) uint {
2259	cbPtr := uintptr(unsafe.Pointer(cb))
2260	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2261		handlerID := gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
2262		glib.SaveHandlerMapping(handlerID, cbPtr)
2263		return handlerID
2264	}
2265
2266	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) {
2267		fa := TreeView{}
2268		fa.Ptr = clsPtr
2269		cbFn := *cb
2270
2271		cbFn(fa, IterVarp, PathVarp)
2272
2273	}
2274	cbRefPtr := purego.NewCallback(fcb)
2275	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2276	handlerID := gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
2277	glib.SaveHandlerMapping(handlerID, cbPtr)
2278	return handlerID
2279}
2280
2281func (x *TreeView) ConnectSelectAll(cb *func(TreeView) bool) uint {
2282	cbPtr := uintptr(unsafe.Pointer(cb))
2283	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2284		handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
2285		glib.SaveHandlerMapping(handlerID, cbPtr)
2286		return handlerID
2287	}
2288
2289	fcb := func(clsPtr uintptr) bool {
2290		fa := TreeView{}
2291		fa.Ptr = clsPtr
2292		cbFn := *cb
2293
2294		return cbFn(fa)
2295
2296	}
2297	cbRefPtr := purego.NewCallback(fcb)
2298	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2299	handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
2300	glib.SaveHandlerMapping(handlerID, cbPtr)
2301	return handlerID
2302}
2303
2304func (x *TreeView) ConnectSelectCursorParent(cb *func(TreeView) bool) uint {
2305	cbPtr := uintptr(unsafe.Pointer(cb))
2306	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2307		handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
2308		glib.SaveHandlerMapping(handlerID, cbPtr)
2309		return handlerID
2310	}
2311
2312	fcb := func(clsPtr uintptr) bool {
2313		fa := TreeView{}
2314		fa.Ptr = clsPtr
2315		cbFn := *cb
2316
2317		return cbFn(fa)
2318
2319	}
2320	cbRefPtr := purego.NewCallback(fcb)
2321	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2322	handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
2323	glib.SaveHandlerMapping(handlerID, cbPtr)
2324	return handlerID
2325}
2326
2327func (x *TreeView) ConnectSelectCursorRow(cb *func(TreeView, bool) bool) uint {
2328	cbPtr := uintptr(unsafe.Pointer(cb))
2329	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2330		handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
2331		glib.SaveHandlerMapping(handlerID, cbPtr)
2332		return handlerID
2333	}
2334
2335	fcb := func(clsPtr uintptr, ObjectVarp bool) bool {
2336		fa := TreeView{}
2337		fa.Ptr = clsPtr
2338		cbFn := *cb
2339
2340		return cbFn(fa, ObjectVarp)
2341
2342	}
2343	cbRefPtr := purego.NewCallback(fcb)
2344	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2345	handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
2346	glib.SaveHandlerMapping(handlerID, cbPtr)
2347	return handlerID
2348}
2349
2350func (x *TreeView) ConnectStartInteractiveSearch(cb *func(TreeView) bool) uint {
2351	cbPtr := uintptr(unsafe.Pointer(cb))
2352	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2353		handlerID := gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
2354		glib.SaveHandlerMapping(handlerID, cbPtr)
2355		return handlerID
2356	}
2357
2358	fcb := func(clsPtr uintptr) bool {
2359		fa := TreeView{}
2360		fa.Ptr = clsPtr
2361		cbFn := *cb
2362
2363		return cbFn(fa)
2364
2365	}
2366	cbRefPtr := purego.NewCallback(fcb)
2367	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2368	handlerID := gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
2369	glib.SaveHandlerMapping(handlerID, cbPtr)
2370	return handlerID
2371}
2372
2373// The given row is about to be collapsed (hide its children nodes). Use this
2374// signal if you need to control the collapsibility of individual rows.
2375func (x *TreeView) ConnectTestCollapseRow(cb *func(TreeView, uintptr, uintptr) bool) uint {
2376	cbPtr := uintptr(unsafe.Pointer(cb))
2377	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2378		handlerID := gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
2379		glib.SaveHandlerMapping(handlerID, cbPtr)
2380		return handlerID
2381	}
2382
2383	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) bool {
2384		fa := TreeView{}
2385		fa.Ptr = clsPtr
2386		cbFn := *cb
2387
2388		return cbFn(fa, IterVarp, PathVarp)
2389
2390	}
2391	cbRefPtr := purego.NewCallback(fcb)
2392	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2393	handlerID := gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
2394	glib.SaveHandlerMapping(handlerID, cbPtr)
2395	return handlerID
2396}
2397
2398// The given row is about to be expanded (show its children nodes). Use this
2399// signal if you need to control the expandability of individual rows.
2400func (x *TreeView) ConnectTestExpandRow(cb *func(TreeView, uintptr, uintptr) bool) uint {
2401	cbPtr := uintptr(unsafe.Pointer(cb))
2402	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2403		handlerID := gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
2404		glib.SaveHandlerMapping(handlerID, cbPtr)
2405		return handlerID
2406	}
2407
2408	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) bool {
2409		fa := TreeView{}
2410		fa.Ptr = clsPtr
2411		cbFn := *cb
2412
2413		return cbFn(fa, IterVarp, PathVarp)
2414
2415	}
2416	cbRefPtr := purego.NewCallback(fcb)
2417	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2418	handlerID := gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
2419	glib.SaveHandlerMapping(handlerID, cbPtr)
2420	return handlerID
2421}
2422
2423func (x *TreeView) ConnectToggleCursorRow(cb *func(TreeView) bool) uint {
2424	cbPtr := uintptr(unsafe.Pointer(cb))
2425	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2426		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
2427		glib.SaveHandlerMapping(handlerID, cbPtr)
2428		return handlerID
2429	}
2430
2431	fcb := func(clsPtr uintptr) bool {
2432		fa := TreeView{}
2433		fa.Ptr = clsPtr
2434		cbFn := *cb
2435
2436		return cbFn(fa)
2437
2438	}
2439	cbRefPtr := purego.NewCallback(fcb)
2440	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2441	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
2442	glib.SaveHandlerMapping(handlerID, cbPtr)
2443	return handlerID
2444}
2445
2446func (x *TreeView) ConnectUnselectAll(cb *func(TreeView) bool) uint {
2447	cbPtr := uintptr(unsafe.Pointer(cb))
2448	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
2449		handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
2450		glib.SaveHandlerMapping(handlerID, cbPtr)
2451		return handlerID
2452	}
2453
2454	fcb := func(clsPtr uintptr) bool {
2455		fa := TreeView{}
2456		fa.Ptr = clsPtr
2457		cbFn := *cb
2458
2459		return cbFn(fa)
2460
2461	}
2462	cbRefPtr := purego.NewCallback(fcb)
2463	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
2464	handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
2465	glib.SaveHandlerMapping(handlerID, cbPtr)
2466	return handlerID
2467}
2468
2469// Requests the user's screen reader to announce the given message.
2470//
2471// This kind of notification is useful for messages that
2472// either have only a visual representation or that are not
2473// exposed visually at all, e.g. a notification about a
2474// successful operation.
2475//
2476// Also, by using this API, you can ensure that the message
2477// does not interrupts the user's current screen reader output.
2478func (x *TreeView) Announce(MessageVar string, PriorityVar AccessibleAnnouncementPriority) {
2479
2480	XGtkAccessibleAnnounce(x.GoPointer(), MessageVar, PriorityVar)
2481
2482}
2483
2484// Retrieves the accessible parent for an accessible object.
2485//
2486// This function returns `NULL` for top level widgets.
2487func (x *TreeView) GetAccessibleParent() *AccessibleBase {
2488	var cls *AccessibleBase
2489
2490	cret := XGtkAccessibleGetAccessibleParent(x.GoPointer())
2491
2492	if cret == 0 {
2493		return nil
2494	}
2495	cls = &AccessibleBase{}
2496	cls.Ptr = cret
2497	return cls
2498}
2499
2500// Retrieves the accessible role of an accessible object.
2501func (x *TreeView) GetAccessibleRole() AccessibleRole {
2502
2503	cret := XGtkAccessibleGetAccessibleRole(x.GoPointer())
2504	return cret
2505}
2506
2507// Retrieves the implementation for the given accessible object.
2508func (x *TreeView) GetAtContext() *ATContext {
2509	var cls *ATContext
2510
2511	cret := XGtkAccessibleGetAtContext(x.GoPointer())
2512
2513	if cret == 0 {
2514		return nil
2515	}
2516	cls = &ATContext{}
2517	cls.Ptr = cret
2518	return cls
2519}
2520
2521// Queries the coordinates and dimensions of this accessible
2522//
2523// This functionality can be overridden by `GtkAccessible`
2524// implementations, e.g. to get the bounds from an ignored
2525// child widget.
2526func (x *TreeView) GetBounds(XVar *int, YVar *int, WidthVar *int, HeightVar *int) bool {
2527
2528	cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
2529	return cret
2530}
2531
2532// Retrieves the first accessible child of an accessible object.
2533func (x *TreeView) GetFirstAccessibleChild() *AccessibleBase {
2534	var cls *AccessibleBase
2535
2536	cret := XGtkAccessibleGetFirstAccessibleChild(x.GoPointer())
2537
2538	if cret == 0 {
2539		return nil
2540	}
2541	cls = &AccessibleBase{}
2542	cls.Ptr = cret
2543	return cls
2544}
2545
2546// Retrieves the next accessible sibling of an accessible object
2547func (x *TreeView) GetNextAccessibleSibling() *AccessibleBase {
2548	var cls *AccessibleBase
2549
2550	cret := XGtkAccessibleGetNextAccessibleSibling(x.GoPointer())
2551
2552	if cret == 0 {
2553		return nil
2554	}
2555	cls = &AccessibleBase{}
2556	cls.Ptr = cret
2557	return cls
2558}
2559
2560// Queries a platform state, such as focus.
2561//
2562// This functionality can be overridden by `GtkAccessible`
2563// implementations, e.g. to get platform state from an ignored
2564// child widget, as is the case for `GtkText` wrappers.
2565func (x *TreeView) GetPlatformState(StateVar AccessiblePlatformState) bool {
2566
2567	cret := XGtkAccessibleGetPlatformState(x.GoPointer(), StateVar)
2568	return cret
2569}
2570
2571// Resets the accessible property to its default value.
2572func (x *TreeView) ResetProperty(PropertyVar AccessibleProperty) {
2573
2574	XGtkAccessibleResetProperty(x.GoPointer(), PropertyVar)
2575
2576}
2577
2578// Resets the accessible relation to its default value.
2579func (x *TreeView) ResetRelation(RelationVar AccessibleRelation) {
2580
2581	XGtkAccessibleResetRelation(x.GoPointer(), RelationVar)
2582
2583}
2584
2585// Resets the accessible state to its default value.
2586func (x *TreeView) ResetState(StateVar AccessibleState) {
2587
2588	XGtkAccessibleResetState(x.GoPointer(), StateVar)
2589
2590}
2591
2592// Sets the parent and sibling of an accessible object.
2593//
2594// This function is meant to be used by accessible implementations that are
2595// not part of the widget hierarchy, and but act as a logical bridge between
2596// widgets. For instance, if a widget creates an object that holds metadata
2597// for each child, and you want that object to implement the `GtkAccessible`
2598// interface, you will use this function to ensure that the parent of each
2599// child widget is the metadata object, and the parent of each metadata
2600// object is the container widget.
2601func (x *TreeView) SetAccessibleParent(ParentVar Accessible, NextSiblingVar Accessible) {
2602
2603	XGtkAccessibleSetAccessibleParent(x.GoPointer(), ParentVar.GoPointer(), NextSiblingVar.GoPointer())
2604
2605}
2606
2607// Updates the next accessible sibling.
2608//
2609// That might be useful when a new child of a custom accessible
2610// is created, and it needs to be linked to a previous child.
2611func (x *TreeView) UpdateNextAccessibleSibling(NewSiblingVar Accessible) {
2612
2613	XGtkAccessibleUpdateNextAccessibleSibling(x.GoPointer(), NewSiblingVar.GoPointer())
2614
2615}
2616
2617// Informs ATs that the platform state has changed.
2618//
2619// This function should be used by `GtkAccessible` implementations that
2620// have a platform state but are not widgets. Widgets handle platform
2621// states automatically.
2622func (x *TreeView) UpdatePlatformState(StateVar AccessiblePlatformState) {
2623
2624	XGtkAccessibleUpdatePlatformState(x.GoPointer(), StateVar)
2625
2626}
2627
2628// Updates a list of accessible properties.
2629//
2630// See the [enum@Gtk.AccessibleProperty] documentation for the
2631// value types of accessible properties.
2632//
2633// This function should be called by `GtkWidget` types whenever
2634// an accessible property change must be communicated to assistive
2635// technologies.
2636//
2637// Example:
2638// ```c
2639// value = gtk_adjustment_get_value (adjustment);
2640// gtk_accessible_update_property (GTK_ACCESSIBLE (spin_button),
2641//
2642//	GTK_ACCESSIBLE_PROPERTY_VALUE_NOW, value,
2643//	-1);
2644//
2645// ```
2646func (x *TreeView) UpdateProperty(FirstPropertyVar AccessibleProperty, varArgs ...interface{}) {
2647
2648	XGtkAccessibleUpdateProperty(x.GoPointer(), FirstPropertyVar, varArgs...)
2649
2650}
2651
2652// Updates an array of accessible properties.
2653//
2654// This function should be called by `GtkWidget` types whenever an accessible
2655// property change must be communicated to assistive technologies.
2656//
2657// This function is meant to be used by language bindings.
2658func (x *TreeView) UpdatePropertyValue(NPropertiesVar int, PropertiesVar []AccessibleProperty, ValuesVar []gobject.Value) {
2659
2660	XGtkAccessibleUpdatePropertyValue(x.GoPointer(), NPropertiesVar, PropertiesVar, ValuesVar)
2661
2662}
2663
2664// Updates a list of accessible relations.
2665//
2666// This function should be called by `GtkWidget` types whenever an accessible
2667// relation change must be communicated to assistive technologies.
2668//
2669// If the [enum@Gtk.AccessibleRelation] requires a list of references,
2670// you should pass each reference individually, followed by `NULL`, e.g.
2671//
2672// ```c
2673// gtk_accessible_update_relation (accessible,
2674//
2675//	GTK_ACCESSIBLE_RELATION_CONTROLS,
2676//	  ref1, NULL,
2677//	GTK_ACCESSIBLE_RELATION_LABELLED_BY,
2678//	  ref1, ref2, ref3, NULL,
2679//	-1);
2680//
2681// ```
2682func (x *TreeView) UpdateRelation(FirstRelationVar AccessibleRelation, varArgs ...interface{}) {
2683
2684	XGtkAccessibleUpdateRelation(x.GoPointer(), FirstRelationVar, varArgs...)
2685
2686}
2687
2688// Updates an array of accessible relations.
2689//
2690// This function should be called by `GtkWidget` types whenever an accessible
2691// relation change must be communicated to assistive technologies.
2692//
2693// This function is meant to be used by language bindings.
2694func (x *TreeView) UpdateRelationValue(NRelationsVar int, RelationsVar []AccessibleRelation, ValuesVar []gobject.Value) {
2695
2696	XGtkAccessibleUpdateRelationValue(x.GoPointer(), NRelationsVar, RelationsVar, ValuesVar)
2697
2698}
2699
2700// Updates a list of accessible states.
2701//
2702// See the [enum@Gtk.AccessibleState] documentation for the
2703// value types of accessible states.
2704//
2705// This function should be called by `GtkWidget` types whenever
2706// an accessible state change must be communicated to assistive
2707// technologies.
2708//
2709// Example:
2710//
2711// ```c
2712// value = GTK_ACCESSIBLE_TRISTATE_MIXED;
2713// gtk_accessible_update_state (GTK_ACCESSIBLE (check_button),
2714//
2715//	GTK_ACCESSIBLE_STATE_CHECKED, value,
2716//	-1);
2717//
2718// ```
2719func (x *TreeView) UpdateState(FirstStateVar AccessibleState, varArgs ...interface{}) {
2720
2721	XGtkAccessibleUpdateState(x.GoPointer(), FirstStateVar, varArgs...)
2722
2723}
2724
2725// Updates an array of accessible states.
2726//
2727// This function should be called by `GtkWidget` types whenever an accessible
2728// state change must be communicated to assistive technologies.
2729//
2730// This function is meant to be used by language bindings.
2731func (x *TreeView) UpdateStateValue(NStatesVar int, StatesVar []AccessibleState, ValuesVar []gobject.Value) {
2732
2733	XGtkAccessibleUpdateStateValue(x.GoPointer(), NStatesVar, StatesVar, ValuesVar)
2734
2735}
2736
2737// Gets the ID of the @buildable object.
2738//
2739// `GtkBuilder` sets the name based on the ID attribute
2740// of the `<object>` tag used to construct the @buildable.
2741func (x *TreeView) GetBuildableId() string {
2742
2743	cret := XGtkBuildableGetBuildableId(x.GoPointer())
2744	return cret
2745}
2746
2747// Returns the size of a non-scrolling border around the
2748// outside of the scrollable.
2749//
2750// An example for this would be treeview headers. GTK can use
2751// this information to display overlaid graphics, like the
2752// overshoot indication, at the right position.
2753func (x *TreeView) GetBorder(BorderVar *Border) bool {
2754
2755	cret := XGtkScrollableGetBorder(x.GoPointer(), BorderVar)
2756	return cret
2757}
2758
2759// Retrieves the `GtkAdjustment` used for horizontal scrolling.
2760func (x *TreeView) GetHadjustment() *Adjustment {
2761	var cls *Adjustment
2762
2763	cret := XGtkScrollableGetHadjustment(x.GoPointer())
2764
2765	if cret == 0 {
2766		return nil
2767	}
2768	gobject.IncreaseRef(cret)
2769	cls = &Adjustment{}
2770	cls.Ptr = cret
2771	return cls
2772}
2773
2774// Gets the horizontal `GtkScrollablePolicy`.
2775func (x *TreeView) GetHscrollPolicy() ScrollablePolicy {
2776
2777	cret := XGtkScrollableGetHscrollPolicy(x.GoPointer())
2778	return cret
2779}
2780
2781// Retrieves the `GtkAdjustment` used for vertical scrolling.
2782func (x *TreeView) GetVadjustment() *Adjustment {
2783	var cls *Adjustment
2784
2785	cret := XGtkScrollableGetVadjustment(x.GoPointer())
2786
2787	if cret == 0 {
2788		return nil
2789	}
2790	gobject.IncreaseRef(cret)
2791	cls = &Adjustment{}
2792	cls.Ptr = cret
2793	return cls
2794}
2795
2796// Gets the vertical `GtkScrollablePolicy`.
2797func (x *TreeView) GetVscrollPolicy() ScrollablePolicy {
2798
2799	cret := XGtkScrollableGetVscrollPolicy(x.GoPointer())
2800	return cret
2801}
2802
2803// Sets the horizontal adjustment of the `GtkScrollable`.
2804func (x *TreeView) SetHadjustment(HadjustmentVar *Adjustment) {
2805
2806	XGtkScrollableSetHadjustment(x.GoPointer(), HadjustmentVar.GoPointer())
2807
2808}
2809
2810// Sets the `GtkScrollablePolicy`.
2811//
2812// The policy determines whether horizontal scrolling should start
2813// below the minimum width or below the natural width.
2814func (x *TreeView) SetHscrollPolicy(PolicyVar ScrollablePolicy) {
2815
2816	XGtkScrollableSetHscrollPolicy(x.GoPointer(), PolicyVar)
2817
2818}
2819
2820// Sets the vertical adjustment of the `GtkScrollable`.
2821func (x *TreeView) SetVadjustment(VadjustmentVar *Adjustment) {
2822
2823	XGtkScrollableSetVadjustment(x.GoPointer(), VadjustmentVar.GoPointer())
2824
2825}
2826
2827// Sets the `GtkScrollablePolicy`.
2828//
2829// The policy determines whether vertical scrolling should start
2830// below the minimum height or below the natural height.
2831func (x *TreeView) SetVscrollPolicy(PolicyVar ScrollablePolicy) {
2832
2833	XGtkScrollableSetVscrollPolicy(x.GoPointer(), PolicyVar)
2834
2835}
2836
2837func init() {
2838	core.SetPackageName("GTK", "gtk4")
2839	core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})
2840	var libs []uintptr
2841	for _, libPath := range core.GetPaths("GTK") {
2842		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
2843		if err != nil {
2844			panic(err)
2845		}
2846		libs = append(libs, lib)
2847	}
2848
2849	core.PuregoSafeRegister(&xTreeViewDropPositionGLibType, libs, "gtk_tree_view_drop_position_get_type")
2850
2851	core.PuregoSafeRegister(&xTreeViewGLibType, libs, "gtk_tree_view_get_type")
2852
2853	core.PuregoSafeRegister(&xNewTreeView, libs, "gtk_tree_view_new")
2854	core.PuregoSafeRegister(&xNewTreeViewWithModel, libs, "gtk_tree_view_new_with_model")
2855
2856	core.PuregoSafeRegister(&xTreeViewAppendColumn, libs, "gtk_tree_view_append_column")
2857	core.PuregoSafeRegister(&xTreeViewCollapseAll, libs, "gtk_tree_view_collapse_all")
2858	core.PuregoSafeRegister(&xTreeViewCollapseRow, libs, "gtk_tree_view_collapse_row")
2859	core.PuregoSafeRegister(&xTreeViewColumnsAutosize, libs, "gtk_tree_view_columns_autosize")
2860	core.PuregoSafeRegister(&xTreeViewConvertBinWindowToTreeCoords, libs, "gtk_tree_view_convert_bin_window_to_tree_coords")
2861	core.PuregoSafeRegister(&xTreeViewConvertBinWindowToWidgetCoords, libs, "gtk_tree_view_convert_bin_window_to_widget_coords")
2862	core.PuregoSafeRegister(&xTreeViewConvertTreeToBinWindowCoords, libs, "gtk_tree_view_convert_tree_to_bin_window_coords")
2863	core.PuregoSafeRegister(&xTreeViewConvertTreeToWidgetCoords, libs, "gtk_tree_view_convert_tree_to_widget_coords")
2864	core.PuregoSafeRegister(&xTreeViewConvertWidgetToBinWindowCoords, libs, "gtk_tree_view_convert_widget_to_bin_window_coords")
2865	core.PuregoSafeRegister(&xTreeViewConvertWidgetToTreeCoords, libs, "gtk_tree_view_convert_widget_to_tree_coords")
2866	core.PuregoSafeRegister(&xTreeViewCreateRowDragIcon, libs, "gtk_tree_view_create_row_drag_icon")
2867	core.PuregoSafeRegister(&xTreeViewEnableModelDragDest, libs, "gtk_tree_view_enable_model_drag_dest")
2868	core.PuregoSafeRegister(&xTreeViewEnableModelDragSource, libs, "gtk_tree_view_enable_model_drag_source")
2869	core.PuregoSafeRegister(&xTreeViewExpandAll, libs, "gtk_tree_view_expand_all")
2870	core.PuregoSafeRegister(&xTreeViewExpandRow, libs, "gtk_tree_view_expand_row")
2871	core.PuregoSafeRegister(&xTreeViewExpandToPath, libs, "gtk_tree_view_expand_to_path")
2872	core.PuregoSafeRegister(&xTreeViewGetActivateOnSingleClick, libs, "gtk_tree_view_get_activate_on_single_click")
2873	core.PuregoSafeRegister(&xTreeViewGetBackgroundArea, libs, "gtk_tree_view_get_background_area")
2874	core.PuregoSafeRegister(&xTreeViewGetCellArea, libs, "gtk_tree_view_get_cell_area")
2875	core.PuregoSafeRegister(&xTreeViewGetColumn, libs, "gtk_tree_view_get_column")
2876	core.PuregoSafeRegister(&xTreeViewGetColumns, libs, "gtk_tree_view_get_columns")
2877	core.PuregoSafeRegister(&xTreeViewGetCursor, libs, "gtk_tree_view_get_cursor")
2878	core.PuregoSafeRegister(&xTreeViewGetDestRowAtPos, libs, "gtk_tree_view_get_dest_row_at_pos")
2879	core.PuregoSafeRegister(&xTreeViewGetDragDestRow, libs, "gtk_tree_view_get_drag_dest_row")
2880	core.PuregoSafeRegister(&xTreeViewGetEnableSearch, libs, "gtk_tree_view_get_enable_search")
2881	core.PuregoSafeRegister(&xTreeViewGetEnableTreeLines, libs, "gtk_tree_view_get_enable_tree_lines")
2882	core.PuregoSafeRegister(&xTreeViewGetExpanderColumn, libs, "gtk_tree_view_get_expander_column")
2883	core.PuregoSafeRegister(&xTreeViewGetFixedHeightMode, libs, "gtk_tree_view_get_fixed_height_mode")
2884	core.PuregoSafeRegister(&xTreeViewGetGridLines, libs, "gtk_tree_view_get_grid_lines")
2885	core.PuregoSafeRegister(&xTreeViewGetHeadersClickable, libs, "gtk_tree_view_get_headers_clickable")
2886	core.PuregoSafeRegister(&xTreeViewGetHeadersVisible, libs, "gtk_tree_view_get_headers_visible")
2887	core.PuregoSafeRegister(&xTreeViewGetHoverExpand, libs, "gtk_tree_view_get_hover_expand")
2888	core.PuregoSafeRegister(&xTreeViewGetHoverSelection, libs, "gtk_tree_view_get_hover_selection")
2889	core.PuregoSafeRegister(&xTreeViewGetLevelIndentation, libs, "gtk_tree_view_get_level_indentation")
2890	core.PuregoSafeRegister(&xTreeViewGetModel, libs, "gtk_tree_view_get_model")
2891	core.PuregoSafeRegister(&xTreeViewGetNColumns, libs, "gtk_tree_view_get_n_columns")
2892	core.PuregoSafeRegister(&xTreeViewGetPathAtPos, libs, "gtk_tree_view_get_path_at_pos")
2893	core.PuregoSafeRegister(&xTreeViewGetReorderable, libs, "gtk_tree_view_get_reorderable")
2894	core.PuregoSafeRegister(&xTreeViewGetRowSeparatorFunc, libs, "gtk_tree_view_get_row_separator_func")
2895	core.PuregoSafeRegister(&xTreeViewGetRubberBanding, libs, "gtk_tree_view_get_rubber_banding")
2896	core.PuregoSafeRegister(&xTreeViewGetSearchColumn, libs, "gtk_tree_view_get_search_column")
2897	core.PuregoSafeRegister(&xTreeViewGetSearchEntry, libs, "gtk_tree_view_get_search_entry")
2898	core.PuregoSafeRegister(&xTreeViewGetSearchEqualFunc, libs, "gtk_tree_view_get_search_equal_func")
2899	core.PuregoSafeRegister(&xTreeViewGetSelection, libs, "gtk_tree_view_get_selection")
2900	core.PuregoSafeRegister(&xTreeViewGetShowExpanders, libs, "gtk_tree_view_get_show_expanders")
2901	core.PuregoSafeRegister(&xTreeViewGetTooltipColumn, libs, "gtk_tree_view_get_tooltip_column")
2902	core.PuregoSafeRegister(&xTreeViewGetTooltipContext, libs, "gtk_tree_view_get_tooltip_context")
2903	core.PuregoSafeRegister(&xTreeViewGetVisibleRange, libs, "gtk_tree_view_get_visible_range")
2904	core.PuregoSafeRegister(&xTreeViewGetVisibleRect, libs, "gtk_tree_view_get_visible_rect")
2905	core.PuregoSafeRegister(&xTreeViewInsertColumn, libs, "gtk_tree_view_insert_column")
2906	core.PuregoSafeRegister(&xTreeViewInsertColumnWithAttributes, libs, "gtk_tree_view_insert_column_with_attributes")
2907	core.PuregoSafeRegister(&xTreeViewInsertColumnWithDataFunc, libs, "gtk_tree_view_insert_column_with_data_func")
2908	core.PuregoSafeRegister(&xTreeViewIsBlankAtPos, libs, "gtk_tree_view_is_blank_at_pos")
2909	core.PuregoSafeRegister(&xTreeViewIsRubberBandingActive, libs, "gtk_tree_view_is_rubber_banding_active")
2910	core.PuregoSafeRegister(&xTreeViewMapExpandedRows, libs, "gtk_tree_view_map_expanded_rows")
2911	core.PuregoSafeRegister(&xTreeViewMoveColumnAfter, libs, "gtk_tree_view_move_column_after")
2912	core.PuregoSafeRegister(&xTreeViewRemoveColumn, libs, "gtk_tree_view_remove_column")
2913	core.PuregoSafeRegister(&xTreeViewRowActivated, libs, "gtk_tree_view_row_activated")
2914	core.PuregoSafeRegister(&xTreeViewRowExpanded, libs, "gtk_tree_view_row_expanded")
2915	core.PuregoSafeRegister(&xTreeViewScrollToCell, libs, "gtk_tree_view_scroll_to_cell")
2916	core.PuregoSafeRegister(&xTreeViewScrollToPoint, libs, "gtk_tree_view_scroll_to_point")
2917	core.PuregoSafeRegister(&xTreeViewSetActivateOnSingleClick, libs, "gtk_tree_view_set_activate_on_single_click")
2918	core.PuregoSafeRegister(&xTreeViewSetColumnDragFunction, libs, "gtk_tree_view_set_column_drag_function")
2919	core.PuregoSafeRegister(&xTreeViewSetCursor, libs, "gtk_tree_view_set_cursor")
2920	core.PuregoSafeRegister(&xTreeViewSetCursorOnCell, libs, "gtk_tree_view_set_cursor_on_cell")
2921	core.PuregoSafeRegister(&xTreeViewSetDragDestRow, libs, "gtk_tree_view_set_drag_dest_row")
2922	core.PuregoSafeRegister(&xTreeViewSetEnableSearch, libs, "gtk_tree_view_set_enable_search")
2923	core.PuregoSafeRegister(&xTreeViewSetEnableTreeLines, libs, "gtk_tree_view_set_enable_tree_lines")
2924	core.PuregoSafeRegister(&xTreeViewSetExpanderColumn, libs, "gtk_tree_view_set_expander_column")
2925	core.PuregoSafeRegister(&xTreeViewSetFixedHeightMode, libs, "gtk_tree_view_set_fixed_height_mode")
2926	core.PuregoSafeRegister(&xTreeViewSetGridLines, libs, "gtk_tree_view_set_grid_lines")
2927	core.PuregoSafeRegister(&xTreeViewSetHeadersClickable, libs, "gtk_tree_view_set_headers_clickable")
2928	core.PuregoSafeRegister(&xTreeViewSetHeadersVisible, libs, "gtk_tree_view_set_headers_visible")
2929	core.PuregoSafeRegister(&xTreeViewSetHoverExpand, libs, "gtk_tree_view_set_hover_expand")
2930	core.PuregoSafeRegister(&xTreeViewSetHoverSelection, libs, "gtk_tree_view_set_hover_selection")
2931	core.PuregoSafeRegister(&xTreeViewSetLevelIndentation, libs, "gtk_tree_view_set_level_indentation")
2932	core.PuregoSafeRegister(&xTreeViewSetModel, libs, "gtk_tree_view_set_model")
2933	core.PuregoSafeRegister(&xTreeViewSetReorderable, libs, "gtk_tree_view_set_reorderable")
2934	core.PuregoSafeRegister(&xTreeViewSetRowSeparatorFunc, libs, "gtk_tree_view_set_row_separator_func")
2935	core.PuregoSafeRegister(&xTreeViewSetRubberBanding, libs, "gtk_tree_view_set_rubber_banding")
2936	core.PuregoSafeRegister(&xTreeViewSetSearchColumn, libs, "gtk_tree_view_set_search_column")
2937	core.PuregoSafeRegister(&xTreeViewSetSearchEntry, libs, "gtk_tree_view_set_search_entry")
2938	core.PuregoSafeRegister(&xTreeViewSetSearchEqualFunc, libs, "gtk_tree_view_set_search_equal_func")
2939	core.PuregoSafeRegister(&xTreeViewSetShowExpanders, libs, "gtk_tree_view_set_show_expanders")
2940	core.PuregoSafeRegister(&xTreeViewSetTooltipCell, libs, "gtk_tree_view_set_tooltip_cell")
2941	core.PuregoSafeRegister(&xTreeViewSetTooltipColumn, libs, "gtk_tree_view_set_tooltip_column")
2942	core.PuregoSafeRegister(&xTreeViewSetTooltipRow, libs, "gtk_tree_view_set_tooltip_row")
2943	core.PuregoSafeRegister(&xTreeViewUnsetRowsDragDest, libs, "gtk_tree_view_unset_rows_drag_dest")
2944	core.PuregoSafeRegister(&xTreeViewUnsetRowsDragSource, libs, "gtk_tree_view_unset_rows_drag_source")
2945
2946}