@gtkx/ffi 0.10.5 → 0.11.1

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

@@ -1,45 +1,123 @@
 import { Ref } from "@gtkx/native";
-import { DirectionType, MovementStep, ScrollablePolicy, StateFlags, TextDirection, TreeViewDropPosition, TreeViewGridLines } from "./enums.js";
+import { MovementStep, ScrollablePolicy, TreeViewDropPosition, TreeViewGridLines } from "./enums.js";
 import { Border } from "./border.js";
 import { TreeIter } from "./tree-iter.js";
 import { TreePath } from "./tree-path.js";
-import { Adjustment } from "./adjustment.js";
-import { CellRenderer } from "./cell-renderer.js";
 import { Editable } from "./editable.js";
 import { TreeModel } from "./tree-model.js";
-import { TreeSelection } from "./tree-selection.js";
+import { Widget } from "./widget.js";
+import { Adjustment } from "./adjustment.js";
+import { CellRenderer } from "./cell-renderer.js";
 import { Tooltip } from "./tooltip.js";
+import { TreeSelection } from "./tree-selection.js";
 import { TreeViewColumn } from "./tree-view-column.js";
-import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
-import { Widget } from "./widget.js";
+/**
+ * A widget for displaying both trees and lists
+ *
+ * ![An example GtkTreeView](https://docs.gtk.org/gtk4/list-and-tree.png)
+ *
+ * Widget that displays any object that implements the {@link 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:
+ *
+ * ![](https://docs.gtk.org/gtk4/tree-view-coordinates.png)
+ *
+ * - 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 {@link Gtk.TreeView.convert_widget_to_bin_window_coords}
+ * (and vice versa), for the latter {@link Gtk.TreeView.convert_bin_window_to_tree_coords}
+ * (and vice versa).
+ *
+ * ## `GtkTreeView` as `GtkBuildable`
+ *
+ * The `GtkTreeView` implementation of the `GtkBuildable` interface accepts
+ * {@link Gtk.TreeViewColumn} objects as `<child>` elements and exposes the
+ * internal {@link 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.
+ */
 export declare class TreeView extends Widget {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
-    /**
-     * Creates a new `GtkTreeView` widget.
-     */
+    /** Creates a new `GtkTreeView` widget. */
     constructor();
-    /**
-     * Creates a new `GtkTreeView` widget with the model initialized to `model`.
-     * @param model - the model.
-     */
-    static viewNewWithModel(model: TreeModel): TreeView;
+    /** Creates a new `GtkTreeView` widget with the model initialized to `model`. */
+    static newWithModel(model: TreeModel): TreeView;
     /**
      * 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`.
-     */
+    /** 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`
-     */
+    /** Collapses a row (hides its child rows, if they exist). */
     collapseRow(path: TreePath): boolean;
     /**
      * Resizes all columns to their optimal width. Only works after the
@@ -49,95 +127,52 @@ export declare class TreeView extends Widget {
     /**
      * 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
-     */
+    /** Converts bin_window coordinates to widget relative coordinates. */
     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
-     */
+    /** Converts widget coordinates to coordinates for the bin_window. */
     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`.
-     */
+    /** 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
-     */
+    /** Opens the row so its children are visible. */
     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().
-     */
+    /** 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
@@ -149,11 +184,8 @@ export declare class TreeView extends Widget {
      * 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: Gdk.Rectangle, path?: TreePath, column?: TreeViewColumn): void;
+    getBackgroundArea(rect: 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
@@ -164,15 +196,9 @@ export declare class TreeView extends Widget {
      * 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: Gdk.Rectangle, path?: TreePath, column?: TreeViewColumn): void;
-    /**
-     * Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
-     * @param n - The position of the column, counting from 0.
      */
+    getCellArea(rect: Gdk.Rectangle, path?: TreePath | null, column?: TreeViewColumn | null): void;
+    /** Gets the `GtkTreeViewColumn` at the given position in the #tree_view. */
     getColumn(n: number): TreeViewColumn | null;
     /**
      * Returns a `GList` of all the `GtkTreeViewColumn`s currently in `tree_view`.
@@ -186,35 +212,23 @@ export declare class TreeView extends Widget {
      *
      * The returned `GtkTreePath` must be freed with gtk_tree_path_free() when
      * you are done with it.
-     * @param path - A pointer to be
-     * @param focusColumn - A
      */
-    treeViewGetCursor(path?: Ref<TreePath>, focusColumn?: Ref<TreeViewColumn>): void;
+    TreeViewGetCursor(path?: Ref<TreePath> | null, focusColumn?: Ref<TreeViewColumn> | null): void;
     /**
      * 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>, pos?: Ref<TreeViewDropPosition>): 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>, pos?: Ref<TreeViewDropPosition>): void;
+    getDestRowAtPos(dragX: number, dragY: number, path?: Ref<TreePath> | null, pos?: Ref<TreeViewDropPosition> | null): boolean;
+    /** Gets information about the row that is highlighted for feedback. */
+    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`.
-     */
+    /** Returns whether or not tree lines are drawn in `tree_view`. */
     getEnableTreeLines(): boolean;
     /**
      * Returns the column that is the current expander column,
@@ -222,29 +236,17 @@ export declare class TreeView extends Widget {
      * This column has the expander arrow drawn next to it.
      */
     getExpanderColumn(): TreeViewColumn | null;
-    /**
-     * Returns whether fixed height mode is turned on for `tree_view`.
-     */
+    /** Returns whether fixed height mode is turned on for `tree_view`. */
     getFixedHeightMode(): boolean;
-    /**
-     * Returns which grid lines are enabled in `tree_view`.
-     */
+    /** Returns which grid lines are enabled in `tree_view`. */
     getGridLines(): TreeViewGridLines;
-    /**
-     * Returns whether all header columns are clickable.
-     */
+    /** Returns whether all header columns are clickable. */
     getHeadersClickable(): boolean;
-    /**
-     * Returns %TRUE if the headers on the `tree_view` are visible.
-     */
+    /** Returns %TRUE if the headers on the `tree_view` are visible. */
     getHeadersVisible(): boolean;
-    /**
-     * Returns whether hover expansion mode is turned on for `tree_view`.
-     */
+    /** Returns whether hover expansion mode is turned on for `tree_view`. */
     getHoverExpand(): boolean;
-    /**
-     * Returns whether hover selection mode is turned on for `tree_view`.
-     */
+    /** Returns whether hover selection mode is turned on for `tree_view`. */
     getHoverSelection(): boolean;
     /**
      * Returns the amount, in pixels, of extra indentation for child levels
@@ -256,9 +258,7 @@ export declare class TreeView extends Widget {
      * model is unset.
      */
     getModel(): TreeModel | null;
-    /**
-     * Queries the number of columns in the given `tree_view`.
-     */
+    /** 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.
@@ -277,14 +277,8 @@ export declare class TreeView extends Widget {
      * 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>, column?: Ref<TreeViewColumn>, cellX?: Ref<number>, cellY?: Ref<number>): boolean;
+    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().
@@ -296,9 +290,7 @@ export declare class TreeView extends Widget {
      * user to select multiple rows by dragging the mouse.
      */
     getRubberBanding(): boolean;
-    /**
-     * Gets the column searched on by the interactive search code.
-     */
+    /** Gets the column searched on by the interactive search code. */
     getSearchColumn(): number;
     /**
      * Returns the `GtkEntry` which is currently in use as interactive search
@@ -306,13 +298,9 @@ export declare class TreeView extends Widget {
      * will be returned.
      */
     getSearchEntry(): Editable | null;
-    /**
-     * Gets the `GtkTreeSelection` associated with `tree_view`.
-     */
+    /** Gets the `GtkTreeSelection` associated with `tree_view`. */
     getSelection(): TreeSelection;
-    /**
-     * Returns whether or not expanders are drawn in `tree_view`.
-     */
+    /** 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
@@ -331,30 +319,21 @@ export declare class TreeView extends Widget {
      * `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>, path?: Ref<TreePath>, iter?: TreeIter): boolean;
+    getTooltipContext(x: number, y: number, keyboardTip: boolean, model?: Ref<TreeModel> | null, path?: Ref<TreePath> | null, iter?: 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>, endPath?: Ref<TreePath>): boolean;
+    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: Gdk.Rectangle): void;
     /**
@@ -362,8 +341,6 @@ export declare class TreeView extends Widget {
      * -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;
     /**
@@ -384,14 +361,8 @@ export declare class TreeView extends Widget {
      * 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>, column?: Ref<TreeViewColumn>, cellX?: Ref<number>, cellY?: Ref<number>): boolean;
+    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`.
@@ -400,25 +371,13 @@ export declare class TreeView extends Widget {
     /**
      * 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): void;
-    /**
-     * Removes `column` from `tree_view`.
-     * @param column - The `GtkTreeViewColumn` to remove.
      */
+    moveColumnAfter(column: TreeViewColumn, baseColumn?: TreeViewColumn | null): void;
+    /** Removes `column` from `tree_view`. */
     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): void;
-    /**
-     * Returns %TRUE if the node pointed to by `path` is expanded in `tree_view`.
-     * @param path - A `GtkTreePath` to test expansion state.
-     */
+    /** Activates the cell determined by `path` and `column`. */
+    rowActivated(path: TreePath, column?: TreeViewColumn | null): void;
+    /** Returns %TRUE if the node pointed to by `path` is expanded in `tree_view`. */
     rowExpanded(path: TreePath): boolean;
     /**
      * Moves the alignments of `tree_view` to the position specified by `column` and
@@ -437,13 +396,8 @@ export declare class TreeView extends Widget {
      * 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, column?: TreeViewColumn): void;
+    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
@@ -452,14 +406,11 @@ export declare class TreeView extends Widget {
      * 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;
     /**
@@ -474,11 +425,8 @@ export declare class TreeView extends Widget {
      *
      * 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 startEditing - %TRUE if the specified cell should start being edited.
      */
-    treeViewSetCursor(path: TreePath, startEditing: boolean, focusColumn?: TreeViewColumn): void;
+    TreeViewSetCursor(path: TreePath, startEditing: boolean, focusColumn?: TreeViewColumn | 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
@@ -494,32 +442,24 @@ export declare class TreeView extends Widget {
      *
      * 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, focusCell?: CellRenderer): void;
+    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): void;
+    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;
     /**
@@ -529,38 +469,26 @@ export declare class TreeView extends Widget {
      *
      * 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): void;
+    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
-     */
+    /** Sets which grid lines to draw in `tree_view`. */
     setGridLines(gridLines: TreeViewGridLines): void;
-    /**
-     * Allow the column title buttons to be clicked.
-     * @param setting - %TRUE if the columns are clickable.
-     */
+    /** Allow the column title buttons to be clicked. */
     setHeadersClickable(setting: boolean): void;
-    /**
-     * Sets the visibility state of the headers.
-     * @param headersVisible - %TRUE if the headers are visible
-     */
+    /** Sets the visibility state of the headers. */
     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;
     /**
@@ -568,7 +496,6 @@ export declare class TreeView extends Widget {
      * 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;
     /**
@@ -577,16 +504,14 @@ export declare class TreeView extends Widget {
      * 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): void;
+    setModel(model?: TreeModel | null): void;
     /**
      * This function is a convenience function to allow you to reorder
      * models that support the `GtkTreeDragSourceIface` and the
@@ -602,14 +527,12 @@ export declare class TreeView extends Widget {
      * 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;
     /**
      * 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;
     /**
@@ -622,7 +545,6 @@ export declare class TreeView extends Widget {
      *
      * 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;
     /**
@@ -631,9 +553,8 @@ export declare class TreeView extends Widget {
      * 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): void;
+    setSearchEntry(entry?: Editable | 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
@@ -642,7 +563,6 @@ export declare class TreeView extends Widget {
      * 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;
     /**
@@ -657,12 +577,8 @@ export declare class TreeView extends Widget {
      * 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, column?: TreeViewColumn, cell?: CellRenderer): void;
+    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
@@ -674,15 +590,12 @@ export declare class TreeView extends Widget {
      *
      * 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;
     /**
@@ -704,49 +617,32 @@ export declare class TreeView extends Widget {
      * 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: Border): boolean;
-    /**
-     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
-     */
+    /** Retrieves the `GtkAdjustment` used for horizontal scrolling. */
     getHadjustment(): Adjustment | null;
-    /**
-     * Gets the horizontal `GtkScrollablePolicy`.
-     */
+    /** Gets the horizontal `GtkScrollablePolicy`. */
     getHscrollPolicy(): ScrollablePolicy;
-    /**
-     * Retrieves the `GtkAdjustment` used for vertical scrolling.
-     */
+    /** Retrieves the `GtkAdjustment` used for vertical scrolling. */
     getVadjustment(): Adjustment | null;
-    /**
-     * Gets the vertical `GtkScrollablePolicy`.
-     */
+    /** Gets the vertical `GtkScrollablePolicy`. */
     getVscrollPolicy(): ScrollablePolicy;
-    /**
-     * Sets the horizontal adjustment of the `GtkScrollable`.
-     * @param hadjustment - a `GtkAdjustment`
-     */
-    setHadjustment(hadjustment?: Adjustment): void;
+    /** Sets the horizontal adjustment of the `GtkScrollable`. */
+    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): void;
+    /** Sets the vertical adjustment of the `GtkScrollable`. */
+    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;
@@ -764,19 +660,5 @@ export declare class TreeView extends Widget {
     connect(signal: "test-expand-row", handler: (self: TreeView, iter: TreeIter, path: TreePath) => boolean, after?: boolean): number;
     connect(signal: "toggle-cursor-row", handler: (self: TreeView) => boolean, after?: boolean): number;
     connect(signal: "unselect-all", handler: (self: TreeView) => boolean, after?: boolean): number;
-    connect(signal: "destroy", handler: (self: TreeView) => void, after?: boolean): number;
-    connect(signal: "direction-changed", handler: (self: TreeView, previousDirection: TextDirection) => void, after?: boolean): number;
-    connect(signal: "hide", handler: (self: TreeView) => void, after?: boolean): number;
-    connect(signal: "keynav-failed", handler: (self: TreeView, direction: DirectionType) => boolean, after?: boolean): number;
-    connect(signal: "map", handler: (self: TreeView) => void, after?: boolean): number;
-    connect(signal: "mnemonic-activate", handler: (self: TreeView, groupCycling: boolean) => boolean, after?: boolean): number;
-    connect(signal: "move-focus", handler: (self: TreeView, direction: DirectionType) => void, after?: boolean): number;
-    connect(signal: "query-tooltip", handler: (self: TreeView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
-    connect(signal: "realize", handler: (self: TreeView) => void, after?: boolean): number;
-    connect(signal: "show", handler: (self: TreeView) => void, after?: boolean): number;
-    connect(signal: "state-flags-changed", handler: (self: TreeView, flags: StateFlags) => void, after?: boolean): number;
-    connect(signal: "unmap", handler: (self: TreeView) => void, after?: boolean): number;
-    connect(signal: "unrealize", handler: (self: TreeView) => void, after?: boolean): number;
-    connect(signal: "notify", handler: (self: TreeView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }