@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/cell-renderer.js

@@ -2,6 +2,45 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellEditable } from "./cell-editable.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * An object for rendering a single cell
+ *
+ * The `GtkCellRenderer` is a base class of a set of objects used for
+ * rendering a cell to a `cairo_t`.  These objects are used primarily by
+ * the `GtkTreeView` widget, though they aren’t tied to them in any
+ * specific way.  It is worth noting that `GtkCellRenderer` is not a
+ * `GtkWidget` and cannot be treated as such.
+ *
+ * The primary use of a `GtkCellRenderer` is for drawing a certain graphical
+ * elements on a `cairo_t`. Typically, one cell renderer is used to
+ * draw many cells on the screen.  To this extent, it isn’t expected that a
+ * CellRenderer keep any permanent state around.  Instead, any state is set
+ * just prior to use using `GObject`s property system.  Then, the
+ * cell is measured using gtk_cell_renderer_get_preferred_size(). Finally, the cell
+ * is rendered in the correct location using gtk_cell_renderer_snapshot().
+ *
+ * There are a number of rules that must be followed when writing a new
+ * `GtkCellRenderer`.  First and foremost, it’s important that a certain set
+ * of properties will always yield a cell renderer of the same size,
+ * barring a style change. The `GtkCellRenderer` also has a number of
+ * generic properties that are expected to be honored by all children.
+ *
+ * Beyond merely rendering a cell, cell renderers can optionally
+ * provide active user interface elements. A cell renderer can be
+ * “activatable” like `GtkCellRenderer`Toggle,
+ * which toggles when it gets activated by a mouse click, or it can be
+ * “editable” like `GtkCellRenderer`Text, which
+ * allows the user to edit the text using a widget implementing the
+ * `GtkCellEditable` interface, e.g. `GtkEntry`.
+ * To make a cell renderer activatable or editable, you have to
+ * implement the `GtkCellRenderer`Class.activate or
+ * `GtkCellRenderer`Class.start_editing virtual functions, respectively.
+ *
+ * Many properties of `GtkCellRenderer` and its subclasses have a
+ * corresponding “set” property, e.g. “cell-background-set” corresponds
+ * to “cell-background”. These “set” properties reflect whether a property
+ * has been set or not. You should not set them independently.
+ */
 const SIGNAL_META = {
     "editing-canceled": { params: [], returnType: { type: "undefined" } },
     "editing-started": {
@@ -27,6 +66,17 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Passes an activate event to the cell renderer for possible processing.
+     * Some cell renderers may use events; for example, `GtkCellRendererToggle`
+     * toggles when it gets a mouse click.
+     * @param event - a `GdkEvent`
+     * @param widget - widget that received the event
+     * @param path - widget-dependent string representation of the event location;
+     * @param backgroundArea - background area as passed to gtk_cell_renderer_render()
+     * @param cellArea - cell area as passed to gtk_cell_renderer_render()
+     * @param flags - render flags
+     */
     activate(event, widget, path, backgroundArea, cellArea, flags) {
         return call("libgtk-4.so.1", "gtk_cell_renderer_activate", [
             {
@@ -69,6 +119,14 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the aligned area used by `cell` inside @cell_area. Used for finding
+     * the appropriate edit and focus rectangle.
+     * @param widget - the `GtkWidget` this cell will be rendering to
+     * @param flags - render flags
+     * @param cellArea - cell area which would be passed to gtk_cell_renderer_render()
+     * @param alignedArea - the return location for the space inside `cell_area`                that would actually be used to render.
+     */
     getAlignedArea(widget, flags, cellArea, alignedArea) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_aligned_area", [
             {
@@ -105,6 +163,11 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Fills in `xalign` and `yalign` with the appropriate values of @cell.
+     * @param xalign - location to fill in with the x alignment of the cell
+     * @param yalign - location to fill in with the y alignment of the cell
+     */
     getAlignment(xalign, yalign) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_alignment", [
             {
@@ -123,6 +186,11 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Fills in `width` and `height` with the appropriate size of @cell.
+     * @param width - location to fill in with the fixed width of the cell
+     * @param height - location to fill in with the fixed height of the cell
+     */
     getFixedSize(width, height) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_fixed_size", [
             {
@@ -147,6 +215,9 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks whether the given `GtkCellRenderer` is expanded.
+     */
     getIsExpanded() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_get_is_expanded", [
             {
@@ -155,6 +226,9 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the given `GtkCellRenderer` is an expander.
+     */
     getIsExpander() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_get_is_expander", [
             {
@@ -163,6 +237,11 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Fills in `xpad` and `ypad` with the appropriate values of @cell.
+     * @param xpad - location to fill in with the x padding of the cell
+     * @param ypad - location to fill in with the y padding of the cell
+     */
     getPadding(xpad, ypad) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_padding", [
             {
@@ -187,6 +266,12 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves a renderer’s natural size when rendered to @widget.
+     * @param widget - the `GtkWidget` this cell will be rendering to
+     * @param minimumSize - location to store the minimum size
+     * @param naturalSize - location to store the natural size
+     */
     getPreferredHeight(widget, minimumSize, naturalSize) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_preferred_height", [
             {
@@ -215,6 +300,14 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves a cell renderers’s minimum and natural height if it were rendered to
+     * `widget` with the specified @width.
+     * @param widget - the `GtkWidget` this cell will be rendering to
+     * @param width - the size which is available for allocation
+     * @param minimumHeight - location for storing the minimum size
+     * @param naturalHeight - location for storing the preferred size
+     */
     getPreferredHeightForWidth(widget, width, minimumHeight, naturalHeight) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_preferred_height_for_width", [
             {
@@ -247,6 +340,13 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the minimum and natural size of a cell taking
+     * into account the widget’s preference for height-for-width management.
+     * @param widget - the `GtkWidget` this cell will be rendering to
+     * @param minimumSize - location for storing the minimum size
+     * @param naturalSize - location for storing the natural size
+     */
     getPreferredSize(widget, minimumSize, naturalSize) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_preferred_size", [
             {
@@ -283,6 +383,12 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves a renderer’s natural size when rendered to @widget.
+     * @param widget - the `GtkWidget` this cell will be rendering to
+     * @param minimumSize - location to store the minimum size
+     * @param naturalSize - location to store the natural size
+     */
     getPreferredWidth(widget, minimumSize, naturalSize) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_preferred_width", [
             {
@@ -311,6 +417,14 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves a cell renderers’s minimum and natural width if it were rendered to
+     * `widget` with the specified @height.
+     * @param widget - the `GtkWidget` this cell will be rendering to
+     * @param height - the size which is available for allocation
+     * @param minimumWidth - location for storing the minimum size
+     * @param naturalWidth - location for storing the preferred size
+     */
     getPreferredWidthForHeight(widget, height, minimumWidth, naturalWidth) {
         call("libgtk-4.so.1", "gtk_cell_renderer_get_preferred_width_for_height", [
             {
@@ -343,6 +457,10 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets whether the cell renderer prefers a height-for-width layout
+     * or a width-for-height layout.
+     */
     getRequestMode() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_get_request_mode", [
             {
@@ -351,6 +469,9 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the cell renderer’s sensitivity.
+     */
     getSensitive() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_get_sensitive", [
             {
@@ -359,6 +480,13 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Translates the cell renderer state to `GtkStateFlags`,
+     * based on the cell renderer and widget sensitivity, and
+     * the given `GtkCellRenderer`State.
+     * @param widget - a `GtkWidget`
+     * @param cellState - cell renderer state
+     */
     getState(cellState, widget) {
         return call("libgtk-4.so.1", "gtk_cell_renderer_get_state", [
             {
@@ -376,6 +504,9 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the cell renderer’s visibility.
+     */
     getVisible() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_get_visible", [
             {
@@ -384,6 +515,9 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the cell renderer can do something when activated.
+     */
     isActivatable() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_is_activatable", [
             {
@@ -392,6 +526,11 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets the renderer’s alignment within its available space.
+     * @param xalign - the x alignment of the cell renderer
+     * @param yalign - the y alignment of the cell renderer
+     */
     setAlignment(xalign, yalign) {
         call("libgtk-4.so.1", "gtk_cell_renderer_set_alignment", [
             {
@@ -408,6 +547,11 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the renderer size to be explicit, independent of the properties set.
+     * @param width - the width of the cell renderer, or -1
+     * @param height - the height of the cell renderer, or -1
+     */
     setFixedSize(width, height) {
         call("libgtk-4.so.1", "gtk_cell_renderer_set_fixed_size", [
             {
@@ -424,6 +568,10 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the given `GtkCellRenderer` is expanded.
+     * @param isExpanded - whether `cell` should be expanded
+     */
     setIsExpanded(isExpanded) {
         call("libgtk-4.so.1", "gtk_cell_renderer_set_is_expanded", [
             {
@@ -436,6 +584,10 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the given `GtkCellRenderer` is an expander.
+     * @param isExpander - whether `cell` is an expander
+     */
     setIsExpander(isExpander) {
         call("libgtk-4.so.1", "gtk_cell_renderer_set_is_expander", [
             {
@@ -448,6 +600,11 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the renderer’s padding.
+     * @param xpad - the x padding of the cell renderer
+     * @param ypad - the y padding of the cell renderer
+     */
     setPadding(xpad, ypad) {
         call("libgtk-4.so.1", "gtk_cell_renderer_set_padding", [
             {
@@ -464,6 +621,10 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the cell renderer’s sensitivity.
+     * @param sensitive - the sensitivity of the cell
+     */
     setSensitive(sensitive) {
         call("libgtk-4.so.1", "gtk_cell_renderer_set_sensitive", [
             {
@@ -476,6 +637,10 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the cell renderer’s visibility.
+     * @param visible - the visibility of the cell
+     */
     setVisible(visible) {
         call("libgtk-4.so.1", "gtk_cell_renderer_set_visible", [
             {
@@ -488,6 +653,20 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Invokes the virtual render function of the `GtkCellRenderer`. The three
+     * passed-in rectangles are areas in @cr. Most renderers will draw within
+     * @cell_area; the xalign, yalign, xpad, and ypad fields of the `GtkCellRenderer`
+     * should be honored with respect to @cell_area. `background_area` includes the
+     * blank space around the cell, and also the area containing the tree expander;
+     * so the `background_area` rectangles for all cells tile to cover the entire
+     * @window.
+     * @param snapshot - a `GtkSnapshot` to draw to
+     * @param widget - the widget owning @window
+     * @param backgroundArea - entire cell area (including tree expanders and maybe
+     * @param cellArea - area normally rendered by a cell renderer
+     * @param flags - flags that affect rendering
+     */
     snapshot(snapshot, widget, backgroundArea, cellArea, flags) {
         call("libgtk-4.so.1", "gtk_cell_renderer_snapshot", [
             {
@@ -526,6 +705,16 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Starts editing the contents of this @cell, through a new `GtkCellEditable`
+     * widget created by the `GtkCellRenderer`Class.start_editing virtual function.
+     * @param event - a `GdkEvent`
+     * @param widget - widget that received the event
+     * @param path - widget-dependent string representation of the event location;
+     * @param backgroundArea - background area as passed to gtk_cell_renderer_render()
+     * @param cellArea - cell area as passed to gtk_cell_renderer_render()
+     * @param flags - render flags
+     */
     startEditing(widget, path, backgroundArea, cellArea, flags, event) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_renderer_start_editing", [
             {
@@ -572,6 +761,16 @@ export class CellRenderer extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, CellEditable);
     }
+    /**
+     * Informs the cell renderer that the editing is stopped.
+     * If `canceled` is %TRUE, the cell renderer will emit the
+     * `GtkCellRenderer`::editing-canceled signal.
+     *
+     * This function should be called by cell renderer implementations
+     * in response to the `GtkCellEditable::editing-done` signal of
+     * `GtkCellEditable`.
+     * @param canceled - %TRUE if the editing has been canceled
+     */
     stopEditing(canceled) {
         call("libgtk-4.so.1", "gtk_cell_renderer_stop_editing", [
             {

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

@@ -7,31 +7,202 @@ import { TreeModel } from "./tree-model.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
+/**
+ * A widget displaying a single row of a GtkTreeModel
+ *
+ * A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
+ * and `GtkCellAreaContext`. A `GtkCellAreaContext` can be provided to the
+ * `GtkCellView` at construction time in order to keep the cellview in context
+ * of a group of cell views, this ensures that the renderers displayed will
+ * be properly aligned with each other (like the aligned cells in the menus
+ * of `GtkComboBox`).
+ *
+ * `GtkCellView` is `GtkOrientable` in order to decide in which orientation
+ * the underlying `GtkCellAreaContext` should be allocated. Taking the `GtkComboBox`
+ * menu as an example, cellviews should be oriented horizontally if the menus are
+ * listed top-to-bottom and thus all share the same width but may have separate
+ * individual heights (left-to-right menus should be allocated vertically since
+ * they all share the same height but may have variable widths).
+ *
+ * ## CSS nodes
+ *
+ * GtkCellView has a single CSS node with name cellview.
+ */
 export declare class CellView extends Widget {
+    /**
+     * Creates a new `GtkCellView` widget.
+     */
     constructor(...args: unknown[]);
+    /**
+     * Creates a new `GtkCellView` widget with a specific `GtkCellArea`
+     * to layout cells and a specific `GtkCellAreaContext`.
+     *
+     * Specifying the same context for a handful of cells lets
+     * the underlying area synchronize the geometry for those cells,
+     * in this way alignments with cellviews for other rows are
+     * possible.
+     * @param area - the `GtkCellArea` to layout cells
+     * @param context - the `GtkCellAreaContext` in which to calculate cell geometry
+     */
     static viewNewWithContext(area: CellArea, context: CellAreaContext): CellView;
+    /**
+     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
+     * to it, and makes it show @markup. The text can be marked up with
+     * the Pango text markup language.
+     * @param markup - the text to display in the cell view
+     */
     static viewNewWithMarkup(markup: string): CellView;
+    /**
+     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
+     * to it, and makes it show @text.
+     * @param text - the text to display in the cell view
+     */
     static viewNewWithText(text: string): CellView;
+    /**
+     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererPixbuf`
+     * to it, and makes it show @texture.
+     * @param texture - the image to display in the cell view
+     */
     static viewNewWithTexture(texture: Gdk.Texture): CellView;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns a `GtkTreePath` referring to the currently
+     * displayed row. If no row is currently displayed,
+     * %NULL is returned.
+     */
     getDisplayedRow(): TreePath | null;
+    /**
+     * Gets whether `cell_view` is configured to draw all of its
+     * cells in a sensitive state.
+     */
     getDrawSensitive(): boolean;
+    /**
+     * Gets whether `cell_view` is configured to request space
+     * to fit the entire `GtkTreeModel`.
+     */
     getFitModel(): boolean;
+    /**
+     * Returns the model for @cell_view. If no model is used %NULL is
+     * returned.
+     */
     getModel(): TreeModel | null;
+    /**
+     * Sets the row of the model that is currently displayed
+     * by the `GtkCellView`. If the path is unset, then the
+     * contents of the cellview “stick” at their last value;
+     * this is not normally a desired result, but may be
+     * a needed intermediate state if say, the model for
+     * the `GtkCellView` becomes temporarily empty.
+     * @param path - a `GtkTreePath` or %NULL to unset.
+     */
     setDisplayedRow(path?: TreePath | null): void;
+    /**
+     * Sets whether `cell_view` should draw all of its
+     * cells in a sensitive state, this is used by `GtkComboBox` menus
+     * to ensure that rows with insensitive cells that contain
+     * children appear sensitive in the parent menu item.
+     * @param drawSensitive - whether to draw all cells in a sensitive state.
+     */
     setDrawSensitive(drawSensitive: boolean): void;
+    /**
+     * Sets whether `cell_view` should request space to fit the entire `GtkTreeModel`.
+     *
+     * This is used by `GtkComboBox` to ensure that the cell view displayed on
+     * the combo box’s button always gets enough space and does not resize
+     * when selection changes.
+     * @param fitModel - whether `cell_view` should request space for the whole model.
+     */
     setFitModel(fitModel: boolean): void;
+    /**
+     * Sets the model for @cell_view.  If `cell_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 - a `GtkTreeModel`
+     */
     setModel(model?: TreeModel | null): void;
+    /**
+     * Adds an attribute mapping to the list in @cell_layout.
+     *
+     * The `column` is the column of the model to get a value from, and the
+     * `attribute` is the property on `cell` to be set from that 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.
+     * In this context "attribute" and "property" are used interchangeably.
+     * @param cell - a `GtkCellRenderer`
+     * @param attribute - a property on the renderer
+     * @param column - the column position on the model to get the attribute from
+     */
     addAttribute(cell: CellRenderer, attribute: string, column: number): void;
+    /**
+     * Unsets all the mappings on all renderers on `cell_layout` and
+     * removes all renderers from @cell_layout.
+     */
     clear(): void;
+    /**
+     * Clears all existing attributes previously set with
+     * gtk_cell_layout_set_attributes().
+     * @param cell - a `GtkCellRenderer` to clear the attribute mapping on
+     */
     clearAttributes(cell: CellRenderer): void;
+    /**
+     * 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(): CellArea | null;
+    /**
+     * Returns the cell renderers which have been added to @cell_layout.
+     */
     getCells(): CellRenderer[];
+    /**
+     * Adds the `cell` to the end of @cell_layout. 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.
+     *
+     * Note that reusing the same cell renderer is not supported.
+     * @param cell - a `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @cell_layout
+     */
     packEnd(cell: CellRenderer, expand: boolean): void;
+    /**
+     * Packs the `cell` into the beginning of @cell_layout. 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.
+     *
+     * Note that reusing the same cell renderer is not supported.
+     * @param cell - a `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @cell_layout
+     */
     packStart(cell: CellRenderer, expand: boolean): void;
+    /**
+     * 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: CellRenderer, position: number): void;
+    /**
+     * Sets the `GtkCellLayout`DataFunc to use for @cell_layout.
+     *
+     * This function is used instead of the standard attributes mapping
+     * for setting the column value, and should set the value of @cell_layout’s
+     * cell renderer(s) as appropriate.
+     *
+     * `func` may be %NULL to remove a previously set function.
+     * @param cell - a `GtkCellRenderer`
+     * @param func - the `GtkCellLayout`DataFunc to use
+     * @param funcData - user data for @func
+     * @param destroy - destroy notify for @func_data
+     */
     setCellDataFunc(cell: CellRenderer, destroy: () => void, func?: (...args: unknown[]) => unknown | null, funcData?: number | null): void;
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation(): Orientation;
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation: Orientation): void;
     connect(signal: "notify", handler: (self: CellView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;