@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -4,13 +4,32 @@ import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A visible column in a [class@Gtk.TreeView] widget
+ *
+ * The `GtkTreeViewColumn` object represents a visible column in a `GtkTreeView` widget.
+ * It allows to set properties of the column header, and functions as a holding pen
+ * for the cell renderers which determine how the data in the column is displayed.
+ *
+ * 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, and to the [class@Gtk.TreeView] documentation for specifics
+ * about the CSS node structure for treeviews and their headers.
+ */
 const SIGNAL_META = {
     clicked: { params: [], returnType: { type: "undefined" } },
 };
 export class TreeViewColumn extends GObject.InitiallyUnowned {
+    /**
+     * Creates a new `GtkTreeViewColumn`.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new `GtkTreeViewColumn` using `area` to render its cells.
+     * @param area - the `GtkCellArea` that the newly created column should use to layout cells.
+     */
     static viewColumnNewWithArea(area) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_column_new_with_area", [
             {
@@ -26,6 +45,19 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             borrowed: true,
         });
     }
+    /**
+     * Adds an attribute mapping to the list in @tree_column.
+     *
+     * The `column` is the
+     * column of the model to get a value from, and the `attribute` is the
+     * parameter on `cell_renderer` to be set from the value. So for example
+     * if column 2 of the model contains strings, you could have the
+     * “text” attribute of a `GtkCellRendererText` get its values from
+     * column 2.
+     * @param cellRenderer - the `GtkCellRenderer` to set attributes on
+     * @param attribute - An attribute on the renderer
+     * @param column - The column position on the model to get the attribute from.
+     */
     addAttribute(cellRenderer, attribute, column) {
         call("libgtk-4.so.1", "gtk_tree_view_column_add_attribute", [
             {
@@ -46,6 +78,14 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Obtains the horizontal position and size of a cell in a column.
+     *
+     * If the  cell is not found in the column, `start_pos` and `width` are not changed and %FALSE is returned.
+     * @param cellRenderer - a `GtkCellRenderer`
+     * @param xOffset - return location for the horizontal
+     * @param width - return location for the width of @cell
+     */
     cellGetPosition(cellRenderer, xOffset, width) {
         return call("libgtk-4.so.1", "gtk_tree_view_column_cell_get_position", [
             {
@@ -74,6 +114,14 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Obtains the width and height needed to render the column.  This is used
+     * primarily by the `GtkTreeView`.
+     * @param xOffset - location to return x offset of a cell relative to @cell_area
+     * @param yOffset - location to return y offset of a cell relative to @cell_area
+     * @param width - location to return width needed to render a cell
+     * @param height - location to return height needed to render a cell
+     */
     cellGetSize(xOffset, yOffset, width, height) {
         call("libgtk-4.so.1", "gtk_tree_view_column_cell_get_size", [
             {
@@ -114,6 +162,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns %TRUE if any of the cells packed into the `tree_column` are visible.
+     * For this to be meaningful, you must first initialize the cells with
+     * gtk_tree_view_column_cell_set_cell_data()
+     */
     cellIsVisible() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_cell_is_visible", [
             {
@@ -122,6 +175,16 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets the cell renderer based on the `tree_model` and @iter.  That is, for
+     * every attribute mapping in @tree_column, it will get a value from the set
+     * column on the @iter, and use that value to set the attribute on the cell
+     * renderer.  This is used primarily by the `GtkTreeView`.
+     * @param treeModel - The `GtkTreeModel` to get the cell renderers attributes from.
+     * @param iter - The `GtkTreeIter` to get the cell renderer’s attributes from.
+     * @param isExpander - %TRUE, if the row has children
+     * @param isExpanded - %TRUE, if the row has visible children
+     */
     cellSetCellData(treeModel, iter, isExpander, isExpanded) {
         call("libgtk-4.so.1", "gtk_tree_view_column_cell_set_cell_data", [
             {
@@ -151,6 +214,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unsets all the mappings on all renderers on the @tree_column.
+     */
     clear() {
         call("libgtk-4.so.1", "gtk_tree_view_column_clear", [
             {
@@ -159,6 +225,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Clears all existing attributes previously set with
+     * gtk_tree_view_column_set_attributes().
+     * @param cellRenderer - a `GtkCellRenderer` to clear the attribute mapping on.
+     */
     clearAttributes(cellRenderer) {
         call("libgtk-4.so.1", "gtk_tree_view_column_clear_attributes", [
             {
@@ -171,6 +242,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the “clicked” signal on the column.  This function will only work if
+     * `tree_column` is clickable.
+     */
     clicked() {
         call("libgtk-4.so.1", "gtk_tree_view_column_clicked", [
             {
@@ -179,6 +254,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the current keyboard focus to be at @cell, if the column contains
+     * 2 or more editable and activatable cells.
+     * @param cell - A `GtkCellRenderer`
+     */
     focusCell(cell) {
         call("libgtk-4.so.1", "gtk_tree_view_column_focus_cell", [
             {
@@ -191,6 +271,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the current x alignment of @tree_column.  This value can range
+     * between 0.0 and 1.0.
+     */
     getAlignment() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_alignment", [
             {
@@ -199,6 +283,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Returns the button used in the treeview column header
+     */
     getButton() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_column_get_button", [
             {
@@ -208,6 +295,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns %TRUE if the user can click on the header for the column.
+     */
     getClickable() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_clickable", [
             {
@@ -216,6 +306,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if the column expands to fill available space.
+     */
     getExpand() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_expand", [
             {
@@ -224,6 +317,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the fixed width of the column.  This may not be the actual displayed
+     * width of the column; for that, use gtk_tree_view_column_get_width().
+     */
     getFixedWidth() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_fixed_width", [
             {
@@ -232,6 +329,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
+     * width is set.
+     */
     getMaxWidth() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_max_width", [
             {
@@ -240,6 +341,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
+     * width is set.
+     */
     getMinWidth() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_min_width", [
             {
@@ -248,6 +353,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns %TRUE if the `tree_column` can be reordered by the user.
+     */
     getReorderable() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_reorderable", [
             {
@@ -256,6 +364,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if the `tree_column` can be resized by the end user.
+     */
     getResizable() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_resizable", [
             {
@@ -264,6 +375,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the current type of @tree_column.
+     */
     getSizing() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_sizing", [
             {
@@ -272,6 +386,12 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the logical `sort_column_id` that the model sorts on
+     * when this column is selected for sorting.
+     *
+     * See [method@Gtk.TreeViewColumn.set_sort_column_id].
+     */
     getSortColumnId() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_sort_column_id", [
             {
@@ -280,6 +400,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the value set by gtk_tree_view_column_set_sort_indicator().
+     */
     getSortIndicator() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_sort_indicator", [
             {
@@ -288,6 +411,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the value set by gtk_tree_view_column_set_sort_order().
+     */
     getSortOrder() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_sort_order", [
             {
@@ -296,6 +422,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the spacing of @tree_column.
+     */
     getSpacing() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_spacing", [
             {
@@ -304,6 +433,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the title of the widget.
+     */
     getTitle() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_title", [
             {
@@ -312,6 +444,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns the `GtkTreeView` wherein `tree_column` has been inserted.
+     * If `column` is currently not inserted in any tree view, %NULL is
+     * returned.
+     */
     getTreeView() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_column_get_tree_view", [
             {
@@ -323,6 +460,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns %TRUE if `tree_column` is visible.
+     */
     getVisible() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_visible", [
             {
@@ -331,6 +471,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the `GtkWidget` in the button on the column header.
+     *
+     * If a custom widget has not been set then %NULL is returned.
+     */
     getWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_column_get_widget", [
             {
@@ -342,6 +487,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns the current size of `tree_column` in pixels.
+     */
     getWidth() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_width", [
             {
@@ -350,6 +498,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the current X offset of `tree_column` in pixels.
+     */
     getXOffset() {
         return call("libgtk-4.so.1", "gtk_tree_view_column_get_x_offset", [
             {
@@ -358,6 +509,12 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Adds the `cell` to end of the column. If `expand` is %FALSE, then the `cell` is allocated no more space than it needs. Any unused space is divided
+     * evenly between cells for which `expand` is %TRUE.
+     * @param cell - The `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @tree_column.
+     */
     packEnd(cell, expand) {
         call("libgtk-4.so.1", "gtk_tree_view_column_pack_end", [
             {
@@ -374,6 +531,13 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Packs the `cell` into the beginning of the column. If `expand` is %FALSE, then
+     * the `cell` is allocated no more space than it needs. Any unused space is divided
+     * evenly between cells for which `expand` is %TRUE.
+     * @param cell - The `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @tree_column.
+     */
     packStart(cell, expand) {
         call("libgtk-4.so.1", "gtk_tree_view_column_pack_start", [
             {
@@ -390,6 +554,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Flags the column, and the cell renderers added to this column, to have
+     * their sizes renegotiated.
+     */
     queueResize() {
         call("libgtk-4.so.1", "gtk_tree_view_column_queue_resize", [
             {
@@ -398,6 +566,12 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the alignment of the title or custom widget inside the column header.
+     * The alignment determines its location inside the button -- 0.0 for left, 0.5
+     * for center, 1.0 for right.
+     * @param xalign - The alignment, which is between [0.0 and 1.0] inclusive.
+     */
     setAlignment(xalign) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_alignment", [
             {
@@ -410,6 +584,19 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkTreeCellDataFunc` to use for the column.
+     *
+     * This
+     * function is used instead of the standard attributes mapping for
+     * setting the column value, and should set the value of @tree_column's
+     * cell renderer as appropriate.  `func` may be %NULL to remove an
+     * older one.
+     * @param cellRenderer - A `GtkCellRenderer`
+     * @param func - The `GtkTreeCellDataFunc` to use.
+     * @param funcData - The user data for @func.
+     * @param destroy - The destroy notification for @func_data
+     */
     setCellDataFunc(cellRenderer, destroy, func, funcData) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_cell_data_func", [
             {
@@ -436,6 +623,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the header to be active if `clickable` is %TRUE.  When the header is
+     * active, then it can take keyboard focus, and can be clicked.
+     * @param clickable - %TRUE if the header is active.
+     */
     setClickable(clickable) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_clickable", [
             {
@@ -448,6 +640,16 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the column to take available extra space.  This space is shared equally
+     * amongst all columns that have the expand set to %TRUE.  If no column has this
+     * option set, then the last column gets all extra space.  By default, every
+     * column is created with this %FALSE.
+     *
+     * Along with “fixed-width”, the “expand” property changes when the column is
+     * resized by the user.
+     * @param expand - %TRUE if the column should expand to fill available space.
+     */
     setExpand(expand) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_expand", [
             {
@@ -460,6 +662,20 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If `fixed_width` is not -1, sets the fixed width of @tree_column; otherwise
+     * unsets it.  The effective value of `fixed_width` is clamped between the
+     * minimum and maximum width of the column; however, the value stored in the
+     * “fixed-width” property is not clamped.  If the column sizing is
+     * %GTK_TREE_VIEW_COLUMN_GROW_ONLY or %GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting
+     * a fixed width overrides the automatically calculated width.  Note that
+     * `fixed_width` is only a hint to GTK; the width actually allocated to the
+     * column may be greater or less than requested.
+     *
+     * Along with “expand”, the “fixed-width” property changes when the column is
+     * resized by the user.
+     * @param fixedWidth - The new fixed width, in pixels, or -1.
+     */
     setFixedWidth(fixedWidth) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_fixed_width", [
             {
@@ -472,6 +688,13 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the maximum width of the @tree_column.  If `max_width` is -1, then the
+     * maximum width is unset.  Note, the column can actually be wider than max
+     * width if it’s the last column in a view.  In this case, the column expands to
+     * fill any extra space.
+     * @param maxWidth - The maximum width of the column in pixels, or -1.
+     */
     setMaxWidth(maxWidth) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_max_width", [
             {
@@ -484,6 +707,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the minimum width of the @tree_column.  If `min_width` is -1, then the
+     * minimum width is unset.
+     * @param minWidth - The minimum width of the column in pixels, or -1.
+     */
     setMinWidth(minWidth) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_min_width", [
             {
@@ -496,6 +724,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If `reorderable` is %TRUE, then the column can be reordered by the end user
+     * dragging the header.
+     * @param reorderable - %TRUE, if the column can be reordered.
+     */
     setReorderable(reorderable) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_reorderable", [
             {
@@ -508,6 +741,15 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If `resizable` is %TRUE, then the user can explicitly resize the column by
+     * grabbing the outer edge of the column button.
+     *
+     * If resizable is %TRUE and
+     * sizing mode of the column is %GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
+     * mode is changed to %GTK_TREE_VIEW_COLUMN_GROW_ONLY.
+     * @param resizable - %TRUE, if the column can be resized
+     */
     setResizable(resizable) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_resizable", [
             {
@@ -520,6 +762,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the growth behavior of `tree_column` to @type.
+     * @param type - The `GtkTreeViewColumn`Sizing.
+     */
     setSizing(type) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_sizing", [
             {
@@ -532,6 +778,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the logical `sort_column_id` that this column sorts on when this column
+     * is selected for sorting.  Doing so makes the column header clickable.
+     * @param sortColumnId - The `sort_column_id` of the model to sort on.
+     */
     setSortColumnId(sortColumnId) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_sort_column_id", [
             {
@@ -544,6 +795,13 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Call this function with a `setting` of %TRUE to display an arrow in
+     * the header button indicating the column is sorted. Call
+     * gtk_tree_view_column_set_sort_order() to change the direction of
+     * the arrow.
+     * @param setting - %TRUE to display an indicator that the column is sorted
+     */
     setSortIndicator(setting) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_sort_indicator", [
             {
@@ -556,6 +814,20 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes the appearance of the sort indicator.
+     *
+     * This does not actually sort the model.  Use
+     * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
+     * support.  This function is primarily for custom sorting behavior, and should
+     * be used in conjunction with gtk_tree_sortable_set_sort_column_id() to do
+     * that. For custom models, the mechanism will vary.
+     *
+     * The sort indicator changes direction to indicate normal sort or reverse sort.
+     * Note that you must have the sort indicator enabled to see anything when
+     * calling this function; see gtk_tree_view_column_set_sort_indicator().
+     * @param order - sort order that the sort indicator should indicate
+     */
     setSortOrder(order) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_sort_order", [
             {
@@ -568,6 +840,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the spacing field of @tree_column, which is the number of pixels to
+     * place between cell renderers packed into it.
+     * @param spacing - distance between cell renderers in pixels.
+     */
     setSpacing(spacing) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_spacing", [
             {
@@ -580,6 +857,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the title of the @tree_column.  If a custom widget has been set, then
+     * this value is ignored.
+     * @param title - The title of the @tree_column.
+     */
     setTitle(title) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_title", [
             {
@@ -592,6 +874,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the visibility of @tree_column.
+     * @param visible - %TRUE if the `tree_column` is visible.
+     */
     setVisible(visible) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_visible", [
             {
@@ -604,6 +890,11 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the widget in the header to be @widget.  If widget is %NULL, then the
+     * header button is set with a `GtkLabel` set to the title of @tree_column.
+     * @param widget - A child `GtkWidget`
+     */
     setWidget(widget) {
         call("libgtk-4.so.1", "gtk_tree_view_column_set_widget", [
             {
@@ -617,6 +908,12 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the ID of the `buildable` object.
+     *
+     * `GtkBuilder` sets the name based on the ID attribute
+     * of the `<object>` tag used to construct the @buildable.
+     */
     getBuildableId() {
         return call("libgtk-4.so.1", "gtk_buildable_get_buildable_id", [
             {
@@ -625,6 +922,10 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns the underlying `GtkCellArea` which might be `cell_layout` if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+     * is used by @cell_layout.
+     */
     getArea() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_layout_get_area", [
             {
@@ -636,6 +937,9 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, CellArea);
     }
+    /**
+     * Returns the cell renderers which have been added to @cell_layout.
+     */
     getCells() {
         const ptrs = call("libgtk-4.so.1", "gtk_cell_layout_get_cells", [
             {
@@ -650,6 +954,13 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
         });
         return ptrs.map((ptr) => getObject(ptr, CellRenderer));
     }
+    /**
+     * Re-inserts `cell` at @position.
+     *
+     * Note that `cell` has already to be packed into `cell_layout` for this to function properly.
+     * @param cell - a `GtkCellRenderer` to reorder
+     * @param position - new position to insert `cell` at
+     */
     reorder(cell, position) {
         call("libgtk-4.so.1", "gtk_cell_layout_reorder", [
             {