@gtkx/ffi 0.6.1 → 0.8.0

package/dist/generated/adw/clamp-scrollable.js

@@ -1,4 +1,6 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, isInstantiating, setInstantiating } from "../../native.js";
+import { registerType } from "../../registry.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A scrollable [class@Clamp].
@@ -161,6 +163,181 @@ export class ClampScrollable extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
+    getOrientation() {
+        return call("libadwaita-1.so.0", "gtk_orientable_get_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
+    setOrientation(orientation) {
+        call("libadwaita-1.so.0", "gtk_orientable_set_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: orientation,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Returns the size of a non-scrolling border around the
+     * outside of the scrollable.
+     *
+     * An example for this would be treeview headers. GTK can use
+     * this information to display overlaid graphics, like the
+     * overshoot indication, at the right position.
+     * @param border - return location for the results
+     */
+    getBorder(border) {
+        return call("libadwaita-1.so.0", "gtk_scrollable_get_border", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "GtkBorder",
+                    lib: "libadwaita-1.so.0",
+                },
+                value: border?.id ?? border,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+     */
+    getHadjustment() {
+        const ptr = call("libadwaita-1.so.0", "gtk_scrollable_get_hadjustment", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets the horizontal `GtkScrollablePolicy`.
+     */
+    getHscrollPolicy() {
+        return call("libadwaita-1.so.0", "gtk_scrollable_get_hscroll_policy", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Retrieves the `GtkAdjustment` used for vertical scrolling.
+     */
+    getVadjustment() {
+        const ptr = call("libadwaita-1.so.0", "gtk_scrollable_get_vadjustment", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets the vertical `GtkScrollablePolicy`.
+     */
+    getVscrollPolicy() {
+        return call("libadwaita-1.so.0", "gtk_scrollable_get_vscroll_policy", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Sets the horizontal adjustment of the `GtkScrollable`.
+     * @param hadjustment - a `GtkAdjustment`
+     */
+    setHadjustment(hadjustment) {
+        call("libadwaita-1.so.0", "gtk_scrollable_set_hadjustment", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: hadjustment?.id ?? hadjustment,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether horizontal scrolling should start
+     * below the minimum width or below the natural width.
+     * @param policy - the horizontal `GtkScrollablePolicy`
+     */
+    setHscrollPolicy(policy) {
+        call("libadwaita-1.so.0", "gtk_scrollable_set_hscroll_policy", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: policy,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the vertical adjustment of the `GtkScrollable`.
+     * @param vadjustment - a `GtkAdjustment`
+     */
+    setVadjustment(vadjustment) {
+        call("libadwaita-1.so.0", "gtk_scrollable_set_vadjustment", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: vadjustment?.id ?? vadjustment,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether vertical scrolling should start
+     * below the minimum height or below the natural height.
+     * @param policy - the vertical `GtkScrollablePolicy`
+     */
+    setVscrollPolicy(policy) {
+        call("libadwaita-1.so.0", "gtk_scrollable_set_vscroll_policy", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: policy,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/adw/clamp.d.ts

@@ -83,6 +83,15 @@ export declare class Clamp extends Gtk.Widget {
      * @param unit - the length unit
      */
     setUnit(unit: LengthUnit): void;
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
+    getOrientation(): Gtk.Orientation;
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
+    setOrientation(orientation: Gtk.Orientation): void;
     connect(signal: "notify", handler: (self: Clamp, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/adw/clamp.js

@@ -1,4 +1,6 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, isInstantiating, setInstantiating } from "../../native.js";
+import { registerType } from "../../registry.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A widget constraining its child to a given size.
@@ -173,6 +175,33 @@ export class Clamp extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
+    getOrientation() {
+        return call("libadwaita-1.so.0", "gtk_orientable_get_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
+    setOrientation(orientation) {
+        call("libadwaita-1.so.0", "gtk_orientable_set_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: orientation,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

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

@@ -1,4 +1,7 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getInterface, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
+import * as Gio from "../gio/index.js";
 import { ActionRow } from "./action-row.js";
 /**
  * A [class@Gtk.ListBoxRow] used to choose from a list of items.
@@ -154,7 +157,7 @@ export class ComboRow extends ActionRow {
         ], { type: "gobject", borrowed: true });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getInterface(ptr, Gio.ListModel);
     }
     /**
      * Returns the match mode that the search filter is using.

package/dist/generated/adw/constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Indicates an [class@Animation] with an infinite duration.
+ *
+ * This value is mostly used internally.
+ */
+export declare const DURATION_INFINITE = 4294967295;
+/** Adwaita major version component (e.g. 1 if the version is 1.2.3). */
+export declare const MAJOR_VERSION = 1;
+/** Adwaita micro version component (e.g. 3 if the version is 1.2.3). */
+export declare const MICRO_VERSION = 2;
+/** Adwaita minor version component (e.g. 2 if the version is 1.2.3). */
+export declare const MINOR_VERSION = 8;
+/**
+ * Adwaita version, encoded as a string, useful for printing and
+ * concatenation.
+ */
+export declare const VERSION_S = "1.8.2";

package/dist/generated/adw/constants.js

@@ -0,0 +1,17 @@
+/**
+ * Indicates an [class@Animation] with an infinite duration.
+ *
+ * This value is mostly used internally.
+ */
+export const DURATION_INFINITE = 4294967295;
+/** Adwaita major version component (e.g. 1 if the version is 1.2.3). */
+export const MAJOR_VERSION = 1;
+/** Adwaita micro version component (e.g. 3 if the version is 1.2.3). */
+export const MICRO_VERSION = 2;
+/** Adwaita minor version component (e.g. 2 if the version is 1.2.3). */
+export const MINOR_VERSION = 8;
+/**
+ * Adwaita version, encoded as a string, useful for printing and
+ * concatenation.
+ */
+export const VERSION_S = "1.8.2";

package/dist/generated/adw/dialog.js

@@ -1,4 +1,6 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, isInstantiating, setInstantiating } from "../../native.js";
+import { registerType } from "../../registry.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * An adaptive dialog container.

package/dist/generated/adw/entry-row.d.ts

@@ -1,3 +1,4 @@
+import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
 import * as Pango from "../pango/index.js";
@@ -115,6 +116,225 @@ export declare class EntryRow extends PreferencesRow {
      * @param showApplyButton - whether to show the apply button
      */
     setShowApplyButton(showApplyButton: boolean): void;
+    /**
+     * 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: Gtk.AccessiblePlatformState): boolean;
+    /**
+     * Deletes the currently selected text of the editable.
+     *
+     * This call doesn’t do anything if there is no selected text.
+     */
+    deleteSelection(): void;
+    /**
+     * 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: number, endPos: number): void;
+    /**
+     * 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(): void;
+    /**
+     * Gets the alignment of the editable.
+     */
+    getAlignment(): number;
+    /**
+     * 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: number, endPos: number): string;
+    /**
+     * Gets the `GtkEditable` that `editable` is delegating its
+     * implementation to.
+     *
+     * Typically, the delegate is a [class@Gtk.Text] widget.
+     */
+    getDelegate(): Gtk.Editable | null;
+    /**
+     * Retrieves whether `editable` is editable.
+     */
+    getEditable(): boolean;
+    /**
+     * Gets if undo/redo actions are enabled for @editable
+     */
+    getEnableUndo(): boolean;
+    /**
+     * Retrieves the desired maximum width of @editable, in characters.
+     */
+    getMaxWidthChars(): number;
+    /**
+     * 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(): number;
+    /**
+     * 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?: Ref<number> | null, endPos?: Ref<number> | null): boolean;
+    /**
+     * Retrieves the contents of @editable.
+     *
+     * The returned string is owned by GTK and must not be modified or freed.
+     */
+    getText(): string;
+    /**
+     * Gets the number of characters of space reserved
+     * for the contents of the editable.
+     */
+    getWidthChars(): number;
+    /**
+     * 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(): void;
+    /**
+     * 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: string, length: number, position: Ref<number>): void;
+    /**
+     * 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: number, endPos: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * Sets the desired maximum width in characters of @editable.
+     * @param nChars - the new desired maximum width, in characters
+     */
+    setMaxWidthChars(nChars: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * Sets the text in the editable to the given value.
+     *
+     * This is replacing the current contents.
+     * @param text - the text to set
+     */
+    setText(text: string): void;
+    /**
+     * 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: number): void;
     connect(signal: "apply", handler: (self: EntryRow) => void, after?: boolean): number;
     connect(signal: "entry-activated", handler: (self: EntryRow) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: EntryRow, pspec: GObject.ParamSpec) => void, after?: boolean): number;