@gtkx/ffi 0.12.0 → 0.12.1

package/dist/generated/gtk4layershell/enums.d.ts

@@ -0,0 +1,46 @@
+export declare enum Edge {
+    /** The left edge of the screen. */
+    LEFT = 0,
+    /** The right edge of the screen. */
+    RIGHT = 1,
+    /** The top edge of the screen. */
+    TOP = 2,
+    /** The bottom edge of the screen. */
+    BOTTOM = 3,
+    /**
+     * Should not be used except to get the number of entries. (NOTE: may change in
+     * future releases as more entries are added)
+     */
+    ENTRY_NUMBER = 4
+}
+export declare enum KeyboardMode {
+    /** This window should not receive keyboard events. */
+    NONE = 0,
+    /** This window should have exclusive focus if it is on the top or overlay layer. */
+    EXCLUSIVE = 1,
+    /**
+     * The user should be able to focus and unfocues this window in an implementation
+     * defined way. Not supported for protocol version < 4.
+     */
+    ON_DEMAND = 2,
+    /**
+     * Should not be used except to get the number of entries. (NOTE: may change in
+     * future releases as more entries are added)
+     */
+    ENTRY_NUMBER = 3
+}
+export declare enum Layer {
+    /** The background layer. */
+    BACKGROUND = 0,
+    /** The bottom layer. */
+    BOTTOM = 1,
+    /** The top layer. */
+    TOP = 2,
+    /** The overlay layer. */
+    OVERLAY = 3,
+    /**
+     * Should not be used except to get the number of entries. (NOTE: may change in
+     * future releases as more entries are added)
+     */
+    ENTRY_NUMBER = 4
+}

package/dist/generated/gtk4layershell/enums.js

@@ -0,0 +1,49 @@
+export var Edge;
+(function (Edge) {
+    /** The left edge of the screen. */
+    Edge[Edge["LEFT"] = 0] = "LEFT";
+    /** The right edge of the screen. */
+    Edge[Edge["RIGHT"] = 1] = "RIGHT";
+    /** The top edge of the screen. */
+    Edge[Edge["TOP"] = 2] = "TOP";
+    /** The bottom edge of the screen. */
+    Edge[Edge["BOTTOM"] = 3] = "BOTTOM";
+    /**
+     * Should not be used except to get the number of entries. (NOTE: may change in
+     * future releases as more entries are added)
+     */
+    Edge[Edge["ENTRY_NUMBER"] = 4] = "ENTRY_NUMBER";
+})(Edge || (Edge = {}));
+export var KeyboardMode;
+(function (KeyboardMode) {
+    /** This window should not receive keyboard events. */
+    KeyboardMode[KeyboardMode["NONE"] = 0] = "NONE";
+    /** This window should have exclusive focus if it is on the top or overlay layer. */
+    KeyboardMode[KeyboardMode["EXCLUSIVE"] = 1] = "EXCLUSIVE";
+    /**
+     * The user should be able to focus and unfocues this window in an implementation
+     * defined way. Not supported for protocol version < 4.
+     */
+    KeyboardMode[KeyboardMode["ON_DEMAND"] = 2] = "ON_DEMAND";
+    /**
+     * Should not be used except to get the number of entries. (NOTE: may change in
+     * future releases as more entries are added)
+     */
+    KeyboardMode[KeyboardMode["ENTRY_NUMBER"] = 3] = "ENTRY_NUMBER";
+})(KeyboardMode || (KeyboardMode = {}));
+export var Layer;
+(function (Layer) {
+    /** The background layer. */
+    Layer[Layer["BACKGROUND"] = 0] = "BACKGROUND";
+    /** The bottom layer. */
+    Layer[Layer["BOTTOM"] = 1] = "BOTTOM";
+    /** The top layer. */
+    Layer[Layer["TOP"] = 2] = "TOP";
+    /** The overlay layer. */
+    Layer[Layer["OVERLAY"] = 3] = "OVERLAY";
+    /**
+     * Should not be used except to get the number of entries. (NOTE: may change in
+     * future releases as more entries are added)
+     */
+    Layer[Layer["ENTRY_NUMBER"] = 4] = "ENTRY_NUMBER";
+})(Layer || (Layer = {}));

package/dist/generated/gtk4layershell/functions.d.ts

@@ -0,0 +1,99 @@
+import { Edge, KeyboardMode, Layer } from "./enums.js";
+import * as Gdk from "../gdk/index.js";
+import * as Gtk from "../gtk/index.js";
+/**
+ * When auto exclusive zone is enabled, exclusive zone is automatically set to the
+ * size of the `window` + relevant margin. To disable auto exclusive zone, just set the
+ * exclusive zone to 0 or any other fixed value.
+ *
+ * NOTE: you can control the auto exclusive zone by changing the margin on the non-anchored
+ * edge. This behavior is specific to gtk4-layer-shell and not part of the underlying protocol
+ */
+export declare const autoExclusiveZoneEnable: (window: Gtk.Window) => void;
+export declare const autoExclusiveZoneIsEnabled: (window: Gtk.Window) => boolean;
+export declare const getAnchor: (window: Gtk.Window, edge: Edge) => boolean;
+export declare const getExclusiveZone: (window: Gtk.Window) => number;
+export declare const getKeyboardMode: (window: Gtk.Window) => KeyboardMode;
+export declare const getLayer: (window: Gtk.Window) => Layer;
+export declare const getMajorVersion: () => number;
+export declare const getMargin: (window: Gtk.Window, edge: Edge) => number;
+export declare const getMicroVersion: () => number;
+export declare const getMinorVersion: () => number;
+/**
+ * NOTE: To get which monitor the surface is actually on, use
+ * gdk_display_get_monitor_at_window().
+ */
+export declare const getMonitor: (window: Gtk.Window) => Gdk.Monitor;
+/**
+ * NOTE: this function does not return ownership of the string. Do not free the returned string.
+ * Future calls into the library may invalidate the returned string.
+ */
+export declare const getNamespace: (window: Gtk.Window) => string;
+/** May block for a Wayland roundtrip the first time it's called. */
+export declare const getProtocolVersion: () => number;
+export declare const getZwlrLayerSurfaceV1: (window: Gtk.Window) => number | null;
+/**
+ * Set the `window` up to be a layer surface once it is mapped. this must be called before
+ * the `window` is realized.
+ */
+export declare const initForWindow: (window: Gtk.Window) => void;
+export declare const isLayerWindow: (window: Gtk.Window) => boolean;
+/** May block for a Wayland roundtrip the first time it's called. */
+export declare const isSupported: () => boolean;
+/**
+ * Set whether `window` should be anchored to `edge`.
+ * - If two perpendicular edges are anchored, the surface with be anchored to that corner
+ * - If two opposite edges are anchored, the window will be stretched across the screen in that direction
+ *
+ * Default is %FALSE for each #GtkLayerShellEdge
+ */
+export declare const setAnchor: (window: Gtk.Window, edge: Edge, anchorToEdge: boolean) => void;
+/**
+ * Has no effect unless the surface is anchored to an edge. Requests that the compositor
+ * does not place other surfaces within the given exclusive zone of the anchored edge.
+ * For example, a panel can request to not be covered by maximized windows. See
+ * wlr-layer-shell-unstable-v1.xml for details.
+ *
+ * Default is 0
+ */
+export declare const setExclusiveZone: (window: Gtk.Window, exclusiveZone: number) => void;
+/**
+ * Sets if/when `window` should receive keyboard events from the compositor, see
+ * GtkLayerShellKeyboardMode for details.
+ *
+ * Default is %GTK_LAYER_SHELL_KEYBOARD_MODE_NONE
+ */
+export declare const setKeyboardMode: (window: Gtk.Window, mode: KeyboardMode) => void;
+/**
+ * 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.
+ *
+ * Default is %GTK_LAYER_SHELL_LAYER_TOP
+ */
+export declare const setLayer: (window: Gtk.Window, layer: Layer) => void;
+/**
+ * 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).
+ *
+ * Default is 0 for each #GtkLayerShellEdge
+ */
+export declare const setMargin: (window: Gtk.Window, edge: Edge, marginSize: number) => void;
+/**
+ * Set the output for the window to be placed on, or %NULL to let the compositor choose.
+ * If the window is currently mapped, it will get remapped so the change can take effect.
+ *
+ * Default is %NULL
+ */
+export declare const setMonitor: (window: Gtk.Window, monitor: Gdk.Monitor) => void;
+/**
+ * Set the "namespace" of the surface.
+ *
+ * No one is quite sure what this is for, but it probably should be something generic
+ * ("panel", "osk", etc). The `name_space` string is copied, and caller maintains
+ * ownership of original. If the window is currently mapped, it will get remapped so
+ * the change can take effect.
+ *
+ * Default is "gtk4-layer-shell" (which will be used if set to %NULL)
+ */
+export declare const setNamespace: (window: Gtk.Window, nameSpace: string) => void;

package/dist/generated/gtk4layershell/functions.js

@@ -0,0 +1,451 @@
+import { call } from "../../batch.js";
+import { getNativeObject } from "../../native/object.js";
+/**
+ * When auto exclusive zone is enabled, exclusive zone is automatically set to the
+ * size of the `window` + relevant margin. To disable auto exclusive zone, just set the
+ * exclusive zone to 0 or any other fixed value.
+ *
+ * NOTE: you can control the auto exclusive zone by changing the margin on the non-anchored
+ * edge. This behavior is specific to gtk4-layer-shell and not part of the underlying protocol
+ */
+export const autoExclusiveZoneEnable = (window) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_auto_exclusive_zone_enable", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+export const autoExclusiveZoneIsEnabled = (window) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_auto_exclusive_zone_is_enabled", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "boolean",
+    });
+};
+export const getAnchor = (window, edge) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_anchor", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: edge,
+        },
+    ], {
+        type: "boolean",
+    });
+};
+export const getExclusiveZone = (window) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_exclusive_zone", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
+};
+export const getKeyboardMode = (window) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_keyboard_mode", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
+};
+export const getLayer = (window) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_layer", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
+};
+export const getMajorVersion = () => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_major_version", [], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
+};
+export const getMargin = (window, edge) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_margin", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: edge,
+        },
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
+};
+export const getMicroVersion = () => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_micro_version", [], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
+};
+export const getMinorVersion = () => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_minor_version", [], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
+};
+/**
+ * NOTE: To get which monitor the surface is actually on, use
+ * gdk_display_get_monitor_at_window().
+ */
+export const getMonitor = (window) => {
+    const ptr = call("libgtk4-layer-shell.so.0", "gtk_layer_get_monitor", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "gobject",
+        ownership: "borrowed",
+    });
+    return getNativeObject(ptr);
+};
+/**
+ * NOTE: this function does not return ownership of the string. Do not free the returned string.
+ * Future calls into the library may invalidate the returned string.
+ */
+export const getNamespace = (window) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_namespace", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "string",
+        ownership: "borrowed",
+    });
+};
+/** May block for a Wayland roundtrip the first time it's called. */
+export const getProtocolVersion = () => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_protocol_version", [], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
+};
+export const getZwlrLayerSurfaceV1 = (window) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_get_zwlr_layer_surface_v1", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "int",
+        size: 64,
+        unsigned: true,
+    });
+};
+/**
+ * Set the `window` up to be a layer surface once it is mapped. this must be called before
+ * the `window` is realized.
+ */
+export const initForWindow = (window) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_init_for_window", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+export const isLayerWindow = (window) => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_is_layer_window", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+    ], {
+        type: "boolean",
+    });
+};
+/** May block for a Wayland roundtrip the first time it's called. */
+export const isSupported = () => {
+    return call("libgtk4-layer-shell.so.0", "gtk_layer_is_supported", [], {
+        type: "boolean",
+    });
+};
+/**
+ * Set whether `window` should be anchored to `edge`.
+ * - If two perpendicular edges are anchored, the surface with be anchored to that corner
+ * - If two opposite edges are anchored, the window will be stretched across the screen in that direction
+ *
+ * Default is %FALSE for each #GtkLayerShellEdge
+ */
+export const setAnchor = (window, edge, anchorToEdge) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_set_anchor", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: edge,
+        },
+        {
+            type: {
+                type: "boolean",
+            },
+            value: anchorToEdge,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * Has no effect unless the surface is anchored to an edge. Requests that the compositor
+ * does not place other surfaces within the given exclusive zone of the anchored edge.
+ * For example, a panel can request to not be covered by maximized windows. See
+ * wlr-layer-shell-unstable-v1.xml for details.
+ *
+ * Default is 0
+ */
+export const setExclusiveZone = (window, exclusiveZone) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_set_exclusive_zone", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: exclusiveZone,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * Sets if/when `window` should receive keyboard events from the compositor, see
+ * GtkLayerShellKeyboardMode for details.
+ *
+ * Default is %GTK_LAYER_SHELL_KEYBOARD_MODE_NONE
+ */
+export const setKeyboardMode = (window, mode) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_set_keyboard_mode", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: mode,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * 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.
+ *
+ * Default is %GTK_LAYER_SHELL_LAYER_TOP
+ */
+export const setLayer = (window, layer) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_set_layer", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: layer,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * 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).
+ *
+ * Default is 0 for each #GtkLayerShellEdge
+ */
+export const setMargin = (window, edge, marginSize) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_set_margin", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: edge,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: marginSize,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * Set the output for the window to be placed on, or %NULL to let the compositor choose.
+ * If the window is currently mapped, it will get remapped so the change can take effect.
+ *
+ * Default is %NULL
+ */
+export const setMonitor = (window, monitor) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_set_monitor", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: monitor.handle,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * Set the "namespace" of the surface.
+ *
+ * No one is quite sure what this is for, but it probably should be something generic
+ * ("panel", "osk", etc). The `name_space` string is copied, and caller maintains
+ * ownership of original. If the window is currently mapped, it will get remapped so
+ * the change can take effect.
+ *
+ * Default is "gtk4-layer-shell" (which will be used if set to %NULL)
+ */
+export const setNamespace = (window, nameSpace) => {
+    call("libgtk4-layer-shell.so.0", "gtk_layer_set_namespace", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+            value: window.handle,
+        },
+        {
+            type: {
+                type: "string",
+                ownership: "borrowed",
+            },
+            value: nameSpace,
+        },
+    ], {
+        type: "undefined",
+    });
+};

package/dist/generated/gtk4layershell/index.d.ts

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

package/dist/generated/gtk4layershell/index.js

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

package/dist/generated/javascriptcore/constants.d.ts

@@ -9,7 +9,7 @@ export declare const MAJOR_VERSION = 2;
  * application compile time, rather than from the library linked
  * against at application run time.
  */
-export declare const MICRO_VERSION = 3;
+export declare const MICRO_VERSION = 4;
 /**
  * Like jsc_get_minor_version(), but from the headers used at
  * application compile time, rather than from the library linked

package/dist/generated/javascriptcore/constants.js

@@ -9,7 +9,7 @@ export const MAJOR_VERSION = 2;
  * application compile time, rather than from the library linked
  * against at application run time.
  */
-export const MICRO_VERSION = 3;
+export const MICRO_VERSION = 4;
 /**
  * Like jsc_get_minor_version(), but from the headers used at
  * application compile time, rather than from the library linked

package/dist/generated/webkit/constants.d.ts

@@ -83,7 +83,7 @@ export declare const MAJOR_VERSION = 2;
  * application compile time, rather than from the library linked
  * against at application run time.
  */
-export declare const MICRO_VERSION = 3;
+export declare const MICRO_VERSION = 4;
 /**
  * Like webkit_get_minor_version(), but from the headers used at
  * application compile time, rather than from the library linked

package/dist/generated/webkit/constants.js

@@ -83,7 +83,7 @@ export const MAJOR_VERSION = 2;
  * application compile time, rather than from the library linked
  * against at application run time.
  */
-export const MICRO_VERSION = 3;
+export const MICRO_VERSION = 4;
 /**
  * Like webkit_get_minor_version(), but from the headers used at
  * application compile time, rather than from the library linked

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gtkx/ffi",
-  "version": "0.12.0",
-  "description": "Generated TypeScript FFI bindings for GTK4 libraries",
+  "version": "0.12.1",
+  "description": "Generated TypeScript FFI bindings for GTKX",
   "keywords": [
     "gtkx",
     "gtk",
@@ -47,10 +47,10 @@
     "dist"
   ],
   "dependencies": {
-    "@gtkx/native": "0.12.0"
+    "@gtkx/native": "0.12.1"
   },
   "devDependencies": {
-    "@gtkx/vitest": "0.12.0"
+    "@gtkx/vitest": "0.12.1"
   },
   "scripts": {
     "build": "tsc -b && cp ../../README.md .",