@gtkx/ffi 0.9.4 → 0.10.0

package/dist/generated/gtk/accessible-range.d.ts

@@ -1,4 +1,9 @@
+import { Ref } from "@gtkx/native";
 import { NativeObject } from "../../native/base.js";
+import { AccessibleAnnouncementPriority, AccessiblePlatformState, AccessibleProperty, AccessibleRelation, AccessibleRole, AccessibleState } from "./enums.js";
+import { Accessible } from "./accessible.js";
+import { ATContext } from "./atcontext.js";
+import * as GObject from "../gobject/index.js";
 /**
  * An interface for accessible objects containing a numeric value.
  *
@@ -29,4 +34,143 @@ import { NativeObject } from "../../native/base.js";
 export declare class AccessibleRange extends NativeObject {
     static readonly glibTypeName: string;
     static readonly objectType: "interface";
+    /**
+     * 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: AccessibleAnnouncementPriority): void;
+    /**
+     * Retrieves the accessible parent for an accessible object.
+     *
+     * This function returns `NULL` for top level widgets.
+     */
+    getAccessibleParent(): Accessible | null;
+    /**
+     * Retrieves the accessible role of an accessible object.
+     */
+    getAccessibleRole(): AccessibleRole;
+    /**
+     * Retrieves the implementation for the given accessible object.
+     */
+    getAtContext(): 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(): Accessible | null;
+    /**
+     * Retrieves the next accessible sibling of an accessible object
+     */
+    getNextAccessibleSibling(): 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: AccessiblePlatformState): boolean;
+    /**
+     * Resets the accessible property to its default value.
+     * @param property - the accessible property
+     */
+    resetProperty(property: AccessibleProperty): void;
+    /**
+     * Resets the accessible relation to its default value.
+     * @param relation - the accessible relation
+     */
+    resetRelation(relation: AccessibleRelation): void;
+    /**
+     * Resets the accessible state to its default value.
+     * @param state - the accessible state
+     */
+    resetState(state: 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?: Accessible, nextSibling?: Accessible): 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?: Accessible): 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: 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: 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: 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: AccessibleState[], values: GObject.Value[]): void;
 }

package/dist/generated/gtk/accessible-range.js

@@ -1,4 +1,7 @@
+import { call } from "../../batch.js";
+import { getNativeObject } from "../../native/object.js";
 import { NativeObject } from "../../native/base.js";
+import { Accessible } from "./accessible.js";
 /**
  * An interface for accessible objects containing a numeric value.
  *
@@ -29,4 +32,412 @@ import { NativeObject } from "../../native/base.js";
 export class AccessibleRange extends NativeObject {
     static glibTypeName = "GtkAccessibleRange";
     static objectType = "interface";
+    /**
+     * 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("libgtk-4.so.1", "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("libgtk-4.so.1", "gtk_accessible_get_accessible_parent", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, Accessible);
+    }
+    /**
+     * Retrieves the accessible role of an accessible object.
+     */
+    getAccessibleRole() {
+        return call("libgtk-4.so.1", "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("libgtk-4.so.1", "gtk_accessible_get_at_context", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getNativeObject(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("libgtk-4.so.1", "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("libgtk-4.so.1", "gtk_accessible_get_first_accessible_child", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, Accessible);
+    }
+    /**
+     * Retrieves the next accessible sibling of an accessible object
+     */
+    getNextAccessibleSibling() {
+        const ptr = call("libgtk-4.so.1", "gtk_accessible_get_next_accessible_sibling", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, Accessible);
+    }
+    /**
+     * 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("libgtk-4.so.1", "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("libgtk-4.so.1", "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("libgtk-4.so.1", "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("libgtk-4.so.1", "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("libgtk-4.so.1", "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("libgtk-4.so.1", "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("libgtk-4.so.1", "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("libgtk-4.so.1", "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: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                },
+                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("libgtk-4.so.1", "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: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                },
+                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("libgtk-4.so.1", "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: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                },
+                value: values,
+            },
+        ], { type: "undefined" });
+    }
 }

package/dist/generated/gtk/accessible-text-range.d.ts

@@ -0,0 +1,18 @@
+import { NativeObject } from "../../native/base.js";
+export interface AccessibleTextRangeInit {
+    start?: number;
+    length?: number;
+}
+/** A range inside the text of an accessible object. */
+export declare class AccessibleTextRange extends NativeObject {
+    static readonly objectType: "struct";
+    constructor(init?: AccessibleTextRangeInit);
+    protected createPtr(init: AccessibleTextRangeInit): unknown;
+    static fromPtr(ptr: unknown): AccessibleTextRange;
+    /** the start of the range, in characters */
+    get start(): number;
+    set start(value: number);
+    /** the length of the range, in characters */
+    get length(): number;
+    set length(value: number);
+}

package/dist/generated/gtk/accessible-text-range.js

@@ -0,0 +1,37 @@
+import { alloc, read, write } from "@gtkx/native";
+import { NativeObject } from "../../native/base.js";
+/** A range inside the text of an accessible object. */
+export class AccessibleTextRange extends NativeObject {
+    static objectType = "struct";
+    constructor(init = {}) {
+        super();
+        this.id = this.createPtr(init);
+    }
+    createPtr(init) {
+        const ptr = alloc(16);
+        if (init.start !== undefined)
+            write(ptr, { type: "int", size: 64, unsigned: true }, 0, init.start);
+        if (init.length !== undefined)
+            write(ptr, { type: "int", size: 64, unsigned: true }, 8, init.length);
+        return ptr;
+    }
+    static fromPtr(ptr) {
+        const instance = Object.create(AccessibleTextRange.prototype);
+        instance.id = ptr;
+        return instance;
+    }
+    /** the start of the range, in characters */
+    get start() {
+        return read(this.id, { type: "int", size: 64, unsigned: true }, 0);
+    }
+    set start(value) {
+        write(this.id, { type: "int", size: 64, unsigned: true }, 0, value);
+    }
+    /** the length of the range, in characters */
+    get length() {
+        return read(this.id, { type: "int", size: 64, unsigned: true }, 8);
+    }
+    set length(value) {
+        write(this.id, { type: "int", size: 64, unsigned: true }, 8, value);
+    }
+}