@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/tree-view.js

@@ -7,6 +7,96 @@ import { TreeSelection } from "./tree-selection.js";
 import { TreeViewColumn } from "./tree-view-column.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
+/**
+ * A widget for displaying both trees and lists
+ *
+ *
+ *
+ * Widget that displays any object that implements the [iface@Gtk.TreeModel] interface.
+ *
+ * Please refer to the tree widget conceptual overview
+ * for an overview of all the objects and data types related to the tree
+ * widget and how they work together.
+ *
+ * ## Coordinate systems in GtkTreeView API
+ *
+ * Several different coordinate systems are exposed in the `GtkTreeView` API.
+ * These are:
+ *
+ *
+ *
+ * - Widget coordinates: Coordinates relative to the widget (usually `widget->window`).
+ *
+ * - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
+ *
+ * - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
+ * coordinates start at (0, 0) for row 0 of the tree.
+ *
+ * Several functions are available for converting between the different
+ * coordinate systems.  The most common translations are between widget and bin
+ * window coordinates and between bin window and tree coordinates. For the
+ * former you can use [method@Gtk.TreeView.convert_widget_to_bin_window_coords]
+ * (and vice versa), for the latter [method@Gtk.TreeView.convert_bin_window_to_tree_coords]
+ * (and vice versa).
+ *
+ * ## `GtkTreeView` as `GtkBuildable`
+ *
+ * The `GtkTreeView` implementation of the `GtkBuildable` interface accepts
+ * [class@Gtk.TreeViewColumn] objects as `<child>` elements and exposes the
+ * internal [class@Gtk.TreeSelection] in UI definitions.
+ *
+ * An example of a UI definition fragment with `GtkTreeView`:
+ *
+ * ```xml
+ * <object class="GtkTreeView" id="treeview">
+ * <property name="model">liststore1</property>
+ * <child>
+ * <object class="GtkTreeViewColumn" id="test-column">
+ * <property name="title">Test</property>
+ * <child>
+ * <object class="GtkCellRendererText" id="test-renderer"/>
+ * <attributes>
+ * <attribute name="text">1</attribute>
+ * </attributes>
+ * </child>
+ * </object>
+ * </child>
+ * <child internal-child="selection">
+ * <object class="GtkTreeSelection" id="selection">
+ * <signal name="changed" handler="on_treeview_selection_changed"/>
+ * </object>
+ * </child>
+ * </object>
+ * ```
+ *
+ * ## CSS nodes
+ *
+ * ```
+ * treeview.view
+ * ├── header
+ * │   ├── button
+ * │   │   ╰── [sort-indicator]
+ * ┊   ┊
+ * │   ╰── button
+ * │       ╰── [sort-indicator]
+ * │
+ * ├── [rubberband]
+ * ╰── [dndtarget]
+ * ```
+ *
+ * `GtkTreeView` has a main CSS node with name `treeview` and style class `.view`.
+ * It has a subnode with name `header`, which is the parent for all the column
+ * header widgets' CSS nodes.
+ *
+ * Each column header consists of a `button`, which among other content, has a
+ * child with name `sort-indicator`, which carries the `.ascending` or `.descending`
+ * style classes when the column header should show a sort indicator. The CSS
+ * is expected to provide a suitable image using the `-gtk-icon-source` property.
+ *
+ * For rubberband selection, a subnode with name `rubberband` is used.
+ *
+ * For the drop target location during DND, a subnode with name `dndtarget` is used.
+ */
 const SIGNAL_META = {
     "columns-changed": { params: [], returnType: { type: "undefined" } },
     "cursor-changed": { params: [], returnType: { type: "undefined" } },
@@ -76,9 +166,16 @@ const SIGNAL_META = {
     "unselect-all": { params: [], returnType: { type: "boolean" } },
 };
 export class TreeView extends Widget {
+    /**
+     * Creates a new `GtkTreeView` widget.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new `GtkTreeView` widget with the model initialized to @model.
+     * @param model - the model.
+     */
     static viewNewWithModel(model) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_new_with_model", [
             {
@@ -94,6 +191,12 @@ export class TreeView extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Appends `column` to the list of columns. If `tree_view` has “fixed_height”
+     * mode enabled, then `column` must have its “sizing” property set to be
+     * GTK_TREE_VIEW_COLUMN_FIXED.
+     * @param column - The `GtkTreeViewColumn` to add.
+     */
     appendColumn(column) {
         return call("libgtk-4.so.1", "gtk_tree_view_append_column", [
             {
@@ -106,6 +209,9 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Recursively collapses all visible, expanded nodes in @tree_view.
+     */
     collapseAll() {
         call("libgtk-4.so.1", "gtk_tree_view_collapse_all", [
             {
@@ -114,6 +220,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Collapses a row (hides its child rows, if they exist).
+     * @param path - path to a row in the @tree_view
+     */
     collapseRow(path) {
         return call("libgtk-4.so.1", "gtk_tree_view_collapse_row", [
             {
@@ -131,6 +241,10 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Resizes all columns to their optimal width. Only works after the
+     * treeview has been realized.
+     */
     columnsAutosize() {
         call("libgtk-4.so.1", "gtk_tree_view_columns_autosize", [
             {
@@ -139,6 +253,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts bin_window coordinates to coordinates for the
+     * tree (the full scrollable area of the tree).
+     * @param bx - X coordinate relative to bin_window
+     * @param by - Y coordinate relative to bin_window
+     * @param tx - return location for tree X coordinate
+     * @param ty - return location for tree Y coordinate
+     */
     convertBinWindowToTreeCoords(bx, by, tx, ty) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_bin_window_to_tree_coords", [
             {
@@ -169,6 +291,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts bin_window coordinates to widget relative coordinates.
+     * @param bx - bin_window X coordinate
+     * @param by - bin_window Y coordinate
+     * @param wx - return location for widget X coordinate
+     * @param wy - return location for widget Y coordinate
+     */
     convertBinWindowToWidgetCoords(bx, by, wx, wy) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_bin_window_to_widget_coords", [
             {
@@ -199,6 +328,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts tree coordinates (coordinates in full scrollable area of the tree)
+     * to bin_window coordinates.
+     * @param tx - tree X coordinate
+     * @param ty - tree Y coordinate
+     * @param bx - return location for X coordinate relative to bin_window
+     * @param by - return location for Y coordinate relative to bin_window
+     */
     convertTreeToBinWindowCoords(tx, ty, bx, by) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_tree_to_bin_window_coords", [
             {
@@ -229,6 +366,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts tree coordinates (coordinates in full scrollable area of the tree)
+     * to widget coordinates.
+     * @param tx - X coordinate relative to the tree
+     * @param ty - Y coordinate relative to the tree
+     * @param wx - return location for widget X coordinate
+     * @param wy - return location for widget Y coordinate
+     */
     convertTreeToWidgetCoords(tx, ty, wx, wy) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_tree_to_widget_coords", [
             {
@@ -259,6 +404,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts widget coordinates to coordinates for the bin_window.
+     * @param wx - X coordinate relative to the widget
+     * @param wy - Y coordinate relative to the widget
+     * @param bx - return location for bin_window X coordinate
+     * @param by - return location for bin_window Y coordinate
+     */
     convertWidgetToBinWindowCoords(wx, wy, bx, by) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_widget_to_bin_window_coords", [
             {
@@ -289,6 +441,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts widget coordinates to coordinates for the
+     * tree (the full scrollable area of the tree).
+     * @param wx - X coordinate relative to the widget
+     * @param wy - Y coordinate relative to the widget
+     * @param tx - return location for tree X coordinate
+     * @param ty - return location for tree Y coordinate
+     */
     convertWidgetToTreeCoords(wx, wy, tx, ty) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_widget_to_tree_coords", [
             {
@@ -319,6 +479,11 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a `cairo_surface_t` representation of the row at @path.
+     * This image is used for a drag icon.
+     * @param path - a `GtkTreePath` in @tree_view
+     */
     createRowDragIcon(path) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_create_row_drag_icon", [
             {
@@ -339,6 +504,12 @@ export class TreeView extends Widget {
             return null;
         return getObject(ptr, Gdk.Paintable);
     }
+    /**
+     * Turns `tree_view` into a drop destination for automatic DND. Calling
+     * this method sets `GtkTreeView`:reorderable to %FALSE.
+     * @param formats - the target formats that the drag will support
+     * @param actions - the bitmask of possible actions for a drag from this
+     */
     enableModelDragDest(formats, actions) {
         call("libgtk-4.so.1", "gtk_tree_view_enable_model_drag_dest", [
             {
@@ -360,6 +531,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Turns `tree_view` into a drag source for automatic DND. Calling this
+     * method sets `GtkTreeView`:reorderable to %FALSE.
+     * @param startButtonMask - Mask of allowed buttons to start drag
+     * @param formats - the target formats that the drag will support
+     * @param actions - the bitmask of possible actions for a drag from this
+     */
     enableModelDragSource(startButtonMask, formats, actions) {
         call("libgtk-4.so.1", "gtk_tree_view_enable_model_drag_source", [
             {
@@ -385,6 +563,9 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Recursively expands all nodes in the @tree_view.
+     */
     expandAll() {
         call("libgtk-4.so.1", "gtk_tree_view_expand_all", [
             {
@@ -393,6 +574,11 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Opens the row so its children are visible.
+     * @param path - path to a row
+     * @param openAll - whether to recursively expand, or just expand immediate children
+     */
     expandRow(path, openAll) {
         return call("libgtk-4.so.1", "gtk_tree_view_expand_row", [
             {
@@ -414,6 +600,11 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Expands the row at @path. This will also expand all parent rows of
+     * `path` as necessary.
+     * @param path - path to a row.
+     */
     expandToPath(path) {
         call("libgtk-4.so.1", "gtk_tree_view_expand_to_path", [
             {
@@ -431,6 +622,9 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
+     */
     getActivateOnSingleClick() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_activate_on_single_click", [
             {
@@ -439,6 +633,19 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Fills the bounding rectangle in bin_window coordinates for the cell at the
+     * row specified by `path` and the column specified by @column.  If `path` is
+     * %NULL, or points to a node not found in the tree, the `y` and `height` fields of
+     * the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width` fields will be filled with 0.  The returned rectangle is equivalent to the
+     * `background_area` passed to gtk_cell_renderer_render().  These background
+     * areas tile to cover the entire bin window.  Contrast with the @cell_area,
+     * returned by gtk_tree_view_get_cell_area(), which returns only the cell
+     * itself, excluding surrounding borders and the tree expander area.
+     * @param path - a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
+     * @param column - a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
+     * @param rect - rectangle to fill with cell background rect
+     */
     getBackgroundArea(rect, path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_get_background_area", [
             {
@@ -473,6 +680,19 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Fills the bounding rectangle in bin_window coordinates for the cell at the
+     * row specified by `path` and the column specified by @column.  If `path` is
+     * %NULL, or points to a path not currently displayed, the `y` and `height` fields
+     * of the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width` fields will be filled with 0.  The sum of all cell rects does not cover the
+     * entire tree; there are extra pixels in between rows, for example. The
+     * returned rectangle is equivalent to the `cell_area` passed to
+     * gtk_cell_renderer_render().  This function is only valid if `tree_view` is
+     * realized.
+     * @param path - a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
+     * @param column - a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
+     * @param rect - rectangle to fill with cell rect
+     */
     getCellArea(rect, path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_get_cell_area", [
             {
@@ -507,6 +727,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
+     * @param n - The position of the column, counting from 0.
+     */
     getColumn(n) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_column", [
             {
@@ -522,6 +746,10 @@ export class TreeView extends Widget {
             return null;
         return getObject(ptr, TreeViewColumn);
     }
+    /**
+     * Returns a `GList` of all the `GtkTreeViewColumn`s currently in @tree_view.
+     * The returned list must be freed with g_list_free ().
+     */
     getColumns() {
         const ptrs = call("libgtk-4.so.1", "gtk_tree_view_get_columns", [
             {
@@ -536,6 +764,16 @@ export class TreeView extends Widget {
         });
         return ptrs.map((ptr) => getObject(ptr, TreeViewColumn));
     }
+    /**
+     * Determines the destination row for a given position.  `drag_x` and
+     * `drag_y` are expected to be in widget coordinates.  This function is only
+     * meaningful if `tree_view` is realized.  Therefore this function will always
+     * return %FALSE if `tree_view` is not realized or does not have a model.
+     * @param dragX - the position to determine the destination row for
+     * @param dragY - the position to determine the destination row for
+     * @param path - Return location for the path of
+     * @param pos - Return location for the drop position, or
+     */
     getDestRowAtPos(dragX, dragY, path, pos) {
         return call("libgtk-4.so.1", "gtk_tree_view_get_dest_row_at_pos", [
             {
@@ -572,6 +810,11 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets information about the row that is highlighted for feedback.
+     * @param path - Return location for the path of the highlighted row
+     * @param pos - Return location for the drop position
+     */
     getDragDestRow(path, pos) {
         call("libgtk-4.so.1", "gtk_tree_view_get_drag_dest_row", [
             {
@@ -600,6 +843,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether or not the tree allows to start interactive searching
+     * by typing in text.
+     */
     getEnableSearch() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_enable_search", [
             {
@@ -608,6 +855,9 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether or not tree lines are drawn in @tree_view.
+     */
     getEnableTreeLines() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_enable_tree_lines", [
             {
@@ -616,6 +866,11 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the column that is the current expander column,
+     * or %NULL if none has been set.
+     * This column has the expander arrow drawn next to it.
+     */
     getExpanderColumn() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_expander_column", [
             {
@@ -627,6 +882,9 @@ export class TreeView extends Widget {
             return null;
         return getObject(ptr, TreeViewColumn);
     }
+    /**
+     * Returns whether fixed height mode is turned on for @tree_view.
+     */
     getFixedHeightMode() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_fixed_height_mode", [
             {
@@ -635,6 +893,9 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns which grid lines are enabled in @tree_view.
+     */
     getGridLines() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_grid_lines", [
             {
@@ -643,6 +904,9 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns whether all header columns are clickable.
+     */
     getHeadersClickable() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_headers_clickable", [
             {
@@ -651,6 +915,9 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if the headers on the `tree_view` are visible.
+     */
     getHeadersVisible() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_headers_visible", [
             {
@@ -659,6 +926,9 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether hover expansion mode is turned on for @tree_view.
+     */
     getHoverExpand() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_hover_expand", [
             {
@@ -667,6 +937,9 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether hover selection mode is turned on for @tree_view.
+     */
     getHoverSelection() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_hover_selection", [
             {
@@ -675,6 +948,10 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the amount, in pixels, of extra indentation for child levels
+     * in @tree_view.
+     */
     getLevelIndentation() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_level_indentation", [
             {
@@ -683,6 +960,10 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the model the `GtkTreeView` is based on.  Returns %NULL if the
+     * model is unset.
+     */
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_model", [
             {
@@ -694,6 +975,9 @@ export class TreeView extends Widget {
             return null;
         return getObject(ptr, TreeModel);
     }
+    /**
+     * Queries the number of columns in the given @tree_view.
+     */
     getNColumns() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_n_columns", [
             {
@@ -702,6 +986,30 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Finds the path at the point (@x, @y), relative to bin_window coordinates.
+     * That is, `x` and `y` are relative to an events coordinates. Widget-relative
+     * coordinates must be converted using
+     * gtk_tree_view_convert_widget_to_bin_window_coords(). It is primarily for
+     * things like popup menus. If `path` is non-%NULL, then it will be filled
+     * with the `GtkTreePath` at that point.  This path should be freed with
+     * gtk_tree_path_free().  If `column` is non-%NULL, then it will be filled
+     * with the column at that point.  `cell_x` and `cell_y` return the coordinates
+     * relative to the cell background (i.e. the `background_area` passed to
+     * gtk_cell_renderer_render()).  This function is only meaningful if
+     * `tree_view` is realized.  Therefore this function will always return %FALSE
+     * if `tree_view` is not realized or does not have a model.
+     *
+     * For converting widget coordinates (eg. the ones you get from
+     * GtkWidget::query-tooltip), please see
+     * gtk_tree_view_convert_widget_to_bin_window_coords().
+     * @param x - The x position to be identified (relative to bin_window).
+     * @param y - The y position to be identified (relative to bin_window).
+     * @param path - A pointer to a `GtkTreePath`
+     * @param column - A pointer to
+     * @param cellX - A pointer where the X coordinate
+     * @param cellY - A pointer where the Y coordinate
+     */
     getPathAtPos(x, y, path, column, cellX, cellY) {
         return call("libgtk-4.so.1", "gtk_tree_view_get_path_at_pos", [
             {
@@ -751,6 +1059,10 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves whether the user can reorder the tree via drag-and-drop. See
+     * gtk_tree_view_set_reorderable().
+     */
     getReorderable() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_reorderable", [
             {
@@ -759,6 +1071,11 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether rubber banding is turned on for @tree_view.  If the
+     * selection mode is %GTK_SELECTION_MULTIPLE, rubber banding will allow the
+     * user to select multiple rows by dragging the mouse.
+     */
     getRubberBanding() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_rubber_banding", [
             {
@@ -767,6 +1084,9 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the column searched on by the interactive search code.
+     */
     getSearchColumn() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_search_column", [
             {
@@ -775,6 +1095,11 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the `GtkEntry` which is currently in use as interactive search
+     * entry for @tree_view.  In case the built-in entry is being used, %NULL
+     * will be returned.
+     */
     getSearchEntry() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_search_entry", [
             {
@@ -786,6 +1111,9 @@ export class TreeView extends Widget {
             return null;
         return getObject(ptr, Editable);
     }
+    /**
+     * Gets the `GtkTreeSelection` associated with @tree_view.
+     */
     getSelection() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_selection", [
             {
@@ -795,6 +1123,9 @@ export class TreeView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, TreeSelection);
     }
+    /**
+     * Returns whether or not expanders are drawn in @tree_view.
+     */
     getShowExpanders() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_show_expanders", [
             {
@@ -803,6 +1134,10 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the column of @tree_view’s model which is being used for
+     * displaying tooltips on @tree_view’s rows.
+     */
     getTooltipColumn() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_tooltip_column", [
             {
@@ -811,6 +1146,25 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * This function is supposed to be used in a ::query-tooltip
+     * signal handler for `GtkTreeView`. The @x, `y` and `keyboard_tip` values
+     * which are received in the signal handler, should be passed to this
+     * function without modification.
+     *
+     * The return value indicates whether there is a tree view row at the given
+     * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
+     * tooltips the row returned will be the cursor row. When %TRUE, then any of
+     * @model, `path` and `iter` which have been provided will be set to point to
+     * that row and the corresponding model. `x` and `y` will always be converted
+     * to be relative to @tree_view’s bin_window if `keyboard_tooltip` is %FALSE.
+     * @param x - the x coordinate (relative to widget coordinates)
+     * @param y - the y coordinate (relative to widget coordinates)
+     * @param keyboardTip - whether this is a keyboard tooltip or not
+     * @param model - a pointer to
+     * @param path - a pointer to receive a `GtkTreePath`
+     * @param iter - a pointer to receive a `GtkTreeIter`
+     */
     getTooltipContext(x, y, keyboardTip, model, path, iter) {
         return call("libgtk-4.so.1", "gtk_tree_view_get_tooltip_context", [
             {
@@ -860,6 +1214,14 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets `start_path` and `end_path` to be the first and last visible path.
+     * Note that there may be invisible paths in between.
+     *
+     * The paths should be freed with gtk_tree_path_free() after use.
+     * @param startPath - Return location for start of region
+     * @param endPath - Return location for end of region
+     */
     getVisibleRange(startPath, endPath) {
         return call("libgtk-4.so.1", "gtk_tree_view_get_visible_range", [
             {
@@ -892,6 +1254,14 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Fills `visible_rect` with the currently-visible region of the
+     * buffer, in tree coordinates. Convert to bin_window coordinates with
+     * gtk_tree_view_convert_tree_to_bin_window_coords().
+     * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
+     * scrollable area of the tree.
+     * @param visibleRect - rectangle to fill
+     */
     getVisibleRect(visibleRect) {
         call("libgtk-4.so.1", "gtk_tree_view_get_visible_rect", [
             {
@@ -911,6 +1281,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * This inserts the `column` into the `tree_view` at @position.  If `position` is
+     * -1, then the column is inserted at the end. If `tree_view` has
+     * “fixed_height” mode enabled, then `column` must have its “sizing” property
+     * set to be GTK_TREE_VIEW_COLUMN_FIXED.
+     * @param column - The `GtkTreeViewColumn` to be inserted.
+     * @param position - The position to insert `column` in.
+     */
     insertColumn(column, position) {
         return call("libgtk-4.so.1", "gtk_tree_view_insert_column", [
             {
@@ -927,6 +1305,20 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Convenience function that inserts a new column into the `GtkTreeView`
+     * with the given cell renderer and a `GtkTreeCellDataFunc` to set cell renderer
+     * attributes (normally using data from the model). See also
+     * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
+     * If `tree_view` has “fixed_height” mode enabled, then the new column will have its
+     * “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
+     * @param position - Position to insert, -1 for append
+     * @param title - column title
+     * @param cell - cell renderer for column
+     * @param func - function to set attributes of cell renderer
+     * @param data - data for @func
+     * @param dnotify - destroy notifier for @data
+     */
     insertColumnWithDataFunc(position, title, cell, func, dnotify, data) {
         return call("libgtk-4.so.1", "gtk_tree_view_insert_column_with_data_func", [
             {
@@ -960,6 +1352,31 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Determine whether the point (@x, @y) in `tree_view` is blank, that is no
+     * cell content nor an expander arrow is drawn at the location. If so, the
+     * location can be considered as the background. You might wish to take
+     * special action on clicks on the background, such as clearing a current
+     * selection, having a custom context menu or starting rubber banding.
+     *
+     * The `x` and `y` coordinate that are provided must be relative to bin_window
+     * coordinates.  Widget-relative coordinates must be converted using
+     * gtk_tree_view_convert_widget_to_bin_window_coords().
+     *
+     * For converting widget coordinates (eg. the ones you get from
+     * GtkWidget::query-tooltip), please see
+     * gtk_tree_view_convert_widget_to_bin_window_coords().
+     *
+     * The @path, @column, `cell_x` and `cell_y` arguments will be filled in
+     * likewise as for gtk_tree_view_get_path_at_pos().  Please see
+     * gtk_tree_view_get_path_at_pos() for more information.
+     * @param x - The x position to be identified (relative to bin_window)
+     * @param y - The y position to be identified (relative to bin_window)
+     * @param path - A pointer to a `GtkTreePath` pointer to
+     * @param column - A pointer to a
+     * @param cellX - A pointer where the X coordinate relative to the
+     * @param cellY - A pointer where the Y coordinate relative to the
+     */
     isBlankAtPos(x, y, path, column, cellX, cellY) {
         return call("libgtk-4.so.1", "gtk_tree_view_is_blank_at_pos", [
             {
@@ -1009,6 +1426,10 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether a rubber banding operation is currently being done
+     * in @tree_view.
+     */
     isRubberBandingActive() {
         return call("libgtk-4.so.1", "gtk_tree_view_is_rubber_banding_active", [
             {
@@ -1017,6 +1438,11 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls `func` on all expanded rows.
+     * @param func - A function to be called
+     * @param data - User data to be passed to the function.
+     */
     mapExpandedRows(func, data) {
         call("libgtk-4.so.1", "gtk_tree_view_map_expanded_rows", [
             {
@@ -1034,6 +1460,12 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves `column` to be after to @base_column.  If `base_column` is %NULL, then
+     * `column` is placed in the first position.
+     * @param column - The `GtkTreeViewColumn` to be moved.
+     * @param baseColumn - The `GtkTreeViewColumn` to be moved relative to
+     */
     moveColumnAfter(column, baseColumn) {
         call("libgtk-4.so.1", "gtk_tree_view_move_column_after", [
             {
@@ -1051,6 +1483,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes `column` from @tree_view.
+     * @param column - The `GtkTreeViewColumn` to remove.
+     */
     removeColumn(column) {
         return call("libgtk-4.so.1", "gtk_tree_view_remove_column", [
             {
@@ -1063,6 +1499,11 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Activates the cell determined by `path` and @column.
+     * @param path - The `GtkTreePath` to be activated.
+     * @param column - The `GtkTreeViewColumn` to be activated.
+     */
     rowActivated(path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_row_activated", [
             {
@@ -1085,6 +1526,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns %TRUE if the node pointed to by `path` is expanded in @tree_view.
+     * @param path - A `GtkTreePath` to test expansion state.
+     */
     rowExpanded(path) {
         return call("libgtk-4.so.1", "gtk_tree_view_row_expanded", [
             {
@@ -1102,6 +1547,28 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves the alignments of `tree_view` to the position specified by `column` and
+     * @path.  If `column` is %NULL, then no horizontal scrolling occurs.  Likewise,
+     * if `path` is %NULL no vertical scrolling occurs.  At a minimum, one of `column` or `path` need to be non-%NULL.  `row_align` determines where the row is
+     * placed, and `col_align` determines where `column` is placed.  Both are expected
+     * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
+     * right/bottom alignment, 0.5 means center.
+     *
+     * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
+     * tree does the minimum amount of work to scroll the cell onto the screen.
+     * This means that the cell will be scrolled to the edge closest to its current
+     * position.  If the cell is currently visible on the screen, nothing is done.
+     *
+     * This function only works if the model is set, and `path` is a valid row on the
+     * model.  If the model changes before the `tree_view` is realized, the centered
+     * path will be modified to reflect this change.
+     * @param path - The path of the row to move to
+     * @param column - The `GtkTreeViewColumn` to move horizontally to
+     * @param useAlign - whether to use alignment arguments, or %FALSE.
+     * @param rowAlign - The vertical alignment of the row specified by @path.
+     * @param colAlign - The horizontal alignment of the column specified by @column.
+     */
     scrollToCell(useAlign, rowAlign, colAlign, path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_scroll_to_cell", [
             {
@@ -1137,6 +1604,17 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Scrolls the tree view such that the top-left corner of the visible
+     * area is @tree_x, @tree_y, where `tree_x` and `tree_y` are specified
+     * in tree coordinates.  The `tree_view` must be realized before
+     * this function is called.  If it isn't, you probably want to be
+     * using gtk_tree_view_scroll_to_cell().
+     *
+     * If either `tree_x` or `tree_y` are -1, then that direction isn’t scrolled.
+     * @param treeX - X coordinate of new top-left pixel of visible area, or -1
+     * @param treeY - Y coordinate of new top-left pixel of visible area, or -1
+     */
     scrollToPoint(treeX, treeY) {
         call("libgtk-4.so.1", "gtk_tree_view_scroll_to_point", [
             {
@@ -1153,6 +1631,11 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Cause the `GtkTreeView`::row-activated signal to be emitted
+     * on a single click instead of a double click.
+     * @param single - %TRUE to emit row-activated on a single click
+     */
     setActivateOnSingleClick(single) {
         call("libgtk-4.so.1", "gtk_tree_view_set_activate_on_single_click", [
             {
@@ -1165,6 +1648,20 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a user function for determining where a column may be dropped when
+     * dragged.  This function is called on every column pair in turn at the
+     * beginning of a column drag to determine where a drop can take place.  The
+     * arguments passed to `func` are: the @tree_view, the `GtkTreeViewColumn` being
+     * dragged, the two `GtkTreeViewColumn`s determining the drop spot, and
+     * @user_data.  If either of the `GtkTreeViewColumn` arguments for the drop spot
+     * are %NULL, then they indicate an edge.  If `func` is set to be %NULL, then
+     * `tree_view` reverts to the default behavior of allowing all columns to be
+     * dropped everywhere.
+     * @param func - A function to determine which columns are reorderable
+     * @param userData - User data to be passed to @func
+     * @param destroy - Destroy notifier for @user_data
+     */
     setColumnDragFunction(func, userData, destroy) {
         call("libgtk-4.so.1", "gtk_tree_view_set_column_drag_function", [
             {
@@ -1188,6 +1685,25 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the current keyboard focus to be at @path, and selects it.  This is
+     * useful when you want to focus the user’s attention on a particular row.  If
+     * `focus_column` is not %NULL, then focus is given to the column specified by
+     * it. If `focus_column` and `focus_cell` are not %NULL, and `focus_column` contains 2 or more editable or activatable cells, then focus is given to
+     * the cell specified by @focus_cell. Additionally, if `focus_column` is
+     * specified, and `start_editing` is %TRUE, then editing should be started in
+     * the specified cell.  This function is often followed by
+     * `gtk_widget_grab_focus` (@tree_view) in order to give keyboard focus to the
+     * widget.  Please note that editing can only happen when the widget is
+     * realized.
+     *
+     * If `path` is invalid for @model, the current cursor (if any) will be unset
+     * and the function will return without failing.
+     * @param path - A `GtkTreePath`
+     * @param focusColumn - A `GtkTreeViewColumn`
+     * @param focusCell - A `GtkCellRenderer`
+     * @param startEditing - %TRUE if the specified cell should start being edited.
+     */
     setCursorOnCell(path, startEditing, focusColumn, focusCell) {
         call("libgtk-4.so.1", "gtk_tree_view_set_cursor_on_cell", [
             {
@@ -1219,6 +1735,12 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the row that is highlighted for feedback.
+     * If `path` is %NULL, an existing highlight is removed.
+     * @param path - The path of the row to highlight
+     * @param pos - Specifies whether to drop before, after or into the row
+     */
     setDragDestRow(pos, path) {
         call("libgtk-4.so.1", "gtk_tree_view_set_drag_dest_row", [
             {
@@ -1241,6 +1763,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If `enable_search` is set, then the user can type in text to search through
+     * the tree interactively (this is sometimes called "typeahead find").
+     *
+     * Note that even if this is %FALSE, the user can still initiate a search
+     * using the “start-interactive-search” key binding.
+     * @param enableSearch - %TRUE, if the user can search interactively
+     */
     setEnableSearch(enableSearch) {
         call("libgtk-4.so.1", "gtk_tree_view_set_enable_search", [
             {
@@ -1253,6 +1783,11 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to draw lines interconnecting the expanders in @tree_view.
+     * This does not have any visible effects for lists.
+     * @param enabled - %TRUE to enable tree line drawing, %FALSE otherwise.
+     */
     setEnableTreeLines(enabled) {
         call("libgtk-4.so.1", "gtk_tree_view_set_enable_tree_lines", [
             {
@@ -1265,6 +1800,15 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the column to draw the expander arrow at. It must be in @tree_view.
+     * If `column` is %NULL, then the expander arrow is always at the first
+     * visible column.
+     *
+     * If you do not want expander arrow to appear in your tree, set the
+     * expander column to a hidden column.
+     * @param column - %NULL, or the column to draw the expander arrow at.
+     */
     setExpanderColumn(column) {
         call("libgtk-4.so.1", "gtk_tree_view_set_expander_column", [
             {
@@ -1278,6 +1822,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Enables or disables the fixed height mode of @tree_view.
+     * Fixed height mode speeds up `GtkTreeView` by assuming that all
+     * rows have the same height.
+     * Only enable this option if all rows are the same height and all
+     * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
+     * @param enable - %TRUE to enable fixed height mode
+     */
     setFixedHeightMode(enable) {
         call("libgtk-4.so.1", "gtk_tree_view_set_fixed_height_mode", [
             {
@@ -1290,6 +1842,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets which grid lines to draw in @tree_view.
+     * @param gridLines - a `GtkTreeView`GridLines value indicating which grid lines to
+     */
     setGridLines(gridLines) {
         call("libgtk-4.so.1", "gtk_tree_view_set_grid_lines", [
             {
@@ -1302,6 +1858,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Allow the column title buttons to be clicked.
+     * @param setting - %TRUE if the columns are clickable.
+     */
     setHeadersClickable(setting) {
         call("libgtk-4.so.1", "gtk_tree_view_set_headers_clickable", [
             {
@@ -1314,6 +1874,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the visibility state of the headers.
+     * @param headersVisible - %TRUE if the headers are visible
+     */
     setHeadersVisible(headersVisible) {
         call("libgtk-4.so.1", "gtk_tree_view_set_headers_visible", [
             {
@@ -1326,6 +1890,12 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Enables or disables the hover expansion mode of @tree_view.
+     * Hover expansion makes rows expand or collapse if the pointer
+     * moves over them.
+     * @param expand - %TRUE to enable hover selection mode
+     */
     setHoverExpand(expand) {
         call("libgtk-4.so.1", "gtk_tree_view_set_hover_expand", [
             {
@@ -1338,6 +1908,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Enables or disables the hover selection mode of @tree_view.
+     * Hover selection makes the selected row follow the pointer.
+     * Currently, this works only for the selection modes
+     * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+     * @param hover - %TRUE to enable hover selection mode
+     */
     setHoverSelection(hover) {
         call("libgtk-4.so.1", "gtk_tree_view_set_hover_selection", [
             {
@@ -1350,6 +1927,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the amount of extra indentation for child levels to use in `tree_view` in addition to the default indentation.  The value should be specified in
+     * pixels, a value of 0 disables this feature and in this case only the default
+     * indentation will be used.
+     * This does not have any visible effects for lists.
+     * @param indentation - the amount, in pixels, of extra indentation in @tree_view.
+     */
     setLevelIndentation(indentation) {
         call("libgtk-4.so.1", "gtk_tree_view_set_level_indentation", [
             {
@@ -1362,6 +1946,12 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the model for a `GtkTreeView`.  If the `tree_view` already has a model
+     * set, it will remove it before setting the new model.  If `model` is %NULL,
+     * then it will unset the old model.
+     * @param model - The model.
+     */
     setModel(model) {
         call("libgtk-4.so.1", "gtk_tree_view_set_model", [
             {
@@ -1375,6 +1965,23 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * This function is a convenience function to allow you to reorder
+     * models that support the `GtkTreeDragSourceIface` and the
+     * `GtkTreeDragDestIface`.  Both `GtkTreeStore` and `GtkListStore` support
+     * these.  If `reorderable` is %TRUE, then the user can reorder the
+     * model by dragging and dropping rows. The developer can listen to
+     * these changes by connecting to the model’s `GtkTreeModel::row-inserted`
+     * and `GtkTreeModel::row-deleted` signals. The reordering is implemented
+     * by setting up the tree view as a drag source and destination.
+     * Therefore, drag and drop can not be used in a reorderable view for any
+     * other purpose.
+     *
+     * This function does not give you any degree of control over the order -- any
+     * reordering is allowed.  If more control is needed, you should probably
+     * handle drag and drop manually.
+     * @param reorderable - %TRUE, if the tree can be reordered.
+     */
     setReorderable(reorderable) {
         call("libgtk-4.so.1", "gtk_tree_view_set_reorderable", [
             {
@@ -1387,6 +1994,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the row separator function, which is used to determine
+     * whether a row should be drawn as a separator. If the row separator
+     * function is %NULL, no separators are drawn. This is the default value.
+     * @param func - a `GtkTreeView`RowSeparatorFunc
+     * @param data - user data to pass to @func
+     * @param destroy - destroy notifier for @data
+     */
     setRowSeparatorFunc(func, data, destroy) {
         call("libgtk-4.so.1", "gtk_tree_view_set_row_separator_func", [
             {
@@ -1410,6 +2025,12 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Enables or disables rubber banding in @tree_view.  If the selection mode
+     * is %GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
+     * multiple rows by dragging the mouse.
+     * @param enable - %TRUE to enable rubber banding
+     */
     setRubberBanding(enable) {
         call("libgtk-4.so.1", "gtk_tree_view_set_rubber_banding", [
             {
@@ -1422,6 +2043,18 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `column` as the column where the interactive search code should
+     * search in for the current model.
+     *
+     * If the search column is set, users can use the “start-interactive-search”
+     * key binding to bring up search popup. The enable-search property controls
+     * whether simply typing text will also start an interactive search.
+     *
+     * Note that `column` refers to a column of the current model. The search
+     * column is reset to -1 when the model is changed.
+     * @param column - the column of the model to search in, or -1 to disable searching
+     */
     setSearchColumn(column) {
         call("libgtk-4.so.1", "gtk_tree_view_set_search_column", [
             {
@@ -1434,6 +2067,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the entry which the interactive search code will use for this
+     * @tree_view.  This is useful when you want to provide a search entry
+     * in our interface at all time at a fixed position.  Passing %NULL for
+     * `entry` will make the interactive search code use the built-in popup
+     * entry again.
+     * @param entry - the entry the interactive search code of `tree_view` should use
+     */
     setSearchEntry(entry) {
         call("libgtk-4.so.1", "gtk_tree_view_set_search_entry", [
             {
@@ -1447,6 +2088,14 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the compare function for the interactive search capabilities; note
+     * that somewhat like strcmp() returning 0 for equality
+     * `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
+     * @param searchEqualFunc - the compare function to use during the search
+     * @param searchUserData - user data to pass to @search_equal_func
+     * @param searchDestroy - Destroy notifier for @search_user_data
+     */
     setSearchEqualFunc(searchEqualFunc, searchUserData, searchDestroy) {
         call("libgtk-4.so.1", "gtk_tree_view_set_search_equal_func", [
             {
@@ -1469,6 +2118,16 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to draw and enable expanders and indent child rows in
+     * @tree_view.  When disabled there will be no expanders visible in trees
+     * and there will be no way to expand and collapse rows by default.  Also
+     * note that hiding the expanders will disable the default indentation.  You
+     * can set a custom indentation in this case using
+     * gtk_tree_view_set_level_indentation().
+     * This does not have any visible effects for lists.
+     * @param enabled - %TRUE to enable expander drawing, %FALSE otherwise.
+     */
     setShowExpanders(enabled) {
         call("libgtk-4.so.1", "gtk_tree_view_set_show_expanders", [
             {
@@ -1481,6 +2140,23 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the tip area of `tooltip` to the area @path, `column` and `cell` have
+     * in common.  For example if `path` is %NULL and `column` is set, the tip
+     * area will be set to the full area covered by @column.  See also
+     * gtk_tooltip_set_tip_area().
+     *
+     * Note that if `path` is not specified and `cell` is set and part of a column
+     * containing the expander, the tooltip might not show and hide at the correct
+     * position.  In such cases `path` must be set to the current node under the
+     * mouse cursor for this function to operate correctly.
+     *
+     * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
+     * @param tooltip - a `GtkTooltip`
+     * @param path - a `GtkTreePath`
+     * @param column - a `GtkTreeViewColumn`
+     * @param cell - a `GtkCellRenderer`
+     */
     setTooltipCell(tooltip, path, column, cell) {
         call("libgtk-4.so.1", "gtk_tree_view_set_tooltip_cell", [
             {
@@ -1513,6 +2189,19 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If you only plan to have simple (text-only) tooltips on full rows, you
+     * can use this function to have `GtkTreeView` handle these automatically
+     * for you. `column` should be set to the column in @tree_view’s model
+     * containing the tooltip texts, or -1 to disable this feature.
+     *
+     * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
+     * `tree_view` will connect a `GtkWidget::query-tooltip` signal handler.
+     *
+     * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
+     * so &, <, etc have to be escaped in the text.
+     * @param column - an integer, which is a valid column number for @tree_view’s model
+     */
     setTooltipColumn(column) {
         call("libgtk-4.so.1", "gtk_tree_view_set_tooltip_column", [
             {
@@ -1525,6 +2214,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the tip area of `tooltip` to be the area covered by the row at @path.
+     * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
+     * See also gtk_tooltip_set_tip_area().
+     * @param tooltip - a `GtkTooltip`
+     * @param path - a `GtkTreePath`
+     */
     setTooltipRow(tooltip, path) {
         call("libgtk-4.so.1", "gtk_tree_view_set_tooltip_row", [
             {
@@ -1546,6 +2242,11 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Undoes the effect of
+     * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
+     * `GtkTreeView`:reorderable to %FALSE.
+     */
     unsetRowsDragDest() {
         call("libgtk-4.so.1", "gtk_tree_view_unset_rows_drag_dest", [
             {
@@ -1554,6 +2255,11 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Undoes the effect of
+     * gtk_tree_view_enable_model_drag_source(). Calling this method sets
+     * `GtkTreeView`:reorderable to %FALSE.
+     */
     unsetRowsDragSource() {
         call("libgtk-4.so.1", "gtk_tree_view_unset_rows_drag_source", [
             {
@@ -1562,6 +2268,15 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the size of a non-scrolling border around the
+     * outside of the scrollable.
+     *
+     * An example for this would be treeview headers. GTK can use
+     * this information to display overlaid graphics, like the
+     * overshoot indication, at the right position.
+     * @param border - return location for the results
+     */
     getBorder(border) {
         return call("libgtk-4.so.1", "gtk_scrollable_get_border", [
             {
@@ -1581,6 +2296,9 @@ export class TreeView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+     */
     getHadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrollable_get_hadjustment", [
             {
@@ -1592,6 +2310,9 @@ export class TreeView extends Widget {
             return null;
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Gets the horizontal `GtkScrollablePolicy`.
+     */
     getHscrollPolicy() {
         return call("libgtk-4.so.1", "gtk_scrollable_get_hscroll_policy", [
             {
@@ -1600,6 +2321,9 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the `GtkAdjustment` used for vertical scrolling.
+     */
     getVadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrollable_get_vadjustment", [
             {
@@ -1611,6 +2335,9 @@ export class TreeView extends Widget {
             return null;
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Gets the vertical `GtkScrollablePolicy`.
+     */
     getVscrollPolicy() {
         return call("libgtk-4.so.1", "gtk_scrollable_get_vscroll_policy", [
             {
@@ -1619,6 +2346,10 @@ export class TreeView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the horizontal adjustment of the `GtkScrollable`.
+     * @param hadjustment - a `GtkAdjustment`
+     */
     setHadjustment(hadjustment) {
         call("libgtk-4.so.1", "gtk_scrollable_set_hadjustment", [
             {
@@ -1632,6 +2363,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether horizontal scrolling should start
+     * below the minimum width or below the natural width.
+     * @param policy - the horizontal `GtkScrollablePolicy`
+     */
     setHscrollPolicy(policy) {
         call("libgtk-4.so.1", "gtk_scrollable_set_hscroll_policy", [
             {
@@ -1644,6 +2382,10 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the vertical adjustment of the `GtkScrollable`.
+     * @param vadjustment - a `GtkAdjustment`
+     */
     setVadjustment(vadjustment) {
         call("libgtk-4.so.1", "gtk_scrollable_set_vadjustment", [
             {
@@ -1657,6 +2399,13 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether vertical scrolling should start
+     * below the minimum height or below the natural height.
+     * @param policy - the vertical `GtkScrollablePolicy`
+     */
     setVscrollPolicy(policy) {
         call("libgtk-4.so.1", "gtk_scrollable_set_vscroll_policy", [
             {