@gtkx/ffi 0.6.0 → 0.7.0

package/dist/generated/adw/spin-row.js

@@ -1,4 +1,5 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import * as Gtk from "../gtk/index.js";
 import { ActionRow } from "./action-row.js";
 /**
  * An [class@ActionRow] with an embedded spin button.
@@ -396,6 +397,483 @@ export class SpinRow extends ActionRow {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the accessible platform state from the editable delegate.
+     *
+     * This is an helper function to retrieve the accessible state for
+     * `GtkEditable` interface implementations using a delegate pattern.
+     *
+     * You should call this function in your editable widget implementation
+     * of the [vfunc@Gtk.Accessible.get_platform_state] virtual function, for
+     * instance:
+     *
+     * ```c
+     * static void
+     * accessible_interface_init (GtkAccessibleInterface *iface)
+     * {
+     * iface->get_platform_state = your_editable_get_accessible_platform_state;
+     * }
+     *
+     * static gboolean
+     * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+     * GtkAccessiblePlatformState state)
+     * {
+     * return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+     * }
+     * ```
+     *
+     * Note that the widget which is the delegate *must* be a direct child of
+     * this widget, otherwise your implementation of [vfunc@Gtk.Accessible.get_platform_state]
+     * might not even be called, as the platform change will originate from
+     * the parent of the delegate, and, as a result, will not work properly.
+     *
+     * So, if you can't ensure the direct child condition, you should give the
+     * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+     * change your tree to allow this function to work.
+     * @param state - what kind of accessible state to retrieve
+     */
+    delegateGetAccessiblePlatformState(state) {
+        return call("libadwaita-1.so.0", "gtk_editable_delegate_get_accessible_platform_state", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: state,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Deletes the currently selected text of the editable.
+     *
+     * This call doesn’t do anything if there is no selected text.
+     */
+    deleteSelection() {
+        call("libadwaita-1.so.0", "gtk_editable_delete_selection", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Deletes a sequence of characters.
+     *
+     * The characters that are deleted are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is
+     * negative, then the characters deleted are those from `start_pos` to
+     * the end of the text.
+     *
+     * Note that the positions are specified in characters, not bytes.
+     * @param startPos - start position
+     * @param endPos - end position
+     */
+    deleteText(startPos, endPos) {
+        call("libadwaita-1.so.0", "gtk_editable_delete_text", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: startPos,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: endPos,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Undoes the setup done by [method@Gtk.Editable.init_delegate].
+     *
+     * This is a helper function that should be called from dispose,
+     * before removing the delegate object.
+     */
+    finishDelegate() {
+        call("libadwaita-1.so.0", "gtk_editable_finish_delegate", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Gets the alignment of the editable.
+     */
+    getAlignment() {
+        return call("libadwaita-1.so.0", "gtk_editable_get_alignment", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "float", size: 32 });
+    }
+    /**
+     * Retrieves a sequence of characters.
+     *
+     * The characters that are retrieved are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is negative,
+     * then the characters retrieved are those characters from `start_pos` to
+     * the end of the text.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - start of text
+     * @param endPos - end of text
+     */
+    getChars(startPos, endPos) {
+        return call("libadwaita-1.so.0", "gtk_editable_get_chars", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: startPos,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: endPos,
+            },
+        ], { type: "string" });
+    }
+    /**
+     * Gets the `GtkEditable` that `editable` is delegating its
+     * implementation to.
+     *
+     * Typically, the delegate is a [class@Gtk.Text] widget.
+     */
+    getDelegate() {
+        const ptr = call("libadwaita-1.so.0", "gtk_editable_get_delegate", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getInterface(ptr, Gtk.Editable);
+    }
+    /**
+     * Retrieves whether `editable` is editable.
+     */
+    getEditable() {
+        return call("libadwaita-1.so.0", "gtk_editable_get_editable", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets if undo/redo actions are enabled for @editable
+     */
+    getEnableUndo() {
+        return call("libadwaita-1.so.0", "gtk_editable_get_enable_undo", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Retrieves the desired maximum width of @editable, in characters.
+     */
+    getMaxWidthChars() {
+        return call("libadwaita-1.so.0", "gtk_editable_get_max_width_chars", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Retrieves the current position of the cursor relative
+     * to the start of the content of the editable.
+     *
+     * Note that this position is in characters, not in bytes.
+     */
+    getPosition() {
+        return call("libadwaita-1.so.0", "gtk_editable_get_position", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Retrieves the selection bound of the editable.
+     *
+     * `start_pos` will be filled with the start of the selection and
+     * `end_pos` with end. If no text was selected both will be identical
+     * and %FALSE will be returned.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - location to store the starting position
+     * @param endPos - location to store the end position
+     */
+    getSelectionBounds(startPos, endPos) {
+        return call("libadwaita-1.so.0", "gtk_editable_get_selection_bounds", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: startPos,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: endPos,
+                optional: true,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Retrieves the contents of @editable.
+     *
+     * The returned string is owned by GTK and must not be modified or freed.
+     */
+    getText() {
+        return call("libadwaita-1.so.0", "gtk_editable_get_text", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets the number of characters of space reserved
+     * for the contents of the editable.
+     */
+    getWidthChars() {
+        return call("libadwaita-1.so.0", "gtk_editable_get_width_chars", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Sets up a delegate for `GtkEditable`.
+     *
+     * This is assuming that the get_delegate vfunc in the `GtkEditable`
+     * interface has been set up for the @editable's type.
+     *
+     * This is a helper function that should be called in instance init,
+     * after creating the delegate object.
+     */
+    initDelegate() {
+        call("libadwaita-1.so.0", "gtk_editable_init_delegate", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Inserts `length` bytes of `text` into the contents of the
+     * widget, at position @position.
+     *
+     * Note that the position is in characters, not in bytes.
+     * The function updates `position` to point after the newly
+     * inserted text.
+     * @param text - the text to insert
+     * @param length - the length of the text in bytes, or -1
+     * @param position - location of the position text will be inserted at
+     */
+    insertText(text, length, position) {
+        call("libadwaita-1.so.0", "gtk_editable_insert_text", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: length,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: position,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Selects a region of text.
+     *
+     * The characters that are selected are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is
+     * negative, then the characters selected are those characters from
+     * `start_pos` to  the end of the text.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - start of region
+     * @param endPos - end of region
+     */
+    selectRegion(startPos, endPos) {
+        call("libadwaita-1.so.0", "gtk_editable_select_region", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: startPos,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: endPos,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the alignment for the contents of the editable.
+     *
+     * This controls the horizontal positioning of the contents when
+     * the displayed text is shorter than the width of the editable.
+     * @param xalign - The horizontal alignment, from 0 (left) to 1 (right).
+     */
+    setAlignment(xalign) {
+        call("libadwaita-1.so.0", "gtk_editable_set_alignment", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: xalign,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Determines if the user can edit the text in the editable widget.
+     * @param isEditable - %TRUE if the user is allowed to edit the text
+     */
+    setEditable(isEditable) {
+        call("libadwaita-1.so.0", "gtk_editable_set_editable", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: isEditable,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * If enabled, changes to `editable` will be saved for undo/redo
+     * actions.
+     *
+     * This results in an additional copy of text changes and are not
+     * stored in secure memory. As such, undo is forcefully disabled
+     * when [property@Gtk.Text:visibility] is set to %FALSE.
+     * @param enableUndo - if undo/redo should be enabled
+     */
+    setEnableUndo(enableUndo) {
+        call("libadwaita-1.so.0", "gtk_editable_set_enable_undo", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: enableUndo,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the desired maximum width in characters of @editable.
+     * @param nChars - the new desired maximum width, in characters
+     */
+    setMaxWidthChars(nChars) {
+        call("libadwaita-1.so.0", "gtk_editable_set_max_width_chars", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: nChars,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the cursor position in the editable to the given value.
+     *
+     * The cursor is displayed before the character with the given (base 0)
+     * index in the contents of the editable. The value must be less than
+     * or equal to the number of characters in the editable. A value of -1
+     * indicates that the position should be set after the last character
+     * of the editable. Note that `position` is in characters, not in bytes.
+     * @param position - the position of the cursor
+     */
+    setPosition(position) {
+        call("libadwaita-1.so.0", "gtk_editable_set_position", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: position,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the text in the editable to the given value.
+     *
+     * This is replacing the current contents.
+     * @param text - the text to set
+     */
+    setText(text) {
+        call("libadwaita-1.so.0", "gtk_editable_set_text", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Changes the size request of the editable to be about the
+     * right size for `n_chars` characters.
+     *
+     * Note that it changes the size request, the size can still
+     * be affected by how you pack the widget into containers.
+     * If `n_chars` is -1, the size reverts to the default size.
+     * @param nChars - width in chars
+     */
+    setWidthChars(nChars) {
+        call("libadwaita-1.so.0", "gtk_editable_set_width_chars", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: nChars,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };

package/dist/generated/adw/spinner-paintable.d.ts

@@ -1,4 +1,6 @@
+import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A paintable showing a loading spinner.
@@ -44,6 +46,136 @@ export declare class SpinnerPaintable extends GObject.GObject {
      * @param widget - the widget to use for frame clock
      */
     setWidget(widget?: Gtk.Widget | null): void;
+    /**
+     * Compute a concrete size for the `GdkPaintable`.
+     *
+     * Applies the sizing algorithm outlined in the
+     * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+     * to the given @paintable. See that link for more details.
+     *
+     * It is not necessary to call this function when both `specified_width` and `specified_height` are known, but it is useful to call this
+     * function in GtkWidget:measure implementations to compute the
+     * other dimension when only one dimension is given.
+     * @param specifiedWidth - the width `paintable` could be drawn into or
+     * @param specifiedHeight - the height `paintable` could be drawn into or
+     * @param defaultWidth - the width `paintable` would be drawn into if
+     * @param defaultHeight - the height `paintable` would be drawn into if
+     * @param concreteWidth - will be set to the concrete width computed
+     * @param concreteHeight - will be set to the concrete height computed
+     */
+    computeConcreteSize(specifiedWidth: number, specifiedHeight: number, defaultWidth: number, defaultHeight: number, concreteWidth: Ref<number>, concreteHeight: Ref<number>): void;
+    /**
+     * Gets an immutable paintable for the current contents displayed by @paintable.
+     *
+     * This is useful when you want to retain the current state of an animation,
+     * for example to take a screenshot of a running animation.
+     *
+     * If the `paintable` is already immutable, it will return itself.
+     */
+    getCurrentImage(): Gdk.Paintable;
+    /**
+     * Get flags for the paintable.
+     *
+     * This is oftentimes useful for optimizations.
+     *
+     * See [flags@Gdk.PaintableFlags] for the flags and what they mean.
+     */
+    getFlags(): Gdk.PaintableFlags;
+    /**
+     * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+     *
+     * The aspect ratio is the width divided by the height, so a value of 0.5
+     * means that the `paintable` prefers to be displayed twice as high as it
+     * is wide. Consumers of this interface can use this to preserve aspect
+     * ratio when displaying the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to [method@Gdk.Paintable.snapshot].
+     *
+     * Usually when a `paintable` returns nonzero values from
+     * [method@Gdk.Paintable.get_intrinsic_width] and
+     * [method@Gdk.Paintable.get_intrinsic_height] the aspect ratio
+     * should conform to those values, though that is not required.
+     *
+     * If the `paintable` does not have a preferred aspect ratio,
+     * it returns 0. Negative values are never returned.
+     */
+    getIntrinsicAspectRatio(): number;
+    /**
+     * Gets the preferred height the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to [method@Gdk.Paintable.snapshot].
+     *
+     * If the `paintable` does not have a preferred height, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicHeight(): number;
+    /**
+     * Gets the preferred width the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to [method@Gdk.Paintable.snapshot].
+     *
+     * If the `paintable` does not have a preferred width, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicWidth(): number;
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their contents.
+     *
+     * Unless the contents are invalidated, implementations must guarantee that
+     * multiple calls of [method@Gdk.Paintable.snapshot] produce the same output.
+     *
+     * This function will emit the [signal@Gdk.Paintable::invalidate-contents]
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+     * it must not call this function.
+     */
+    invalidateContents(): void;
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their size.
+     *
+     * As long as the size is not invalidated, `paintable` must return the same
+     * values for its intrinsic width, height and aspect ratio.
+     *
+     * This function will emit the [signal@Gdk.Paintable::invalidate-size]
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+     * it must not call this function.
+     */
+    invalidateSize(): void;
+    /**
+     * Snapshots the given paintable with the given `width` and @height.
+     *
+     * The paintable is drawn at the current (0,0) offset of the @snapshot.
+     * If `width` and `height` are not larger than zero, this function will
+     * do nothing.
+     * @param snapshot - a `GdkSnapshot` to snapshot to
+     * @param width - width to snapshot in
+     * @param height - height to snapshot in
+     */
+    snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+    /**
+     * Snapshots the paintable with the given colors.
+     *
+     * If less than 4 colors are provided, GTK will pad the array with default
+     * colors.
+     * @param snapshot - a `GdkSnapshot` to snapshot to
+     * @param width - width to snapshot in
+     * @param height - height to snapshot in
+     * @param colors - a pointer to an array of colors
+     * @param nColors - The number of colors
+     */
+    snapshotSymbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[], nColors: number): void;
     connect(signal: "notify", handler: (self: SpinnerPaintable, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }