@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/cell-area-context.js

@@ -2,6 +2,20 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellArea } from "./cell-area.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Stores geometrical information for a series of rows in a GtkCellArea
+ *
+ * The `GtkCellAreaContext` object is created by a given `GtkCellArea`
+ * implementation via its `GtkCellAreaClass.create_context()` virtual
+ * method and is used to store cell sizes and alignments for a series of
+ * `GtkTreeModel` rows that are requested and rendered in the same context.
+ *
+ * `GtkCellLayout` widgets can create any number of contexts in which to
+ * request and render groups of data rows. However, it’s important that the
+ * same context which was used to request sizes for a given `GtkTreeModel`
+ * row also be used for the same row when calling other `GtkCellArea` APIs
+ * such as gtk_cell_area_render() and gtk_cell_area_event().
+ */
 export class CellAreaContext extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -17,6 +31,20 @@ export class CellAreaContext extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Allocates a width and/or a height for all rows which are to be
+     * rendered with @context.
+     *
+     * Usually allocation is performed only horizontally or sometimes
+     * vertically since a group of rows are usually rendered side by
+     * side vertically or horizontally and share either the same width
+     * or the same height. Sometimes they are allocated in both horizontal
+     * and vertical orientations producing a homogeneous effect of the
+     * rows. This is generally the case for `GtkTreeView` when
+     * `GtkTreeView:fixed-height-mode` is enabled.
+     * @param width - the allocated width for all `GtkTreeModel` rows rendered
+     * @param height - the allocated height for all `GtkTreeModel` rows rendered
+     */
     allocate(width, height) {
         call("libgtk-4.so.1", "gtk_cell_area_context_allocate", [
             {
@@ -33,6 +61,15 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Fetches the current allocation size for @context.
+     *
+     * If the context was not allocated in width or height, or if the
+     * context was recently reset with gtk_cell_area_context_reset(),
+     * the returned value will be -1.
+     * @param width - location to store the allocated width
+     * @param height - location to store the allocated height
+     */
     getAllocation(width, height) {
         call("libgtk-4.so.1", "gtk_cell_area_context_get_allocation", [
             {
@@ -57,6 +94,18 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Fetches the `GtkCellArea` this `context` was created by.
+     *
+     * This is generally unneeded by layouting widgets; however,
+     * it is important for the context implementation itself to
+     * fetch information about the area it is being used for.
+     *
+     * For instance at `GtkCellAreaContextClass.allocate()` time
+     * it’s important to know details about any cell spacing
+     * that the `GtkCellArea` is configured with in order to
+     * compute a proper allocation.
+     */
     getArea() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_context_get_area", [
             {
@@ -66,6 +115,15 @@ export class CellAreaContext extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, CellArea);
     }
+    /**
+     * Gets the accumulative preferred height for all rows which have been
+     * requested with this context.
+     *
+     * After gtk_cell_area_context_reset() is called and/or before ever
+     * requesting the size of a `GtkCellArea`, the returned values are 0.
+     * @param minimumHeight - location to store the minimum height
+     * @param naturalHeight - location to store the natural height
+     */
     getPreferredHeight(minimumHeight, naturalHeight) {
         call("libgtk-4.so.1", "gtk_cell_area_context_get_preferred_height", [
             {
@@ -90,6 +148,16 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the accumulative preferred height for `width` for all rows
+     * which have been requested for the same said `width` with this context.
+     *
+     * After gtk_cell_area_context_reset() is called and/or before ever
+     * requesting the size of a `GtkCellArea`, the returned values are -1.
+     * @param width - a proposed width for allocation
+     * @param minimumHeight - location to store the minimum height
+     * @param naturalHeight - location to store the natural height
+     */
     getPreferredHeightForWidth(width, minimumHeight, naturalHeight) {
         call("libgtk-4.so.1", "gtk_cell_area_context_get_preferred_height_for_width", [
             {
@@ -118,6 +186,15 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the accumulative preferred width for all rows which have been
+     * requested with this context.
+     *
+     * After gtk_cell_area_context_reset() is called and/or before ever
+     * requesting the size of a `GtkCellArea`, the returned values are 0.
+     * @param minimumWidth - location to store the minimum width
+     * @param naturalWidth - location to store the natural width
+     */
     getPreferredWidth(minimumWidth, naturalWidth) {
         call("libgtk-4.so.1", "gtk_cell_area_context_get_preferred_width", [
             {
@@ -142,6 +219,16 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the accumulative preferred width for `height` for all rows which
+     * have been requested for the same said `height` with this context.
+     *
+     * After gtk_cell_area_context_reset() is called and/or before ever
+     * requesting the size of a `GtkCellArea`, the returned values are -1.
+     * @param height - a proposed height for allocation
+     * @param minimumWidth - location to store the minimum width
+     * @param naturalWidth - location to store the natural width
+     */
     getPreferredWidthForHeight(height, minimumWidth, naturalWidth) {
         call("libgtk-4.so.1", "gtk_cell_area_context_get_preferred_width_for_height", [
             {
@@ -170,6 +257,17 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Causes the minimum and/or natural height to grow if the new
+     * proposed sizes exceed the current minimum and natural height.
+     *
+     * This is used by `GtkCellAreaContext` implementations during
+     * the request process over a series of `GtkTreeModel` rows to
+     * progressively push the requested height over a series of
+     * gtk_cell_area_get_preferred_height() requests.
+     * @param minimumHeight - the proposed new minimum height for @context
+     * @param naturalHeight - the proposed new natural height for @context
+     */
     pushPreferredHeight(minimumHeight, naturalHeight) {
         call("libgtk-4.so.1", "gtk_cell_area_context_push_preferred_height", [
             {
@@ -186,6 +284,17 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Causes the minimum and/or natural width to grow if the new
+     * proposed sizes exceed the current minimum and natural width.
+     *
+     * This is used by `GtkCellAreaContext` implementations during
+     * the request process over a series of `GtkTreeModel` rows to
+     * progressively push the requested width over a series of
+     * gtk_cell_area_get_preferred_width() requests.
+     * @param minimumWidth - the proposed new minimum width for @context
+     * @param naturalWidth - the proposed new natural width for @context
+     */
     pushPreferredWidth(minimumWidth, naturalWidth) {
         call("libgtk-4.so.1", "gtk_cell_area_context_push_preferred_width", [
             {
@@ -202,6 +311,30 @@ export class CellAreaContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Resets any previously cached request and allocation
+     * data.
+     *
+     * When underlying `GtkTreeModel` data changes its
+     * important to reset the context if the content
+     * size is allowed to shrink. If the content size
+     * is only allowed to grow (this is usually an option
+     * for views rendering large data stores as a measure
+     * of optimization), then only the row that changed
+     * or was inserted needs to be (re)requested with
+     * gtk_cell_area_get_preferred_width().
+     *
+     * When the new overall size of the context requires
+     * that the allocated size changes (or whenever this
+     * allocation changes at all), the variable row
+     * sizes need to be re-requested for every row.
+     *
+     * For instance, if the rows are displayed all with
+     * the same width from top to bottom then a change
+     * in the allocated width necessitates a recalculation
+     * of all the displayed row heights using
+     * gtk_cell_area_get_preferred_height_for_width().
+     */
     reset() {
         call("libgtk-4.so.1", "gtk_cell_area_context_reset", [
             {

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

@@ -12,54 +12,453 @@ import * as Gdk from "../gdk/index.js";
 export declare class CellArea extends GObject.InitiallyUnowned {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Activates @area, usually by activating the currently focused
+     * cell, however some subclasses which embed widgets in the area
+     * can also activate a widget if it currently has the focus.
+     * @param context - the `GtkCellArea`Context in context with the current row data
+     * @param widget - the `GtkWidget` that `area` is rendering on
+     * @param cellArea - the size and location of `area` relative to @widget’s allocation
+     * @param flags - the `GtkCellRenderer`State flags for `area` for this row of data.
+     * @param editOnly - if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE
+     */
     activate(context: CellAreaContext, widget: Widget, cellArea: Gdk.Rectangle, flags: CellRendererState, editOnly: boolean): boolean;
+    /**
+     * This is used by `GtkCellArea` subclasses when handling events
+     * to activate cells, the base `GtkCellArea` class activates cells
+     * for keyboard events for free in its own GtkCellArea->activate()
+     * implementation.
+     * @param widget - the `GtkWidget` that `area` is rendering onto
+     * @param renderer - the `GtkCellRenderer` in `area` to activate
+     * @param event - the `GdkEvent` for which cell activation should occur
+     * @param cellArea - the `GdkRectangle` in `widget` relative coordinates
+     * @param flags - the `GtkCellRenderer`State for @renderer
+     */
     activateCell(widget: Widget, renderer: CellRenderer, event: Gdk.Event, cellArea: Gdk.Rectangle, flags: CellRendererState): boolean;
+    /**
+     * Adds `renderer` to `area` with the default child cell properties.
+     * @param renderer - the `GtkCellRenderer` to add to @area
+     */
     add(renderer: CellRenderer): void;
+    /**
+     * Adds `sibling` to @renderer’s focusable area, focus will be drawn
+     * around `renderer` and all of its siblings if `renderer` can
+     * focus for a given row.
+     *
+     * Events handled by focus siblings can also activate the given
+     * focusable @renderer.
+     * @param renderer - the `GtkCellRenderer` expected to have focus
+     * @param sibling - the `GtkCellRenderer` to add to @renderer’s focus area
+     */
     addFocusSibling(renderer: CellRenderer, sibling: CellRenderer): void;
+    /**
+     * Applies any connected attributes to the renderers in
+     * `area` by pulling the values from @tree_model.
+     * @param treeModel - the `GtkTreeModel` to pull values from
+     * @param iter - the `GtkTreeIter` in `tree_model` to apply values for
+     * @param isExpander - whether `iter` has children
+     * @param isExpanded - whether `iter` is expanded in the view and
+     */
     applyAttributes(treeModel: TreeModel, iter: TreeIter, isExpander: boolean, isExpanded: boolean): void;
+    /**
+     * Connects an `attribute` to apply values from `column` for the
+     * `GtkTreeModel` in use.
+     * @param renderer - the `GtkCellRenderer` to connect an attribute for
+     * @param attribute - the attribute name
+     * @param column - the `GtkTreeModel` column to fetch attribute values from
+     */
     attributeConnect(renderer: CellRenderer, attribute: string, column: number): void;
+    /**
+     * Disconnects `attribute` for the `renderer` in `area` so that
+     * attribute will no longer be updated with values from the
+     * model.
+     * @param renderer - the `GtkCellRenderer` to disconnect an attribute for
+     * @param attribute - the attribute name
+     */
     attributeDisconnect(renderer: CellRenderer, attribute: string): void;
+    /**
+     * Returns the model column that an attribute has been mapped to,
+     * or -1 if the attribute is not mapped.
+     * @param renderer - a `GtkCellRenderer`
+     * @param attribute - an attribute on the renderer
+     */
     attributeGetColumn(renderer: CellRenderer, attribute: string): number;
+    /**
+     * Gets the value of a cell property for `renderer` in @area.
+     * @param renderer - a `GtkCellRenderer` inside @area
+     * @param propertyName - the name of the property to get
+     * @param value - a location to return the value
+     */
     cellGetProperty(renderer: CellRenderer, propertyName: string, value: GObject.Value): void;
+    /**
+     * Sets a cell property for `renderer` in @area.
+     * @param renderer - a `GtkCellRenderer` inside @area
+     * @param propertyName - the name of the cell property to set
+     * @param value - the value to set the cell property to
+     */
     cellSetProperty(renderer: CellRenderer, propertyName: string, value: GObject.Value): void;
+    /**
+     * This is sometimes needed for cases where rows need to share
+     * alignments in one orientation but may be separately grouped
+     * in the opposing orientation.
+     *
+     * For instance, `GtkIconView` creates all icons (rows) to have
+     * the same width and the cells theirin to have the same
+     * horizontal alignments. However each row of icons may have
+     * a separate collective height. `GtkIconView` uses this to
+     * request the heights of each row based on a context which
+     * was already used to request all the row widths that are
+     * to be displayed.
+     * @param context - the `GtkCellArea`Context to copy
+     */
     copyContext(context: CellAreaContext): CellAreaContext;
+    /**
+     * Creates a `GtkCellArea`Context to be used with `area` for
+     * all purposes. `GtkCellArea`Context stores geometry information
+     * for rows for which it was operated on, it is important to use
+     * the same context for the same row of data at all times (i.e.
+     * one should render and handle events with the same `GtkCellArea`Context
+     * which was used to request the size of those rows of data).
+     */
     createContext(): CellAreaContext;
+    /**
+     * Delegates event handling to a `GtkCellArea`.
+     * @param context - the `GtkCellArea`Context for this row of data.
+     * @param widget - the `GtkWidget` that `area` is rendering to
+     * @param event - the `GdkEvent` to handle
+     * @param cellArea - the `widget` relative coordinates for @area
+     * @param flags - the `GtkCellRenderer`State for `area` in this row.
+     */
     event(context: CellAreaContext, widget: Widget, event: Gdk.Event, cellArea: Gdk.Rectangle, flags: CellRendererState): number;
+    /**
+     * This should be called by the @area’s owning layout widget
+     * when focus is to be passed to @area, or moved within `area` for a given `direction` and row data.
+     *
+     * Implementing `GtkCellArea` classes should implement this
+     * method to receive and navigate focus in its own way particular
+     * to how it lays out cells.
+     * @param direction - the `GtkDirectionType`
+     */
     focus(direction: DirectionType): boolean;
+    /**
+     * Calls `callback` for every `GtkCellRenderer` in @area.
+     * @param callback - the `GtkCellCallback` to call
+     * @param callbackData - user provided data pointer
+     */
     foreach(callback: (...args: unknown[]) => unknown, callbackData?: number | null): void;
+    /**
+     * Calls `callback` for every `GtkCellRenderer` in `area` with the
+     * allocated rectangle inside @cell_area.
+     * @param context - the `GtkCellArea`Context for this row of data.
+     * @param widget - the `GtkWidget` that `area` is rendering to
+     * @param cellArea - the `widget` relative coordinates and size for @area
+     * @param backgroundArea - the `widget` relative coordinates of the background area
+     * @param callback - the `GtkCellAllocCallback` to call
+     * @param callbackData - user provided data pointer
+     */
     foreachAlloc(context: CellAreaContext, widget: Widget, cellArea: Gdk.Rectangle, backgroundArea: Gdk.Rectangle, callback: (...args: unknown[]) => unknown, callbackData?: number | null): void;
+    /**
+     * Derives the allocation of `renderer` inside `area` if `area` were to be rendered in @cell_area.
+     * @param context - the `GtkCellArea`Context used to hold sizes for @area.
+     * @param widget - the `GtkWidget` that `area` is rendering on
+     * @param renderer - the `GtkCellRenderer` to get the allocation for
+     * @param cellArea - the whole allocated area for `area` in `widget`             for this row
+     * @param allocation - where to store the allocation for @renderer
+     */
     getCellAllocation(context: CellAreaContext, widget: Widget, renderer: CellRenderer, cellArea: Gdk.Rectangle, allocation: Ref<Gdk.Rectangle>): void;
+    /**
+     * Gets the `GtkCellRenderer` at `x` and `y` coordinates inside `area` and optionally
+     * returns the full cell allocation for it inside @cell_area.
+     * @param context - the `GtkCellArea`Context used to hold sizes for @area.
+     * @param widget - the `GtkWidget` that `area` is rendering on
+     * @param cellArea - the whole allocated area for `area` in `widget`   for this row
+     * @param x - the x position
+     * @param y - the y position
+     * @param allocArea - where to store the inner allocated area of the
+     */
     getCellAtPosition(context: CellAreaContext, widget: Widget, cellArea: Gdk.Rectangle, x: number, y: number, allocArea?: Ref<Gdk.Rectangle> | null): CellRenderer;
+    /**
+     * Gets the current `GtkTreePath` string for the currently
+     * applied `GtkTreeIter`, this is implicitly updated when
+     * gtk_cell_area_apply_attributes() is called and can be
+     * used to interact with renderers from `GtkCellArea`
+     * subclasses.
+     */
     getCurrentPathString(): string;
+    /**
+     * Gets the `GtkCellEditable` widget currently used
+     * to edit the currently edited cell.
+     */
     getEditWidget(): CellEditable | null;
+    /**
+     * Gets the `GtkCellRenderer` in `area` that is currently
+     * being edited.
+     */
     getEditedCell(): CellRenderer | null;
+    /**
+     * Retrieves the currently focused cell for @area
+     */
     getFocusCell(): CellRenderer | null;
+    /**
+     * Gets the `GtkCellRenderer` which is expected to be focusable
+     * for which `renderer` is, or may be a sibling.
+     *
+     * This is handy for `GtkCellArea` subclasses when handling events,
+     * after determining the renderer at the event location it can
+     * then chose to activate the focus cell for which the event
+     * cell may have been a sibling.
+     * @param renderer - the `GtkCellRenderer`
+     */
     getFocusFromSibling(renderer: CellRenderer): CellRenderer | null;
+    /**
+     * Gets the focus sibling cell renderers for @renderer.
+     * @param renderer - the `GtkCellRenderer` expected to have focus
+     */
     getFocusSiblings(renderer: CellRenderer): CellRenderer[];
+    /**
+     * Retrieves a cell area’s initial minimum and natural height.
+     *
+     * `area` will store some geometrical information in `context` along the way;
+     * when requesting sizes over an arbitrary number of rows, it’s not important
+     * to check the `minimum_height` and `natural_height` of this call but rather to
+     * consult gtk_cell_area_context_get_preferred_height() after a series of
+     * requests.
+     * @param context - the `GtkCellArea`Context to perform this request with
+     * @param widget - the `GtkWidget` where `area` will be rendering
+     * @param minimumHeight - location to store the minimum height
+     * @param naturalHeight - location to store the natural height
+     */
     getPreferredHeight(context: CellAreaContext, widget: Widget, minimumHeight?: Ref<number> | null, naturalHeight?: Ref<number> | null): void;
+    /**
+     * Retrieves a cell area’s minimum and natural height if it would be given
+     * the specified @width.
+     *
+     * `area` stores some geometrical information in `context` along the way
+     * while calling gtk_cell_area_get_preferred_width(). It’s important to
+     * perform a series of gtk_cell_area_get_preferred_width() requests with
+     * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
+     * on each cell area individually to get the height for width of each
+     * fully requested row.
+     *
+     * If at some point, the width of a single row changes, it should be
+     * requested with gtk_cell_area_get_preferred_width() again and then
+     * the full width of the requested rows checked again with
+     * gtk_cell_area_context_get_preferred_width().
+     * @param context - the `GtkCellArea`Context which has already been requested for widths.
+     * @param widget - the `GtkWidget` where `area` will be rendering
+     * @param width - the width for which to check the height of this area
+     * @param minimumHeight - location to store the minimum height
+     * @param naturalHeight - location to store the natural height
+     */
     getPreferredHeightForWidth(context: CellAreaContext, widget: Widget, width: number, minimumHeight?: Ref<number> | null, naturalHeight?: Ref<number> | null): void;
+    /**
+     * Retrieves a cell area’s initial minimum and natural width.
+     *
+     * `area` will store some geometrical information in `context` along the way;
+     * when requesting sizes over an arbitrary number of rows, it’s not important
+     * to check the `minimum_width` and `natural_width` of this call but rather to
+     * consult gtk_cell_area_context_get_preferred_width() after a series of
+     * requests.
+     * @param context - the `GtkCellArea`Context to perform this request with
+     * @param widget - the `GtkWidget` where `area` will be rendering
+     * @param minimumWidth - location to store the minimum width
+     * @param naturalWidth - location to store the natural width
+     */
     getPreferredWidth(context: CellAreaContext, widget: Widget, minimumWidth?: Ref<number> | null, naturalWidth?: Ref<number> | null): void;
+    /**
+     * Retrieves a cell area’s minimum and natural width if it would be given
+     * the specified @height.
+     *
+     * `area` stores some geometrical information in `context` along the way
+     * while calling gtk_cell_area_get_preferred_height(). It’s important to
+     * perform a series of gtk_cell_area_get_preferred_height() requests with
+     * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
+     * on each cell area individually to get the height for width of each
+     * fully requested row.
+     *
+     * If at some point, the height of a single row changes, it should be
+     * requested with gtk_cell_area_get_preferred_height() again and then
+     * the full height of the requested rows checked again with
+     * gtk_cell_area_context_get_preferred_height().
+     * @param context - the `GtkCellArea`Context which has already been requested for widths.
+     * @param widget - the `GtkWidget` where `area` will be rendering
+     * @param height - the height for which to check the width of this area
+     * @param minimumWidth - location to store the minimum width
+     * @param naturalWidth - location to store the natural width
+     */
     getPreferredWidthForHeight(context: CellAreaContext, widget: Widget, height: number, minimumWidth?: Ref<number> | null, naturalWidth?: Ref<number> | null): void;
+    /**
+     * Gets whether the area prefers a height-for-width layout
+     * or a width-for-height layout.
+     */
     getRequestMode(): SizeRequestMode;
+    /**
+     * Checks if `area` contains @renderer.
+     * @param renderer - the `GtkCellRenderer` to check
+     */
     hasRenderer(renderer: CellRenderer): boolean;
+    /**
+     * This is a convenience function for `GtkCellArea` implementations
+     * to get the inner area where a given `GtkCellRenderer` will be
+     * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
+     * @param widget - the `GtkWidget` that `area` is rendering onto
+     * @param cellArea - the `widget` relative coordinates where one of @area’s cells
+     * @param innerArea - the return location for the inner cell area
+     */
     innerCellArea(widget: Widget, cellArea: Gdk.Rectangle, innerArea: Ref<Gdk.Rectangle>): void;
+    /**
+     * Returns whether the area can do anything when activated,
+     * after applying new attributes to @area.
+     */
     isActivatable(): boolean;
+    /**
+     * Returns whether `sibling` is one of @renderer’s focus siblings
+     * (see gtk_cell_area_add_focus_sibling()).
+     * @param renderer - the `GtkCellRenderer` expected to have focus
+     * @param sibling - the `GtkCellRenderer` to check against @renderer’s sibling list
+     */
     isFocusSibling(renderer: CellRenderer, sibling: CellRenderer): boolean;
+    /**
+     * Removes `renderer` from @area.
+     * @param renderer - the `GtkCellRenderer` to remove from @area
+     */
     remove(renderer: CellRenderer): void;
+    /**
+     * Removes `sibling` from @renderer’s focus sibling list
+     * (see gtk_cell_area_add_focus_sibling()).
+     * @param renderer - the `GtkCellRenderer` expected to have focus
+     * @param sibling - the `GtkCellRenderer` to remove from @renderer’s focus area
+     */
     removeFocusSibling(renderer: CellRenderer, sibling: CellRenderer): void;
+    /**
+     * This is a convenience function for `GtkCellArea` implementations
+     * to request size for cell renderers. It’s important to use this
+     * function to request size and then use gtk_cell_area_inner_cell_area()
+     * at render and event time since this function will add padding
+     * around the cell for focus painting.
+     * @param renderer - the `GtkCellRenderer` to request size for
+     * @param orientation - the `GtkOrientation` in which to request size
+     * @param widget - the `GtkWidget` that `area` is rendering onto
+     * @param forSize - the allocation contextual size to request for, or -1 if
+     * @param minimumSize - location to store the minimum size
+     * @param naturalSize - location to store the natural size
+     */
     requestRenderer(renderer: CellRenderer, orientation: Orientation, widget: Widget, forSize: number, minimumSize?: Ref<number> | null, naturalSize?: Ref<number> | null): void;
+    /**
+     * Explicitly sets the currently focused cell to @renderer.
+     *
+     * This is generally called by implementations of
+     * `GtkCellAreaClass.focus()` or `GtkCellAreaClass.event()`,
+     * however it can also be used to implement functions such
+     * as gtk_tree_view_set_cursor_on_cell().
+     * @param renderer - the `GtkCellRenderer` to give focus to
+     */
     setFocusCell(renderer?: CellRenderer | null): void;
+    /**
+     * Snapshots @area’s cells according to @area’s layout onto at
+     * the given coordinates.
+     * @param context - the `GtkCellArea`Context for this row of data.
+     * @param widget - the `GtkWidget` that `area` is rendering to
+     * @param snapshot - the `GtkSnapshot` to draw to
+     * @param backgroundArea - the `widget` relative coordinates for @area’s background
+     * @param cellArea - the `widget` relative coordinates for @area
+     * @param flags - the `GtkCellRenderer`State for `area` in this row.
+     * @param paintFocus - whether `area` should paint focus on focused cells for focused rows or not.
+     */
     snapshot(context: CellAreaContext, widget: Widget, snapshot: Snapshot, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState, paintFocus: boolean): void;
+    /**
+     * Explicitly stops the editing of the currently edited cell.
+     *
+     * If `canceled` is %TRUE, the currently edited cell renderer
+     * will emit the ::editing-canceled signal, otherwise the
+     * the ::editing-done signal will be emitted on the current
+     * edit widget.
+     *
+     * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
+     * @param canceled - whether editing was canceled.
+     */
     stopEditing(canceled: boolean): void;
+    /**
+     * 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(): string | null;
+    /**
+     * 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;
     connect(signal: "add-editable", handler: (self: CellArea, renderer: CellRenderer, editable: CellEditable, cellArea: Gdk.Rectangle, path: string) => void, after?: boolean): number;
     connect(signal: "apply-attributes", handler: (self: CellArea, model: TreeModel, iter: TreeIter, isExpander: boolean, isExpanded: boolean) => void, after?: boolean): number;