@gtkx/ffi 0.18.4 → 0.18.6

package/src/generated/gst/constants.ts

@@ -662,7 +662,7 @@ export const VALUE_UNORDERED = 2;
 /** The major version of GStreamer at compile time: */
 export const VERSION_MAJOR = 1;
 /** The micro version of GStreamer at compile time: */
-export const VERSION_MICRO = 9;
+export const VERSION_MICRO = 10;
 /** The minor version of GStreamer at compile time: */
 export const VERSION_MINOR = 26;
 /**

package/src/generated/gtk4layershell/functions.ts

@@ -186,9 +186,9 @@ export const getMinorVersion = (): number => {
 };
 /**
  * NOTE: To get which monitor the surface is actually on, use
- * gdk_display_get_monitor_at_window().
+ * gdk_display_get_monitor_at_surface().
  */
-export const getMonitor = (window: Gtk.Window): Gdk.Monitor => {
+export const getMonitor = (window: Gtk.Window): Gdk.Monitor | null => {
     const ptr = call(
         "libgtk4-layer-shell.so.0",
         "gtk_layer_get_monitor",
@@ -206,6 +206,7 @@ export const getMonitor = (window: Gtk.Window): Gdk.Monitor => {
             ownership: "borrowed",
         },
     );
+    if (ptr === null) return null;
     return getNativeObject(ptr as NativeHandle) as Gdk.Monitor;
 };
 /**
@@ -239,6 +240,24 @@ export const getProtocolVersion = (): number => {
         unsigned: true,
     }) as number;
 };
+export const getRespectClose = (window: Gtk.Window): boolean => {
+    return call(
+        "libgtk4-layer-shell.so.0",
+        "gtk_layer_get_respect_close",
+        [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: window.handle,
+            },
+        ],
+        {
+            type: "boolean",
+        },
+    ) as boolean;
+};
 /**
  * Set the `window` up to be a layer surface once it is mapped. this must be called before
  * the `window` is realized.
@@ -360,7 +379,8 @@ export const setExclusiveZone = (window: Gtk.Window, exclusiveZone: number) => {
 };
 /**
  * Sets if/when `window` should receive keyboard events from the compositor, see
- * GtkLayerShellKeyboardMode for details.
+ * GtkLayerShellKeyboardMode for details. To control mouse/touch interactivity use input regions,
+ * see [#61](https://github.com/wmww/gtk4-layer-shell/issues/61) for details.
  *
  * Default is %GTK_LAYER_SHELL_KEYBOARD_MODE_NONE
  */
@@ -391,7 +411,7 @@ export const setKeyboardMode = (window: Gtk.Window, mode: KeyboardMode) => {
     );
 };
 /**
- * Set the "layer" on which the surface appears (controls if it is over top of or below other surfaces). The layer may
+ * Set the "layer" on which the surface appears(controls if it is over top of or below other surfaces). The layer may
  * be changed on-the-fly in the current version of the layer shell protocol, but on compositors that only support an
  * older version the `window` is remapped so the change can take effect.
  *
@@ -425,7 +445,7 @@ export const setLayer = (window: Gtk.Window, layer: Layer) => {
 };
 /**
  * Set the margin for a specific `edge` of a `window`. Effects both surface's distance from
- * the edge and its exclusive zone size (if auto exclusive zone enabled).
+ * the edge and its exclusive zone size(if auto exclusive zone enabled).
  *
  * Default is 0 for each #GtkLayerShellEdge
  */
@@ -469,7 +489,7 @@ export const setMargin = (window: Gtk.Window, edge: Edge, marginSize: number) =>
  *
  * Default is %NULL
  */
-export const setMonitor = (window: Gtk.Window, monitor: Gdk.Monitor) => {
+export const setMonitor = (window: Gtk.Window, monitor?: Gdk.Monitor | null) => {
     call(
         "libgtk4-layer-shell.so.0",
         "gtk_layer_set_monitor",
@@ -486,7 +506,8 @@ export const setMonitor = (window: Gtk.Window, monitor: Gdk.Monitor) => {
                     type: "gobject",
                     ownership: "borrowed",
                 },
-                value: monitor.handle,
+                value: monitor?.handle,
+                optional: true,
             },
         ],
         {
@@ -504,7 +525,7 @@ export const setMonitor = (window: Gtk.Window, monitor: Gdk.Monitor) => {
  *
  * Default is "gtk4-layer-shell" (which will be used if set to %NULL)
  */
-export const setNamespace = (window: Gtk.Window, nameSpace: string) => {
+export const setNamespace = (window: Gtk.Window, nameSpace?: string | null) => {
     call(
         "libgtk4-layer-shell.so.0",
         "gtk_layer_set_namespace",
@@ -522,6 +543,39 @@ export const setNamespace = (window: Gtk.Window, nameSpace: string) => {
                     ownership: "borrowed",
                 },
                 value: nameSpace,
+                optional: true,
+            },
+        ],
+        {
+            type: "undefined",
+        },
+    );
+};
+/**
+ * Compositors may send the `zwlr_layer_surface_v1.closed` event in some cases (such as
+ * when an output is destroyed). Prior to v1.3 this always triggered a GTK `close-request`
+ * signal, which would destroy the window if not intercepted by application code. In v1.3+
+ * this behavior is disabled by default, and can be turned back on by calling this
+ * function with %TRUE. To handle the `.closed` event without destroying your window
+ * turn respect_close on and connect a `close-request` listener that returns %TRUE.
+ */
+export const setRespectClose = (window: Gtk.Window, respectClose: boolean) => {
+    call(
+        "libgtk4-layer-shell.so.0",
+        "gtk_layer_set_respect_close",
+        [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: window.handle,
+            },
+            {
+                type: {
+                    type: "boolean",
+                },
+                value: respectClose,
             },
         ],
         {

package/src/generated/gtk4sessionlock/functions.ts

@@ -0,0 +1,8 @@
+import { call } from "../../native.js";
+
+/** May block for a Wayland roundtrip the first time it's called. */
+export const isSupported = (): boolean => {
+    return call("libgtk4-layer-shell.so.0", "gtk_session_lock_is_supported", [], {
+        type: "boolean",
+    }) as boolean;
+};

package/src/generated/gtk4sessionlock/index.ts

@@ -0,0 +1,2 @@
+export * from "./functions.js";
+export * from "./instance.js";

package/src/generated/gtk4sessionlock/instance.ts

@@ -0,0 +1,271 @@
+import { isInstantiating, setInstantiating } from "../../lifecycle.js";
+import { NativeHandle } from "../../object.js";
+import { call } from "../../native.js";
+import { getNativeObject, registerNativeClass, registerNativeObject } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
+import * as Gtk from "../gtk/index.js";
+
+/**
+ * An instance of the object used to control locking the screen.
+ * Multiple instances can exist at once, but only one can be locked at a time.
+ */
+export class Instance extends GObject.Object {
+    static override readonly glibTypeName: string = "GtkSessionLockInstance";
+    static override readonly objectType = "gobject" as const;
+
+    constructor() {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            this.handle = call("libgtk4-layer-shell.so.0", "gtk_session_lock_instance_new", [], {
+                type: "gobject",
+                ownership: "full",
+            }) as NativeHandle;
+            registerNativeObject(this);
+        } else {
+            // @ts-ignore
+            super();
+        }
+    }
+
+    /**
+     * This must be called with a different unrealized window once for each monitor immediately after calling
+     * gtk_session_lock_lock(). Hiding a window that is active on a monitor or not letting a window be resized by the
+     * library is not allowed (may result in a Wayland protocol error). The window will be unmapped and gtk_window_destroy()
+     * called on it when the current lock ends.
+     */
+    assignWindowToMonitor(window: Gtk.Window, monitor: Gdk.Monitor) {
+        call(
+            "libgtk4-layer-shell.so.0",
+            "gtk_session_lock_instance_assign_window_to_monitor",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: window.handle,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: monitor.handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /** Returns if this instance currently holds a lock. */
+    isLocked(): boolean {
+        return call(
+            "libgtk4-layer-shell.so.0",
+            "gtk_session_lock_instance_is_locked",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /**
+     * Lock the screen. This should be called before assigning any windows to monitors. If this function fails the ::failed
+     * signal is emitted, if it succeeds the ::locked signal is emitted. The ::failed signal may be emitted before the
+     * function returns (for example, if another #GtkSessionLockInstance holds a lock) or later (if another process holds a
+     * lock). The only case where neither signal is triggered is if the instance is already locked.
+     */
+    lock(): boolean {
+        return call(
+            "libgtk4-layer-shell.so.0",
+            "gtk_session_lock_instance_lock",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /** If the screen is locked by this instance unlocks it and fires ::unlocked. Otherwise has no effect */
+    unlock() {
+        call(
+            "libgtk4-layer-shell.so.0",
+            "gtk_session_lock_instance_unlock",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    connect(signal: "failed", handler: (self: Instance) => void, after?: boolean): number;
+    connect(signal: "locked", handler: (self: Instance) => void, after?: boolean): number;
+    connect(signal: "monitor", handler: (self: Instance, monitor: Gdk.Monitor) => void, after?: boolean): number;
+    connect(signal: "unlocked", handler: (self: Instance) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
+    /**
+     * Connects a handler to a signal on this Instance.
+     *
+     * @param signal - The signal name to connect to
+     * @param handler - Callback function invoked when signal is emitted
+     * @param after - If true, handler is called after default handler
+     * @returns Connection ID for disconnecting
+     */
+    connect(signal: string, handler: (...args: any[]) => any, after = false): number {
+        switch (signal) {
+            case "failed": {
+                const wrappedHandler = (...args: unknown[]) => {
+                    return handler(getNativeObject(args[0] as NativeHandle) as Instance);
+                };
+                return call(
+                    "libgtk4-layer-shell.so.0",
+                    "g_signal_connect_closure",
+                    [
+                        { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                        { type: { type: "string", ownership: "borrowed" }, value: signal },
+                        {
+                            type: {
+                                type: "callback",
+                                argTypes: [{ type: "gobject", ownership: "borrowed" }],
+                                returnType: {
+                                    type: "undefined",
+                                },
+                                kind: "closure",
+                            },
+                            value: wrappedHandler,
+                        },
+                        { type: { type: "boolean" }, value: after },
+                    ],
+                    { type: "int", size: 64, unsigned: true },
+                ) as number;
+            }
+            case "locked": {
+                const wrappedHandler = (...args: unknown[]) => {
+                    return handler(getNativeObject(args[0] as NativeHandle) as Instance);
+                };
+                return call(
+                    "libgtk4-layer-shell.so.0",
+                    "g_signal_connect_closure",
+                    [
+                        { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                        { type: { type: "string", ownership: "borrowed" }, value: signal },
+                        {
+                            type: {
+                                type: "callback",
+                                argTypes: [{ type: "gobject", ownership: "borrowed" }],
+                                returnType: {
+                                    type: "undefined",
+                                },
+                                kind: "closure",
+                            },
+                            value: wrappedHandler,
+                        },
+                        { type: { type: "boolean" }, value: after },
+                    ],
+                    { type: "int", size: 64, unsigned: true },
+                ) as number;
+            }
+            case "monitor": {
+                const wrappedHandler = (...args: unknown[]) => {
+                    return handler(
+                        getNativeObject(args[0] as NativeHandle) as Instance,
+                        getNativeObject(args[1] as NativeHandle) as Gdk.Monitor,
+                    );
+                };
+                return call(
+                    "libgtk4-layer-shell.so.0",
+                    "g_signal_connect_closure",
+                    [
+                        { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                        { type: { type: "string", ownership: "borrowed" }, value: signal },
+                        {
+                            type: {
+                                type: "callback",
+                                argTypes: [
+                                    { type: "gobject", ownership: "borrowed" },
+                                    {
+                                        type: "gobject",
+                                        ownership: "borrowed",
+                                    },
+                                ],
+                                returnType: {
+                                    type: "undefined",
+                                },
+                                kind: "closure",
+                            },
+                            value: wrappedHandler,
+                        },
+                        { type: { type: "boolean" }, value: after },
+                    ],
+                    { type: "int", size: 64, unsigned: true },
+                ) as number;
+            }
+            case "unlocked": {
+                const wrappedHandler = (...args: unknown[]) => {
+                    return handler(getNativeObject(args[0] as NativeHandle) as Instance);
+                };
+                return call(
+                    "libgtk4-layer-shell.so.0",
+                    "g_signal_connect_closure",
+                    [
+                        { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                        { type: { type: "string", ownership: "borrowed" }, value: signal },
+                        {
+                            type: {
+                                type: "callback",
+                                argTypes: [{ type: "gobject", ownership: "borrowed" }],
+                                returnType: {
+                                    type: "undefined",
+                                },
+                                kind: "closure",
+                            },
+                            value: wrappedHandler,
+                        },
+                        { type: { type: "boolean" }, value: after },
+                    ],
+                    { type: "int", size: 64, unsigned: true },
+                ) as number;
+            }
+            default:
+                return super.connect(signal, handler, after);
+        }
+    }
+}
+registerNativeClass(Instance);

package/src/generated/vte/constants.ts

@@ -7,7 +7,7 @@ export const MAJOR_VERSION = 0;
  * The micro version number of the VTE library
  * (e.g. in version 3.1.4 this is 4).
  */
-export const MICRO_VERSION = 2;
+export const MICRO_VERSION = 3;
 /**
  * The minor version number of the VTE library
  * (e.g. in version 3.1.4 this is 1).