@gtkx/ffi 0.6.1 → 0.7.0

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

@@ -1,5 +1,6 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+import * as Gio from "../gio/index.js";
 /** An auxiliary class used by [class@TabView]. */
 export class TabPage extends GObject.GObject {
     static glibTypeName = "AdwTabPage";
@@ -48,7 +49,7 @@ export class TabPage extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getInterface(ptr, Gio.Icon);
     }
     /**
      * Gets whether the indicator of `self` is activatable.
@@ -73,7 +74,7 @@ export class TabPage extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getInterface(ptr, Gio.Icon);
     }
     /**
      * Gets the tooltip of the indicator icon of @self.
@@ -516,6 +517,411 @@ export class TabPage extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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, priority) {
+        call("libadwaita-1.so.0", "gtk_accessible_announce", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: message,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: priority,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Retrieves the accessible parent for an accessible object.
+     *
+     * This function returns `NULL` for top level widgets.
+     */
+    getAccessibleParent() {
+        const ptr = call("libadwaita-1.so.0", "gtk_accessible_get_accessible_parent", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Retrieves the accessible role of an accessible object.
+     */
+    getAccessibleRole() {
+        return call("libadwaita-1.so.0", "gtk_accessible_get_accessible_role", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Retrieves the implementation for the given accessible object.
+     */
+    getAtContext() {
+        const ptr = call("libadwaita-1.so.0", "gtk_accessible_get_at_context", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * 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, y, width, height) {
+        return call("libadwaita-1.so.0", "gtk_accessible_get_bounds", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: x,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: y,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: width,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: height,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Retrieves the first accessible child of an accessible object.
+     */
+    getFirstAccessibleChild() {
+        const ptr = call("libadwaita-1.so.0", "gtk_accessible_get_first_accessible_child", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Retrieves the next accessible sibling of an accessible object
+     */
+    getNextAccessibleSibling() {
+        const ptr = call("libadwaita-1.so.0", "gtk_accessible_get_next_accessible_sibling", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * 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) {
+        return call("libadwaita-1.so.0", "gtk_accessible_get_platform_state", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: state,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Resets the accessible property to its default value.
+     * @param property - the accessible property
+     */
+    resetProperty(property) {
+        call("libadwaita-1.so.0", "gtk_accessible_reset_property", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: property,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Resets the accessible relation to its default value.
+     * @param relation - the accessible relation
+     */
+    resetRelation(relation) {
+        call("libadwaita-1.so.0", "gtk_accessible_reset_relation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: relation,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Resets the accessible state to its default value.
+     * @param state - the accessible state
+     */
+    resetState(state) {
+        call("libadwaita-1.so.0", "gtk_accessible_reset_state", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: state,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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, nextSibling) {
+        call("libadwaita-1.so.0", "gtk_accessible_set_accessible_parent", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: parent?.id ?? parent,
+                optional: true,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: nextSibling?.id ?? nextSibling,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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) {
+        call("libadwaita-1.so.0", "gtk_accessible_update_next_accessible_sibling", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: newSibling?.id ?? newSibling,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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) {
+        call("libadwaita-1.so.0", "gtk_accessible_update_platform_state", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: state,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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, properties, values) {
+        call("libadwaita-1.so.0", "gtk_accessible_update_property_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: nProperties,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 32, unsigned: false },
+                },
+                value: properties,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "boxed",
+                        innerType: "GValue",
+                        lib: "libadwaita-1.so.0",
+                    },
+                },
+                value: values,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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, relations, values) {
+        call("libadwaita-1.so.0", "gtk_accessible_update_relation_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: nRelations,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 32, unsigned: false },
+                },
+                value: relations,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "boxed",
+                        innerType: "GValue",
+                        lib: "libadwaita-1.so.0",
+                    },
+                },
+                value: values,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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, states, values) {
+        call("libadwaita-1.so.0", "gtk_accessible_update_state_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: nStates,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 32, unsigned: false },
+                },
+                value: states,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "boxed",
+                        innerType: "GValue",
+                        lib: "libadwaita-1.so.0",
+                    },
+                },
+                value: values,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

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

@@ -1,5 +1,6 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import { TabPage } from "./tab-page.js";
+import * as Gio from "../gio/index.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A dynamic tabbed container.
@@ -314,7 +315,7 @@ export class TabView extends Gtk.Widget {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gio.Icon);
     }
     /**
      * Whether a page is being transferred.
@@ -435,7 +436,7 @@ export class TabView extends Gtk.Widget {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gtk.SelectionModel);
     }
     /**
      * Gets the currently selected page in @self.

package/dist/generated/adw/toast.js

@@ -1,4 +1,4 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getBoxed, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 /**
  * A helper object for [class@ToastOverlay].
@@ -186,7 +186,7 @@ export class Toast extends GObject.GObject {
         });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getBoxed(ptr, "GVariant");
     }
     /**
      * Gets the label to show on the button.

package/dist/generated/adw/toggle-group.d.ts

@@ -184,6 +184,15 @@ export declare class ToggleGroup extends Gtk.Widget {
      * @param homogeneous - whether all toggles should take the same size
      */
     setHomogeneous(homogeneous: boolean): 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: ToggleGroup, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/adw/toggle-group.js

@@ -1,4 +1,4 @@
-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";
 /**
  * A group of exclusive toggles.
@@ -237,7 +237,7 @@ export class ToggleGroup extends Gtk.Widget {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gtk.SelectionModel);
     }
     /**
      * Removes `toggle` from @self.
@@ -343,6 +343,33 @@ export class ToggleGroup 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/view-stack-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 Gtk from "../gtk/index.js";
 /** An auxiliary class used by [class@ViewStack]. */
@@ -84,6 +86,145 @@ export declare class ViewStackPage extends GObject.GObject {
      * @param visible - whether `self` is visible
      */
     setVisible(visible: boolean): 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: ViewStackPage, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }