@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/tree-view.d.ts

@@ -14,101 +14,760 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class TreeView extends Widget {
+    /**
+     * Creates a new `GtkTreeView` widget.
+     */
     constructor(...args: unknown[]);
+    /**
+     * Creates a new `GtkTreeView` widget with the model initialized to @model.
+     * @param model - the model.
+     */
     static viewNewWithModel(model: TreeModel): TreeView;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * 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: TreeViewColumn): number;
+    /**
+     * Recursively collapses all visible, expanded nodes in @tree_view.
+     */
     collapseAll(): void;
+    /**
+     * Collapses a row (hides its child rows, if they exist).
+     * @param path - path to a row in the @tree_view
+     */
     collapseRow(path: TreePath): boolean;
+    /**
+     * Resizes all columns to their optimal width. Only works after the
+     * treeview has been realized.
+     */
     columnsAutosize(): void;
+    /**
+     * 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: number, by: number, tx: Ref<number>, ty: Ref<number>): void;
+    /**
+     * 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: number, by: number, wx: Ref<number>, wy: Ref<number>): void;
+    /**
+     * 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: number, ty: number, bx: Ref<number>, by: Ref<number>): void;
+    /**
+     * 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: number, ty: number, wx: Ref<number>, wy: Ref<number>): void;
+    /**
+     * 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: number, wy: number, bx: Ref<number>, by: Ref<number>): void;
+    /**
+     * 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: number, wy: number, tx: Ref<number>, ty: Ref<number>): void;
+    /**
+     * 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: TreePath): Gdk.Paintable | null;
+    /**
+     * 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: Gdk.ContentFormats, actions: Gdk.DragAction): void;
+    /**
+     * 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: Gdk.ModifierType, formats: Gdk.ContentFormats, actions: Gdk.DragAction): void;
+    /**
+     * Recursively expands all nodes in the @tree_view.
+     */
     expandAll(): void;
+    /**
+     * 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: TreePath, openAll: boolean): 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: TreePath): void;
+    /**
+     * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
+     */
     getActivateOnSingleClick(): 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: Ref<Gdk.Rectangle>, path?: TreePath | null, column?: TreeViewColumn | null): void;
+    /**
+     * 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: Ref<Gdk.Rectangle>, path?: TreePath | null, column?: TreeViewColumn | null): void;
+    /**
+     * Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
+     * @param n - The position of the column, counting from 0.
+     */
     getColumn(n: number): TreeViewColumn | null;
+    /**
+     * Returns a `GList` of all the `GtkTreeViewColumn`s currently in @tree_view.
+     * The returned list must be freed with g_list_free ().
+     */
     getColumns(): 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: number, dragY: number, path?: Ref<TreePath> | null, pos?: Ref<TreeViewDropPosition> | null): 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?: Ref<TreePath> | null, pos?: Ref<TreeViewDropPosition> | null): void;
+    /**
+     * Returns whether or not the tree allows to start interactive searching
+     * by typing in text.
+     */
     getEnableSearch(): boolean;
+    /**
+     * Returns whether or not tree lines are drawn in @tree_view.
+     */
     getEnableTreeLines(): 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(): TreeViewColumn | null;
+    /**
+     * Returns whether fixed height mode is turned on for @tree_view.
+     */
     getFixedHeightMode(): boolean;
+    /**
+     * Returns which grid lines are enabled in @tree_view.
+     */
     getGridLines(): TreeViewGridLines;
+    /**
+     * Returns whether all header columns are clickable.
+     */
     getHeadersClickable(): boolean;
+    /**
+     * Returns %TRUE if the headers on the `tree_view` are visible.
+     */
     getHeadersVisible(): boolean;
+    /**
+     * Returns whether hover expansion mode is turned on for @tree_view.
+     */
     getHoverExpand(): boolean;
+    /**
+     * Returns whether hover selection mode is turned on for @tree_view.
+     */
     getHoverSelection(): boolean;
+    /**
+     * Returns the amount, in pixels, of extra indentation for child levels
+     * in @tree_view.
+     */
     getLevelIndentation(): number;
+    /**
+     * Returns the model the `GtkTreeView` is based on.  Returns %NULL if the
+     * model is unset.
+     */
     getModel(): TreeModel | null;
+    /**
+     * Queries the number of columns in the given @tree_view.
+     */
     getNColumns(): number;
+    /**
+     * 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: number, y: number, path?: Ref<TreePath> | null, column?: Ref<TreeViewColumn> | null, cellX?: Ref<number> | null, cellY?: Ref<number> | null): boolean;
+    /**
+     * Retrieves whether the user can reorder the tree via drag-and-drop. See
+     * gtk_tree_view_set_reorderable().
+     */
     getReorderable(): 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(): boolean;
+    /**
+     * Gets the column searched on by the interactive search code.
+     */
     getSearchColumn(): number;
+    /**
+     * 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(): Editable | null;
+    /**
+     * Gets the `GtkTreeSelection` associated with @tree_view.
+     */
     getSelection(): TreeSelection;
+    /**
+     * Returns whether or not expanders are drawn in @tree_view.
+     */
     getShowExpanders(): boolean;
+    /**
+     * Returns the column of @tree_view’s model which is being used for
+     * displaying tooltips on @tree_view’s rows.
+     */
     getTooltipColumn(): number;
+    /**
+     * 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: number, y: number, keyboardTip: boolean, model?: Ref<TreeModel> | null, path?: Ref<TreePath> | null, iter?: Ref<TreeIter> | null): 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?: Ref<TreePath> | null, endPath?: Ref<TreePath> | null): 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: Ref<Gdk.Rectangle>): void;
+    /**
+     * 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: TreeViewColumn, position: number): number;
+    /**
+     * 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: number, title: string, cell: CellRenderer, func: (...args: unknown[]) => unknown, dnotify: () => void, data?: number | null): number;
+    /**
+     * 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: number, y: number, path?: Ref<TreePath> | null, column?: Ref<TreeViewColumn> | null, cellX?: Ref<number> | null, cellY?: Ref<number> | null): boolean;
+    /**
+     * Returns whether a rubber banding operation is currently being done
+     * in @tree_view.
+     */
     isRubberBandingActive(): 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: (...args: unknown[]) => unknown, data?: number | null): void;
+    /**
+     * 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: TreeViewColumn, baseColumn?: TreeViewColumn | null): void;
+    /**
+     * Removes `column` from @tree_view.
+     * @param column - The `GtkTreeViewColumn` to remove.
+     */
     removeColumn(column: TreeViewColumn): number;
+    /**
+     * Activates the cell determined by `path` and @column.
+     * @param path - The `GtkTreePath` to be activated.
+     * @param column - The `GtkTreeViewColumn` to be activated.
+     */
     rowActivated(path: TreePath, column?: TreeViewColumn | null): void;
+    /**
+     * Returns %TRUE if the node pointed to by `path` is expanded in @tree_view.
+     * @param path - A `GtkTreePath` to test expansion state.
+     */
     rowExpanded(path: TreePath): 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: boolean, rowAlign: number, colAlign: number, path?: TreePath | null, column?: TreeViewColumn | null): void;
+    /**
+     * 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: number, treeY: number): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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?: (...args: unknown[]) => unknown | null, userData?: number | null, destroy?: () => void | null): void;
+    /**
+     * 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: TreePath, startEditing: boolean, focusColumn?: TreeViewColumn | null, focusCell?: CellRenderer | null): void;
+    /**
+     * 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: TreeViewDropPosition, path?: TreePath | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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?: TreeViewColumn | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * Sets which grid lines to draw in @tree_view.
+     * @param gridLines - a `GtkTreeView`GridLines value indicating which grid lines to
+     */
     setGridLines(gridLines: TreeViewGridLines): void;
+    /**
+     * Allow the column title buttons to be clicked.
+     * @param setting - %TRUE if the columns are clickable.
+     */
     setHeadersClickable(setting: boolean): void;
+    /**
+     * Sets the visibility state of the headers.
+     * @param headersVisible - %TRUE if the headers are visible
+     */
     setHeadersVisible(headersVisible: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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?: TreeModel | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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?: (...args: unknown[]) => unknown | null, data?: number | null, destroy?: () => void | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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?: Editable | null): void;
+    /**
+     * 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: (...args: unknown[]) => unknown, searchUserData?: number | null, searchDestroy?: () => void | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: Tooltip, path?: TreePath | null, column?: TreeViewColumn | null, cell?: CellRenderer | null): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: Tooltip, path: TreePath): void;
+    /**
+     * Undoes the effect of
+     * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
+     * `GtkTreeView`:reorderable to %FALSE.
+     */
     unsetRowsDragDest(): void;
+    /**
+     * Undoes the effect of
+     * gtk_tree_view_enable_model_drag_source(). Calling this method sets
+     * `GtkTreeView`:reorderable to %FALSE.
+     */
     unsetRowsDragSource(): void;
+    /**
+     * 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: Ref<Border>): boolean;
+    /**
+     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+     */
     getHadjustment(): Adjustment | null;
+    /**
+     * Gets the horizontal `GtkScrollablePolicy`.
+     */
     getHscrollPolicy(): ScrollablePolicy;
+    /**
+     * Retrieves the `GtkAdjustment` used for vertical scrolling.
+     */
     getVadjustment(): Adjustment | null;
+    /**
+     * Gets the vertical `GtkScrollablePolicy`.
+     */
     getVscrollPolicy(): ScrollablePolicy;
+    /**
+     * Sets the horizontal adjustment of the `GtkScrollable`.
+     * @param hadjustment - a `GtkAdjustment`
+     */
     setHadjustment(hadjustment?: Adjustment | null): void;
+    /**
+     * 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: ScrollablePolicy): void;
+    /**
+     * Sets the vertical adjustment of the `GtkScrollable`.
+     * @param vadjustment - a `GtkAdjustment`
+     */
     setVadjustment(vadjustment?: Adjustment | null): void;
+    /**
+     * 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: ScrollablePolicy): void;
     connect(signal: "columns-changed", handler: (self: TreeView) => void, after?: boolean): number;
     connect(signal: "cursor-changed", handler: (self: TreeView) => void, after?: boolean): number;