@gtkx/ffi 0.6.1 → 0.8.0

package/dist/generated/adw/swipe-tracker.d.ts

@@ -1,6 +1,7 @@
 import { NavigationDirection } from "./enums.js";
 import { Swipeable } from "./swipeable.js";
 import * as GObject from "../gobject/index.js";
+import * as Gtk from "../gtk/index.js";
 export declare class SwipeTracker extends GObject.GObject {
     static readonly glibTypeName: string;
     /**
@@ -94,6 +95,15 @@ export declare class SwipeTracker extends GObject.GObject {
      * @param delta - the position delta
      */
     shiftPosition(delta: number): 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: "begin-swipe", handler: (self: SwipeTracker) => void, after?: boolean): number;
     connect(signal: "end-swipe", handler: (self: SwipeTracker, velocity: number, to: number) => void, after?: boolean): number;
     connect(signal: "prepare", handler: (self: SwipeTracker, direction: NavigationDirection) => void, after?: boolean): number;

package/dist/generated/adw/swipe-tracker.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 { Swipeable } from "./swipeable.js";
 import * as GObject from "../gobject/index.js";
 /**
  * A swipe tracker used in [class@Carousel], [class@NavigationView] and
@@ -131,7 +134,7 @@ export class SwipeTracker extends GObject.GObject {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Swipeable);
     }
     /**
      * Gets whether to allow swiping past the last available snap point.
@@ -286,6 +289,33 @@ export class SwipeTracker extends GObject.GObject {
             },
         ], { 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 meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };

package/dist/generated/adw/swipeable.js

@@ -1,4 +1,4 @@
-import { call } from "@gtkx/ffi";
+import { call } from "../../batch.js";
 /**
  * An interface for swipeable widgets.
  *

package/dist/generated/adw/switch-row.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 { ActionRow } from "./action-row.js";
 /**
  * A [class@Gtk.ListBoxRow] used to represent two states.

package/dist/generated/adw/tab-bar.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 { TabPage } from "./tab-page.js";
 import * as Gtk from "../gtk/index.js";
 /**

package/dist/generated/adw/tab-button.d.ts

@@ -1,4 +1,5 @@
 import { TabView } from "./tab-view.js";
+import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
 export declare class TabButton extends Gtk.Widget {
@@ -16,6 +17,62 @@ export declare class TabButton extends Gtk.Widget {
      * @param view - a tab view
      */
     setView(view?: TabView | null): void;
+    /**
+     * Gets the action name for @actionable.
+     */
+    getActionName(): string | null;
+    /**
+     * Gets the current target value of @actionable.
+     */
+    getActionTargetValue(): GLib.Variant | null;
+    /**
+     * Specifies the name of the action with which this widget should be
+     * associated.
+     *
+     * If `action_name` is %NULL then the widget will be unassociated from
+     * any previous action.
+     *
+     * Usually this function is used when the widget is located (or will be
+     * located) within the hierarchy of a `GtkApplicationWindow`.
+     *
+     * Names are of the form “win.save” or “app.quit” for actions on the
+     * containing [class@ApplicationWindow] or its associated [class@Application],
+     * respectively. This is the same form used for actions in the [class@Gio.Menu]
+     * associated with the window.
+     * @param actionName - an action name
+     */
+    setActionName(actionName?: string | null): void;
+    /**
+     * Sets the target value of an actionable widget.
+     *
+     * If `target_value` is %NULL then the target value is unset.
+     *
+     * The target value has two purposes. First, it is used as the parameter
+     * to activation of the action associated with the `GtkActionable` widget.
+     * Second, it is used to determine if the widget should be rendered as
+     * “active” — the widget is active if the state is equal to the given target.
+     *
+     * Consider the example of associating a set of buttons with a [iface@Gio.Action]
+     * with string state in a typical “radio button” situation. Each button
+     * will be associated with the same action, but with a different target
+     * value for that action. Clicking on a particular button will activate
+     * the action with the target of that button, which will typically cause
+     * the action’s state to change to that value. Since the action’s state
+     * is now equal to the target value of the button, the button will now
+     * be rendered as active (and the other buttons, with different targets,
+     * rendered inactive).
+     * @param targetValue - a [struct@GLib.Variant] to set as the target value
+     */
+    setActionTargetValue(targetValue?: GLib.Variant | null): void;
+    /**
+     * Sets the action-name and associated string target value of an
+     * actionable widget.
+     *
+     * `detailed_action_name` is a string in the format accepted by
+     * [func@Gio.Action.parse_detailed_name].
+     * @param detailedActionName - the detailed action name
+     */
+    setDetailedActionName(detailedActionName: string): void;
     connect(signal: "activate", handler: (self: TabButton) => void, after?: boolean): number;
     connect(signal: "clicked", handler: (self: TabButton) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: TabButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/adw/tab-button.js

@@ -1,4 +1,7 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getBoxed, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
+import * as GLib from "../glib/index.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A button that displays the number of [class@TabView] pages.
@@ -83,6 +86,124 @@ export class TabButton extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the action name for @actionable.
+     */
+    getActionName() {
+        return call("libadwaita-1.so.0", "gtk_actionable_get_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets the current target value of @actionable.
+     */
+    getActionTargetValue() {
+        const ptr = call("libadwaita-1.so.0", "gtk_actionable_get_action_target_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariant",
+            lib: "libadwaita-1.so.0",
+        });
+        if (ptr === null)
+            return null;
+        return getBoxed(ptr, GLib.Variant);
+    }
+    /**
+     * Specifies the name of the action with which this widget should be
+     * associated.
+     *
+     * If `action_name` is %NULL then the widget will be unassociated from
+     * any previous action.
+     *
+     * Usually this function is used when the widget is located (or will be
+     * located) within the hierarchy of a `GtkApplicationWindow`.
+     *
+     * Names are of the form “win.save” or “app.quit” for actions on the
+     * containing [class@ApplicationWindow] or its associated [class@Application],
+     * respectively. This is the same form used for actions in the [class@Gio.Menu]
+     * associated with the window.
+     * @param actionName - an action name
+     */
+    setActionName(actionName) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the target value of an actionable widget.
+     *
+     * If `target_value` is %NULL then the target value is unset.
+     *
+     * The target value has two purposes. First, it is used as the parameter
+     * to activation of the action associated with the `GtkActionable` widget.
+     * Second, it is used to determine if the widget should be rendered as
+     * “active” — the widget is active if the state is equal to the given target.
+     *
+     * Consider the example of associating a set of buttons with a [iface@Gio.Action]
+     * with string state in a typical “radio button” situation. Each button
+     * will be associated with the same action, but with a different target
+     * value for that action. Clicking on a particular button will activate
+     * the action with the target of that button, which will typically cause
+     * the action’s state to change to that value. Since the action’s state
+     * is now equal to the target value of the button, the button will now
+     * be rendered as active (and the other buttons, with different targets,
+     * rendered inactive).
+     * @param targetValue - a [struct@GLib.Variant] to set as the target value
+     */
+    setActionTargetValue(targetValue) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_action_target_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "GVariant",
+                    lib: "libadwaita-1.so.0",
+                },
+                value: targetValue?.id ?? targetValue,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the action-name and associated string target value of an
+     * actionable widget.
+     *
+     * `detailed_action_name` is a string in the format accepted by
+     * [func@Gio.Action.parse_detailed_name].
+     * @param detailedActionName - the detailed action name
+     */
+    setDetailedActionName(detailedActionName) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_detailed_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: detailedActionName,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };

package/dist/generated/adw/tab-overview.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 { TabPage } from "./tab-page.js";
 import * as Gtk from "../gtk/index.js";
 /**

package/dist/generated/adw/tab-page.d.ts

@@ -1,3 +1,5 @@
+import { Ref } from "@gtkx/native";
+import * as Atspi from "../atspi/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import * as Gtk from "../gtk/index.js";
@@ -234,6 +236,145 @@ export declare class TabPage extends GObject.GObject {
      * @param tooltip - the tooltip of @self
      */
     setTooltip(tooltip: string): void;
+    /**
+     * Requests the user's screen reader to announce the given message.
+     *
+     * This kind of notification is useful for messages that
+     * either have only a visual representation or that are not
+     * exposed visually at all, e.g. a notification about a
+     * successful operation.
+     *
+     * Also, by using this API, you can ensure that the message
+     * does not interrupts the user's current screen reader output.
+     * @param message - the string to announce
+     * @param priority - the priority of the announcement
+     */
+    announce(message: string, priority: Gtk.AccessibleAnnouncementPriority): void;
+    /**
+     * Retrieves the accessible parent for an accessible object.
+     *
+     * This function returns `NULL` for top level widgets.
+     */
+    getAccessibleParent(): Atspi.Accessible | null;
+    /**
+     * Retrieves the accessible role of an accessible object.
+     */
+    getAccessibleRole(): Gtk.AccessibleRole;
+    /**
+     * Retrieves the implementation for the given accessible object.
+     */
+    getAtContext(): Gtk.ATContext;
+    /**
+     * Queries the coordinates and dimensions of this accessible
+     *
+     * This functionality can be overridden by `GtkAccessible`
+     * implementations, e.g. to get the bounds from an ignored
+     * child widget.
+     * @param x - the x coordinate of the top left corner of the accessible
+     * @param y - the y coordinate of the top left corner of the widget
+     * @param width - the width of the accessible object
+     * @param height - the height of the accessible object
+     */
+    getBounds(x: Ref<number>, y: Ref<number>, width: Ref<number>, height: Ref<number>): boolean;
+    /**
+     * Retrieves the first accessible child of an accessible object.
+     */
+    getFirstAccessibleChild(): Atspi.Accessible | null;
+    /**
+     * Retrieves the next accessible sibling of an accessible object
+     */
+    getNextAccessibleSibling(): Atspi.Accessible | null;
+    /**
+     * Queries a platform state, such as focus.
+     *
+     * This functionality can be overridden by `GtkAccessible`
+     * implementations, e.g. to get platform state from an ignored
+     * child widget, as is the case for `GtkText` wrappers.
+     * @param state - platform state to query
+     */
+    getPlatformState(state: Gtk.AccessiblePlatformState): boolean;
+    /**
+     * Resets the accessible property to its default value.
+     * @param property - the accessible property
+     */
+    resetProperty(property: Gtk.AccessibleProperty): void;
+    /**
+     * Resets the accessible relation to its default value.
+     * @param relation - the accessible relation
+     */
+    resetRelation(relation: Gtk.AccessibleRelation): void;
+    /**
+     * Resets the accessible state to its default value.
+     * @param state - the accessible state
+     */
+    resetState(state: Gtk.AccessibleState): void;
+    /**
+     * Sets the parent and sibling of an accessible object.
+     *
+     * This function is meant to be used by accessible implementations that are
+     * not part of the widget hierarchy, and but act as a logical bridge between
+     * widgets. For instance, if a widget creates an object that holds metadata
+     * for each child, and you want that object to implement the `GtkAccessible`
+     * interface, you will use this function to ensure that the parent of each
+     * child widget is the metadata object, and the parent of each metadata
+     * object is the container widget.
+     * @param parent - the parent accessible object
+     * @param nextSibling - the sibling accessible object
+     */
+    setAccessibleParent(parent?: Atspi.Accessible | null, nextSibling?: Atspi.Accessible | null): void;
+    /**
+     * Updates the next accessible sibling.
+     *
+     * That might be useful when a new child of a custom accessible
+     * is created, and it needs to be linked to a previous child.
+     * @param newSibling - the new next accessible sibling to set
+     */
+    updateNextAccessibleSibling(newSibling?: Atspi.Accessible | null): void;
+    /**
+     * Informs ATs that the platform state has changed.
+     *
+     * This function should be used by `GtkAccessible` implementations that
+     * have a platform state but are not widgets. Widgets handle platform
+     * states automatically.
+     * @param state - the platform state to update
+     */
+    updatePlatformState(state: Gtk.AccessiblePlatformState): void;
+    /**
+     * Updates an array of accessible properties.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * property change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nProperties - the number of accessible properties to set
+     * @param properties - an array of accessible properties
+     * @param values - an array of `GValues`, one for each property
+     */
+    updatePropertyValue(nProperties: number, properties: Gtk.AccessibleProperty[], values: GObject.Value[]): void;
+    /**
+     * Updates an array of accessible relations.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * relation change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nRelations - the number of accessible relations to set
+     * @param relations - an array of accessible relations
+     * @param values - an array of `GValues`, one for each relation
+     */
+    updateRelationValue(nRelations: number, relations: Gtk.AccessibleRelation[], values: GObject.Value[]): void;
+    /**
+     * Updates an array of accessible states.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * state change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nStates - the number of accessible states to set
+     * @param states - an array of accessible states
+     * @param values - an array of `GValues`, one for each state
+     */
+    updateStateValue(nStates: number, states: Gtk.AccessibleState[], values: GObject.Value[]): void;
     connect(signal: "notify", handler: (self: TabPage, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }