@gtkx/ffi 0.9.4 → 0.10.0

package/dist/generated/gio/remote-action-group.js

@@ -1,5 +1,7 @@
 import { call } from "../../batch.js";
+import { getNativeObject } from "../../native/object.js";
 import { NativeObject } from "../../native/base.js";
+import * as GLib from "../glib/index.js";
 /**
  * The `GRemoteActionGroup` interface is implemented by {@link Gio.ActionGroup}
  * instances that either transmit action invocations to other processes
@@ -51,25 +53,13 @@ export class RemoteActionGroup extends NativeObject {
                 value: actionName,
             },
             {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "intern",
-                },
-                value: parameter?.id ?? parameter,
+                type: { type: "gvariant" },
+                value: parameter,
                 optional: true,
             },
             {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "intern",
-                },
-                value: platformData?.id ?? platformData,
+                type: { type: "gvariant" },
+                value: platformData,
             },
         ], { type: "undefined" });
     }
@@ -97,26 +87,461 @@ export class RemoteActionGroup extends NativeObject {
                 type: { type: "string" },
                 value: actionName,
             },
+            {
+                type: { type: "gvariant" },
+                value: value,
+            },
+            {
+                type: { type: "gvariant" },
+                value: platformData,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Emits the {@link Gio.ActionGroup.:action-added} signal on `action_group`.
+     *
+     * This function should only be called by {@link Gio.ActionGroup} implementations.
+     * @param actionName - the name of an action in the group
+     */
+    actionAdded(actionName) {
+        call("libgio-2.0.so.0", "g_action_group_action_added", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Emits the {@link Gio.ActionGroup.:action-enabled-changed} signal on `action_group`.
+     *
+     * This function should only be called by {@link Gio.ActionGroup} implementations.
+     * @param actionName - the name of an action in the group
+     * @param enabled - whether the action is now enabled
+     */
+    actionEnabledChanged(actionName, enabled) {
+        call("libgio-2.0.so.0", "g_action_group_action_enabled_changed", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+            {
+                type: { type: "boolean" },
+                value: enabled,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Emits the {@link Gio.ActionGroup.:action-removed} signal on `action_group`.
+     *
+     * This function should only be called by {@link Gio.ActionGroup} implementations.
+     * @param actionName - the name of an action in the group
+     */
+    actionRemoved(actionName) {
+        call("libgio-2.0.so.0", "g_action_group_action_removed", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Emits the {@link Gio.ActionGroup.:action-state-changed} signal on `action_group`.
+     *
+     * This function should only be called by {@link Gio.ActionGroup} implementations.
+     * @param actionName - the name of an action in the group
+     * @param state - the new state of the named action
+     */
+    actionStateChanged(actionName, state) {
+        call("libgio-2.0.so.0", "g_action_group_action_state_changed", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+            {
+                type: { type: "gvariant" },
+                value: state,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Activate the named action within `action_group`.
+     *
+     * If the action is expecting a parameter, then the correct type of
+     * parameter must be given as `parameter`.  If the action is expecting no
+     * parameters then `parameter` must be `NULL`.  See
+     * {@link Gio.ActionGroup.get_action_parameter_type}.
+     *
+     * If the {@link Gio.ActionGroup} implementation supports asynchronous remote
+     * activation over D-Bus, this call may return before the relevant
+     * D-Bus traffic has been sent, or any replies have been received. In
+     * order to block on such asynchronous activation calls,
+     * {@link Gio.DBusConnection.flush} should be called prior to the code, which
+     * depends on the result of the action activation. Without flushing
+     * the D-Bus connection, there is no guarantee that the action would
+     * have been activated.
+     *
+     * The following code which runs in a remote app instance, shows an
+     * example of a ‘quit’ action being activated on the primary app
+     * instance over D-Bus. Here {@link Gio.DBusConnection.flush} is called
+     * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+     * may fail to be activated on the primary instance.
+     *
+     * ```c
+     * // call ‘quit’ action on primary instance
+     * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+     *
+     * // make sure the action is activated now
+     * g_dbus_connection_flush (…);
+     *
+     * g_debug ("Application has been terminated. Exiting.");
+     *
+     * exit (0);
+     * ```
+     * @param actionName - the name of the action to activate
+     * @param parameter - parameters to the activation
+     */
+    activateAction(actionName, parameter) {
+        call("libgio-2.0.so.0", "g_action_group_activate_action", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+            {
+                type: { type: "gvariant" },
+                value: parameter,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Request for the state of the named action within `action_group` to be
+     * changed to `value`.
+     *
+     * The action must be stateful and `value` must be of the correct type.
+     * See {@link Gio.ActionGroup.get_action_state_type}.
+     *
+     * This call merely requests a change.  The action may refuse to change
+     * its state or may change its state to something other than `value`.
+     * See {@link Gio.ActionGroup.get_action_state_hint}.
+     *
+     * If the `value` GVariant is floating, it is consumed.
+     * @param actionName - the name of the action to request the change on
+     * @param value - the new state
+     */
+    changeActionState(actionName, value) {
+        call("libgio-2.0.so.0", "g_action_group_change_action_state", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+            {
+                type: { type: "gvariant" },
+                value: value,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Checks if the named action within `action_group` is currently enabled.
+     *
+     * An action must be enabled in order to be activated or in order to
+     * have its state changed from outside callers.
+     * @param actionName - the name of the action to query
+     */
+    getActionEnabled(actionName) {
+        return call("libgio-2.0.so.0", "g_action_group_get_action_enabled", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Queries the type of the parameter that must be given when activating
+     * the named action within `action_group`.
+     *
+     * When activating the action using {@link Gio.ActionGroup.activate_action},
+     * the {@link GLib.Variant} given to that function must be of the type returned
+     * by this function.
+     *
+     * In the case that this function returns `NULL`, you must not give any
+     * {@link GLib.Variant}, but `NULL` instead.
+     *
+     * The parameter type of a particular action will never change but it is
+     * possible for an action to be removed and for a new action to be added
+     * with the same name but a different parameter type.
+     * @param actionName - the name of the action to query
+     */
+    getActionParameterType(actionName) {
+        const ptr = call("libgio-2.0.so.0", "g_action_group_get_action_parameter_type", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+            getTypeFn: "g_variant_type_get_gtype",
+        });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, GLib.VariantType);
+    }
+    /**
+     * Queries the current state of the named action within `action_group`.
+     *
+     * If the action is not stateful then `NULL` will be returned.  If the
+     * action is stateful then the type of the return value is the type
+     * given by {@link Gio.ActionGroup.get_action_state_type}.
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * {@link GLib.Variant.unref} when it is no longer required.
+     * @param actionName - the name of the action to query
+     */
+    getActionState(actionName) {
+        const ptr = call("libgio-2.0.so.0", "g_action_group_get_action_state", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], { type: "gvariant" });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, GLib.Variant);
+    }
+    /**
+     * Requests a hint about the valid range of values for the state of the
+     * named action within `action_group`.
+     *
+     * If `NULL` is returned it either means that the action is not stateful
+     * or that there is no hint about the valid range of values for the
+     * state of the action.
+     *
+     * If a {@link GLib.Variant} array is returned then each item in the array is a
+     * possible value for the state.  If a {@link GLib.Variant} pair (ie: two-tuple) is
+     * returned then the tuple specifies the inclusive lower and upper bound
+     * of valid values for the state.
+     *
+     * In any case, the information is merely a hint.  It may be possible to
+     * have a state value outside of the hinted range and setting a value
+     * within the range may fail.
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * {@link GLib.Variant.unref} when it is no longer required.
+     * @param actionName - the name of the action to query
+     */
+    getActionStateHint(actionName) {
+        const ptr = call("libgio-2.0.so.0", "g_action_group_get_action_state_hint", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], { type: "gvariant" });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, GLib.Variant);
+    }
+    /**
+     * Queries the type of the state of the named action within
+     * `action_group`.
+     *
+     * If the action is stateful then this function returns the
+     * {@link GLib.VariantType} of the state.  All calls to
+     * {@link Gio.ActionGroup.change_action_state} must give a {@link GLib.Variant} of this
+     * type and {@link Gio.ActionGroup.get_action_state} will return a {@link GLib.Variant}
+     * of the same type.
+     *
+     * If the action is not stateful then this function will return `NULL`.
+     * In that case, {@link Gio.ActionGroup.get_action_state} will return `NULL`
+     * and you must not call {@link Gio.ActionGroup.change_action_state}.
+     *
+     * The state type of a particular action will never change but it is
+     * possible for an action to be removed and for a new action to be added
+     * with the same name but a different state type.
+     * @param actionName - the name of the action to query
+     */
+    getActionStateType(actionName) {
+        const ptr = call("libgio-2.0.so.0", "g_action_group_get_action_state_type", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+            getTypeFn: "g_variant_type_get_gtype",
+        });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr, GLib.VariantType);
+    }
+    /**
+     * Checks if the named action exists within `action_group`.
+     * @param actionName - the name of the action to check for
+     */
+    hasAction(actionName) {
+        return call("libgio-2.0.so.0", "g_action_group_has_action", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Lists the actions contained within `action_group`.
+     *
+     * The caller is responsible for freeing the list with {@link GLib.strfreev} when
+     * it is no longer required.
+     */
+    listActions() {
+        return call("libgio-2.0.so.0", "g_action_group_list_actions", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "array", itemType: { type: "string" } });
+    }
+    /**
+     * Queries all aspects of the named action within an `action_group`.
+     *
+     * This function acquires the information available from
+     * {@link Gio.ActionGroup.has_action}, {@link Gio.ActionGroup.get_action_enabled},
+     * {@link Gio.ActionGroup.get_action_parameter_type},
+     * {@link Gio.ActionGroup.get_action_state_type},
+     * {@link Gio.ActionGroup.get_action_state_hint} and
+     * {@link Gio.ActionGroup.get_action_state} with a single function call.
+     *
+     * This provides two main benefits.
+     *
+     * The first is the improvement in efficiency that comes with not having
+     * to perform repeated lookups of the action in order to discover
+     * different things about it.  The second is that implementing
+     * {@link Gio.ActionGroup} can now be done by only overriding this one virtual
+     * function.
+     *
+     * The interface provides a default implementation of this function that
+     * calls the individual functions, as required, to fetch the
+     * information.  The interface also provides default implementations of
+     * those functions that call this function.  All implementations,
+     * therefore, must override either this function or all of the others.
+     *
+     * If the action exists, `TRUE` is returned and any of the requested
+     * fields (as indicated by having a non-`NULL` reference passed in) are
+     * filled.  If the action doesn’t exist, `FALSE` is returned and the
+     * fields may or may not have been modified.
+     * @param actionName - the name of an action in the group
+     * @param enabled - if the action is presently enabled
+     * @param parameterType - the parameter type, or `NULL` if none needed
+     * @param stateType - the state type, or `NULL` if stateless
+     * @param stateHint - the state hint, or `NULL` if none
+     * @param state - the current state, or `NULL` if stateless
+     */
+    queryAction(actionName, enabled, parameterType, stateType, stateHint, state) {
+        const result = call("libgio-2.0.so.0", "g_action_group_query_action", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+            },
+            {
+                type: { type: "ref", innerType: { type: "boolean" } },
+                value: enabled,
+            },
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "intern",
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GVariantType",
+                        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                        getTypeFn: "g_variant_type_get_gtype",
+                    },
                 },
-                value: value?.id ?? value,
+                value: parameterType,
+                optional: true,
             },
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "intern",
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GVariantType",
+                        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                        getTypeFn: "g_variant_type_get_gtype",
+                    },
                 },
-                value: platformData?.id ?? platformData,
+                value: stateType,
+                optional: true,
             },
-        ], { type: "undefined" });
+            {
+                type: { type: "ref", innerType: { type: "gvariant" } },
+                value: stateHint,
+                optional: true,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gvariant" } },
+                value: state,
+                optional: true,
+            },
+        ], { type: "boolean" });
+        if (parameterType)
+            parameterType.value = getNativeObject(parameterType.value, GLib.VariantType);
+        if (stateType)
+            stateType.value = getNativeObject(stateType.value, GLib.VariantType);
+        return result;
     }
 }

package/dist/generated/gio/resolver.js

@@ -43,7 +43,7 @@ export class Resolver extends GObject.GObject {
             type: "gobject",
             borrowed: true,
         });
-        return getNativeObject(ptr);
+        return getNativeObject(ptr, Resolver);
     }
     /**
      * Get the timeout applied to all resolver lookups. See #GResolver:timeout.
@@ -386,12 +386,7 @@ export class Resolver extends GObject.GObject {
             },
         ], {
             type: "array",
-            itemType: {
-                type: "boxed",
-                innerType: "GVariant",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "intern",
-            },
+            itemType: { type: "gvariant" },
             listType: "glist",
             borrowed: true,
         });
@@ -435,12 +430,7 @@ export class Resolver extends GObject.GObject {
             },
         ], {
             type: "array",
-            itemType: {
-                type: "boxed",
-                innerType: "GVariant",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "intern",
-            },
+            itemType: { type: "gvariant" },
             listType: "glist",
             borrowed: true,
         });
@@ -616,16 +606,17 @@ export class Resolver extends GObject.GObject {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gio/resource.js

@@ -236,7 +236,7 @@ export class Resource extends NativeObject {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getNativeObject(ptr);
+        return getNativeObject(ptr, Resource);
     }
     /**
      * Registers the resource with the process-global set of resources.

package/dist/generated/gio/settings-backend.js

@@ -72,15 +72,7 @@ export class SettingsBackend extends GObject.GObject {
             {
                 type: {
                     type: "ref",
-                    innerType: {
-                        type: "array",
-                        itemType: {
-                            type: "boxed",
-                            innerType: "GVariant",
-                            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                            getTypeFn: "intern",
-                        },
-                    },
+                    innerType: { type: "array", itemType: { type: "gvariant" } },
                 },
                 value: values,
                 optional: true,
@@ -99,7 +91,7 @@ export class SettingsBackend extends GObject.GObject {
             type: "gobject",
             borrowed: true,
         });
-        return getNativeObject(ptr);
+        return getNativeObject(ptr, SettingsBackend);
     }
     /**
      * Signals that a single key has possibly changed.  Backend
@@ -308,7 +300,9 @@ export class SettingsBackend extends GObject.GObject {
         const returnType = undefined;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            const result = handler(self, ...callbackArgs);
+            return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gio/settings-schema-key.js

@@ -39,13 +39,7 @@ export class SettingsSchemaKey extends NativeObject {
                 },
                 value: this.id,
             },
-        ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
-        });
+        ], { type: "gvariant" });
         return getNativeObject(ptr, GLib.Variant);
     }
     /**
@@ -142,13 +136,7 @@ export class SettingsSchemaKey extends NativeObject {
                 },
                 value: this.id,
             },
-        ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
-        });
+        ], { type: "gvariant" });
         return getNativeObject(ptr, GLib.Variant);
     }
     /**
@@ -222,14 +210,8 @@ export class SettingsSchemaKey extends NativeObject {
                 value: this.id,
             },
             {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "intern",
-                },
-                value: value?.id ?? value,
+                type: { type: "gvariant" },
+                value: value,
             },
         ], { type: "boolean" });
     }

package/dist/generated/gio/settings-schema-source.js

@@ -64,7 +64,7 @@ export class SettingsSchemaSource extends NativeObject {
             lib: "libgio-2.0.so.0",
             getTypeFn: "g_settings_schema_source_get_type",
         });
-        return getNativeObject(ptr);
+        return getNativeObject(ptr, SettingsSchemaSource);
     }
     /**
      * Lists the schemas in a given source.