@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/cell-renderer-progress.d.ts

@@ -1,10 +1,26 @@
 import { Orientation } from "./enums.js";
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders numbers as progress bars
+ *
+ * `GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
+ * Additionally, it can display a text on top of the progress bar.
+ */
 export declare class CellRendererProgress extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererProgress`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * 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: CellRendererProgress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

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

@@ -1,7 +1,16 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders numbers as progress bars
+ *
+ * `GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
+ * Additionally, it can display a text on top of the progress bar.
+ */
 export class CellRendererProgress extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererProgress`.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -11,6 +20,9 @@ export class CellRendererProgress extends CellRenderer {
             borrowed: true,
         });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_orientable_get_orientation", [
             {
@@ -19,6 +31,10 @@ export class CellRendererProgress extends CellRenderer {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation) {
         call("libgtk-4.so.1", "gtk_orientable_set_orientation", [
             {

package/dist/generated/gtk/cell-renderer-spin.d.ts

@@ -1,6 +1,9 @@
 import * as GObject from "../gobject/index.js";
 import { CellRendererText } from "./cell-renderer-text.js";
 export declare class CellRendererSpin extends CellRendererText {
+    /**
+     * Creates a new `GtkCellRendererSpin`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "edited", handler: (self: CellRendererSpin, path: string, newText: string) => void, after?: boolean): number;

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

@@ -1,6 +1,21 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRendererText } from "./cell-renderer-text.js";
+/**
+ * Renders a spin button in a cell
+ *
+ * `GtkCellRendererSpin` renders text in a cell like `GtkCellRendererText` from
+ * which it is derived. But while `GtkCellRendererText` offers a simple entry to
+ * edit the text, `GtkCellRendererSpin` offers a `GtkSpinButton` widget. Of course,
+ * that means that the text has to be parseable as a floating point number.
+ *
+ * The range of the spinbutton is taken from the adjustment property of the
+ * cell renderer, which can be set explicitly or mapped to a column in the
+ * tree model, like all properties of cell renders. `GtkCellRendererSpin`
+ * also has properties for the `GtkCellRendererSpin:climb-rate` and the number
+ * of `GtkCellRendererSpin:digits` to display. Other `GtkSpinButton` properties
+ * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
+ */
 const SIGNAL_META = {
     edited: {
         params: [
@@ -11,6 +26,9 @@ const SIGNAL_META = {
     },
 };
 export class CellRendererSpin extends CellRendererText {
+    /**
+     * Creates a new `GtkCellRendererSpin`.
+     */
     constructor(...args) {
         super(...args);
     }

package/dist/generated/gtk/cell-renderer-spinner.d.ts

@@ -1,6 +1,24 @@
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders a spinning animation in a cell
+ *
+ * `GtkCellRendererSpinner` renders a spinning animation in a cell, very
+ * similar to `GtkSpinner`. It can often be used as an alternative
+ * to a `GtkCellRendererProgress` for displaying indefinite activity,
+ * instead of actual progress.
+ *
+ * To start the animation in a cell, set the `GtkCellRendererSpinner:active`
+ * property to %TRUE and increment the `GtkCellRendererSpinner:pulse` property
+ * at regular intervals. The usual way to set the cell renderer properties
+ * for each cell is to bind them to columns in your tree model using e.g.
+ * gtk_tree_view_column_add_attribute().
+ */
 export declare class CellRendererSpinner extends CellRenderer {
+    /**
+     * Returns a new cell renderer which will show a spinner to indicate
+     * activity.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "notify", handler: (self: CellRendererSpinner, pspec: GObject.ParamSpec) => void, after?: boolean): number;

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

@@ -1,7 +1,25 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders a spinning animation in a cell
+ *
+ * `GtkCellRendererSpinner` renders a spinning animation in a cell, very
+ * similar to `GtkSpinner`. It can often be used as an alternative
+ * to a `GtkCellRendererProgress` for displaying indefinite activity,
+ * instead of actual progress.
+ *
+ * To start the animation in a cell, set the `GtkCellRendererSpinner:active`
+ * property to %TRUE and increment the `GtkCellRendererSpinner:pulse` property
+ * at regular intervals. The usual way to set the cell renderer properties
+ * for each cell is to bind them to columns in your tree model using e.g.
+ * gtk_tree_view_column_add_attribute().
+ */
 export class CellRendererSpinner extends CellRenderer {
+    /**
+     * Returns a new cell renderer which will show a spinner to indicate
+     * activity.
+     */
     constructor(...args) {
         super(...args);
     }

package/dist/generated/gtk/cell-renderer-text.d.ts

@@ -1,8 +1,27 @@
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
 export declare class CellRendererText extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererText`. Adjust how text is drawn using
+     * object properties. Object properties can be
+     * set globally (with g_object_set()). Also, with `GtkTreeViewColumn`,
+     * you can bind a property to a value in a `GtkTreeModel`. For example,
+     * you can bind the “text” property on the cell renderer to a string
+     * value in the model, thus rendering a different string in each row
+     * of the `GtkTreeView`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Sets the height of a renderer to explicitly be determined by the “font” and
+     * “y_pad” property set on it.  Further changes in these properties do not
+     * affect the height, so they must be accompanied by a subsequent call to this
+     * function.  Using this function is inflexible, and should really only be used
+     * if calculating the size of a cell is too slow (ie, a massive number of cells
+     * displayed).  If `number_of_rows` is -1, then the fixed height is unset, and
+     * the height is determined by the properties again.
+     * @param numberOfRows - Number of rows of text each cell renderer is allocated, or -1
+     */
     setFixedHeightFromFont(numberOfRows: number): void;
     connect(signal: "edited", handler: (self: CellRendererText, path: string, newText: string) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellRendererText, pspec: GObject.ParamSpec) => void, after?: boolean): number;

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

@@ -1,6 +1,16 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders text in a cell
+ *
+ * A `GtkCellRendererText` renders a given text in its cell, using the font, color and
+ * style information provided by its properties. The text will be ellipsized if it is
+ * too long and the `GtkCellRendererText:ellipsize` property allows it.
+ *
+ * If the `GtkCellRenderer:mode` is %GTK_CELL_RENDERER_MODE_EDITABLE,
+ * the `GtkCellRendererText` allows to edit its text using an entry.
+ */
 const SIGNAL_META = {
     edited: {
         params: [
@@ -11,6 +21,15 @@ const SIGNAL_META = {
     },
 };
 export class CellRendererText extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererText`. Adjust how text is drawn using
+     * object properties. Object properties can be
+     * set globally (with g_object_set()). Also, with `GtkTreeViewColumn`,
+     * you can bind a property to a value in a `GtkTreeModel`. For example,
+     * you can bind the “text” property on the cell renderer to a string
+     * value in the model, thus rendering a different string in each row
+     * of the `GtkTreeView`.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -20,6 +39,16 @@ export class CellRendererText extends CellRenderer {
             borrowed: true,
         });
     }
+    /**
+     * Sets the height of a renderer to explicitly be determined by the “font” and
+     * “y_pad” property set on it.  Further changes in these properties do not
+     * affect the height, so they must be accompanied by a subsequent call to this
+     * function.  Using this function is inflexible, and should really only be used
+     * if calculating the size of a cell is too slow (ie, a massive number of cells
+     * displayed).  If `number_of_rows` is -1, then the fixed height is unset, and
+     * the height is determined by the properties again.
+     * @param numberOfRows - Number of rows of text each cell renderer is allocated, or -1
+     */
     setFixedHeightFromFont(numberOfRows) {
         call("libgtk-4.so.1", "gtk_cell_renderer_text_set_fixed_height_from_font", [
             {

package/dist/generated/gtk/cell-renderer-toggle.d.ts

@@ -1,13 +1,51 @@
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
 export declare class CellRendererToggle extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererToggle`. Adjust rendering
+     * parameters using object properties. Object properties can be set
+     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
+     * can bind a property to a value in a `GtkTreeModel`. For example, you
+     * can bind the “active” property on the cell renderer to a boolean value
+     * in the model, thus causing the check button to reflect the state of
+     * the model.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns whether the cell renderer is activatable. See
+     * gtk_cell_renderer_toggle_set_activatable().
+     */
     getActivatable(): boolean;
+    /**
+     * Returns whether the cell renderer is active. See
+     * gtk_cell_renderer_toggle_set_active().
+     */
     getActive(): boolean;
+    /**
+     * Returns whether we’re rendering radio toggles rather than checkboxes.
+     */
     getRadio(): boolean;
+    /**
+     * Makes the cell renderer activatable.
+     * @param setting - the value to set.
+     */
     setActivatable(setting: boolean): void;
+    /**
+     * Activates or deactivates a cell renderer.
+     * @param setting - the value to set.
+     */
     setActive(setting: boolean): void;
+    /**
+     * If `radio` is %TRUE, the cell renderer renders a radio toggle
+     * (i.e. a toggle in a group of mutually-exclusive toggles).
+     * If %FALSE, it renders a check toggle (a standalone boolean option).
+     * This can be set globally for the cell renderer, or changed just
+     * before rendering each cell in the model (for `GtkTreeView`, you set
+     * up a per-row setting using `GtkTreeViewColumn` to associate model
+     * columns with cell renderer properties).
+     * @param radio - %TRUE to make the toggle look like a radio button
+     */
     setRadio(radio: boolean): void;
     connect(signal: "toggled", handler: (self: CellRendererToggle, path: string) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellRendererToggle, pspec: GObject.ParamSpec) => void, after?: boolean): number;

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

@@ -1,6 +1,14 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders a toggle button in a cell
+ *
+ * `GtkCellRendererToggle` renders a toggle button in a cell. The
+ * button is drawn as a radio or a checkbutton, depending on the
+ * `GtkCellRendererToggle:radio` property.
+ * When activated, it emits the `GtkCellRendererToggle::toggled` signal.
+ */
 const SIGNAL_META = {
     toggled: {
         params: [{ type: { type: "string", borrowed: false } }],
@@ -8,6 +16,15 @@ const SIGNAL_META = {
     },
 };
 export class CellRendererToggle extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererToggle`. Adjust rendering
+     * parameters using object properties. Object properties can be set
+     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
+     * can bind a property to a value in a `GtkTreeModel`. For example, you
+     * can bind the “active” property on the cell renderer to a boolean value
+     * in the model, thus causing the check button to reflect the state of
+     * the model.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -17,6 +34,10 @@ export class CellRendererToggle extends CellRenderer {
             borrowed: true,
         });
     }
+    /**
+     * Returns whether the cell renderer is activatable. See
+     * gtk_cell_renderer_toggle_set_activatable().
+     */
     getActivatable() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_toggle_get_activatable", [
             {
@@ -25,6 +46,10 @@ export class CellRendererToggle extends CellRenderer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the cell renderer is active. See
+     * gtk_cell_renderer_toggle_set_active().
+     */
     getActive() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_toggle_get_active", [
             {
@@ -33,6 +58,9 @@ export class CellRendererToggle extends CellRenderer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether we’re rendering radio toggles rather than checkboxes.
+     */
     getRadio() {
         return call("libgtk-4.so.1", "gtk_cell_renderer_toggle_get_radio", [
             {
@@ -41,6 +69,10 @@ export class CellRendererToggle extends CellRenderer {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Makes the cell renderer activatable.
+     * @param setting - the value to set.
+     */
     setActivatable(setting) {
         call("libgtk-4.so.1", "gtk_cell_renderer_toggle_set_activatable", [
             {
@@ -53,6 +85,10 @@ export class CellRendererToggle extends CellRenderer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Activates or deactivates a cell renderer.
+     * @param setting - the value to set.
+     */
     setActive(setting) {
         call("libgtk-4.so.1", "gtk_cell_renderer_toggle_set_active", [
             {
@@ -65,6 +101,16 @@ export class CellRendererToggle extends CellRenderer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If `radio` is %TRUE, the cell renderer renders a radio toggle
+     * (i.e. a toggle in a group of mutually-exclusive toggles).
+     * If %FALSE, it renders a check toggle (a standalone boolean option).
+     * This can be set globally for the cell renderer, or changed just
+     * before rendering each cell in the model (for `GtkTreeView`, you set
+     * up a per-row setting using `GtkTreeViewColumn` to associate model
+     * columns with cell renderer properties).
+     * @param radio - %TRUE to make the toggle look like a radio button
+     */
     setRadio(radio) {
         call("libgtk-4.so.1", "gtk_cell_renderer_toggle_set_radio", [
             {

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

@@ -9,32 +9,192 @@ import * as Gdk from "../gdk/index.js";
 export declare class CellRenderer extends GObject.InitiallyUnowned {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * 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: Gdk.Event, widget: Widget, path: string, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState): 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: Widget, flags: CellRendererState, cellArea: Gdk.Rectangle, alignedArea: Ref<Gdk.Rectangle>): void;
+    /**
+     * 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?: Ref<number> | null, yalign?: Ref<number> | null): void;
+    /**
+     * 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?: Ref<number> | null, height?: Ref<number> | null): void;
+    /**
+     * Checks whether the given `GtkCellRenderer` is expanded.
+     */
     getIsExpanded(): boolean;
+    /**
+     * Checks whether the given `GtkCellRenderer` is an expander.
+     */
     getIsExpander(): 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?: Ref<number> | null, ypad?: Ref<number> | null): void;
+    /**
+     * 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: Widget, minimumSize?: Ref<number> | null, naturalSize?: Ref<number> | null): void;
+    /**
+     * 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: Widget, width: number, minimumHeight?: Ref<number> | null, naturalHeight?: Ref<number> | null): void;
+    /**
+     * 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: Widget, minimumSize?: Ref<Requisition> | null, naturalSize?: Ref<Requisition> | null): void;
+    /**
+     * 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: Widget, minimumSize?: Ref<number> | null, naturalSize?: Ref<number> | null): void;
+    /**
+     * 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: Widget, height: number, minimumWidth?: Ref<number> | null, naturalWidth?: Ref<number> | null): void;
+    /**
+     * Gets whether the cell renderer prefers a height-for-width layout
+     * or a width-for-height layout.
+     */
     getRequestMode(): SizeRequestMode;
+    /**
+     * Returns the cell renderer’s sensitivity.
+     */
     getSensitive(): 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: CellRendererState, widget?: Widget | null): StateFlags;
+    /**
+     * Returns the cell renderer’s visibility.
+     */
     getVisible(): boolean;
+    /**
+     * Checks whether the cell renderer can do something when activated.
+     */
     isActivatable(): 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: number, yalign: number): void;
+    /**
+     * 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: number, height: number): void;
+    /**
+     * Sets whether the given `GtkCellRenderer` is expanded.
+     * @param isExpanded - whether `cell` should be expanded
+     */
     setIsExpanded(isExpanded: boolean): void;
+    /**
+     * Sets whether the given `GtkCellRenderer` is an expander.
+     * @param isExpander - whether `cell` is an expander
+     */
     setIsExpander(isExpander: boolean): void;
+    /**
+     * 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: number, ypad: number): void;
+    /**
+     * Sets the cell renderer’s sensitivity.
+     * @param sensitive - the sensitivity of the cell
+     */
     setSensitive(sensitive: boolean): void;
+    /**
+     * Sets the cell renderer’s visibility.
+     * @param visible - the visibility of the cell
+     */
     setVisible(visible: boolean): void;
+    /**
+     * 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: Snapshot, widget: Widget, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState): void;
+    /**
+     * 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: Widget, path: string, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState, event?: Gdk.Event | null): CellEditable | null;
+    /**
+     * 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: boolean): void;
     connect(signal: "editing-canceled", handler: (self: CellRenderer) => void, after?: boolean): number;
     connect(signal: "editing-started", handler: (self: CellRenderer, editable: CellEditable, path: string) => void, after?: boolean): number;