@gtkx/ffi 0.18.5 → 0.18.6

package/src/generated/gdkwayland/wayland-popup.ts

@@ -0,0 +1,247 @@
+import { isInstantiating, setInstantiating } from "../../lifecycle.js";
+import { NativeHandle } from "../../object.js";
+import { call } from "../../native.js";
+import { getNativeObject, registerNativeClass, registerNativeObject } from "../../registry.js";
+import { WaylandSurface } from "./wayland-surface.js";
+import * as Gdk from "../gdk/index.js";
+
+/** The Wayland implementation of `GdkPopup`. */
+export class WaylandPopup extends WaylandSurface {
+    static override readonly glibTypeName: string = "GdkWaylandPopup";
+    static override readonly objectType = "gobject" as const;
+
+    constructor() {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            const gtype = call("libgtk-4.so.1", "gdk_wayland_popup_get_type", [], {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            });
+            this.handle = call(
+                "libgobject-2.0.so.0",
+                "g_object_new",
+                [
+                    { type: { type: "int", size: 64, unsigned: true }, value: gtype, optional: false },
+                    { type: { type: "null" }, value: null, optional: false },
+                ],
+                { type: "gobject", ownership: "full" },
+            ) as NativeHandle;
+            registerNativeObject(this);
+        } else {
+            // @ts-ignore
+            super();
+        }
+    }
+
+    /** Returns whether this popup is set to hide on outside clicks. */
+    getAutohide(): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_popup_get_autohide",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /** Returns the parent surface of a popup. */
+    getParent(): Gdk.Surface | null {
+        const ptr = call(
+            "libgtk-4.so.1",
+            "gdk_popup_get_parent",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "gobject",
+                ownership: "borrowed",
+            },
+        );
+        if (ptr === null) return null;
+        return getNativeObject(ptr as NativeHandle) as Gdk.Surface;
+    }
+
+    /** Obtains the position of the popup relative to its parent. */
+    getPositionX(): number {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_popup_get_position_x",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+        ) as number;
+    }
+
+    /** Obtains the position of the popup relative to its parent. */
+    getPositionY(): number {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_popup_get_position_y",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+        ) as number;
+    }
+
+    /**
+     * Gets the current popup rectangle anchor.
+     *
+     * The value returned may change after calling {@link Gdk.Popup.present},
+     * or after the {@link Gdk.Surface.:layout} signal is emitted.
+     */
+    getRectAnchor(): Gdk.Gravity {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_popup_get_rect_anchor",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "int",
+                size: 32,
+                unsigned: false,
+                library: "libgtk-4.so.1",
+                getTypeFn: "gdk_gravity_get_type",
+            },
+        ) as Gdk.Gravity;
+    }
+
+    /**
+     * Gets the current popup surface anchor.
+     *
+     * The value returned may change after calling {@link Gdk.Popup.present},
+     * or after the {@link Gdk.Surface.:layout} signal is emitted.
+     */
+    getSurfaceAnchor(): Gdk.Gravity {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_popup_get_surface_anchor",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "int",
+                size: 32,
+                unsigned: false,
+                library: "libgtk-4.so.1",
+                getTypeFn: "gdk_gravity_get_type",
+            },
+        ) as Gdk.Gravity;
+    }
+
+    /**
+     * Present `popup` after having processed the `GdkPopupLayout` rules.
+     *
+     * If the popup was previously not showing, it will be shown,
+     * otherwise it will change position according to `layout`.
+     *
+     * After calling this function, the result should be handled in response
+     * to the {@link Gdk.Surface.:layout} signal being emitted. The resulting
+     * popup position can be queried using {@link Gdk.Popup.get_position_x},
+     * {@link Gdk.Popup.get_position_y}, and the resulting size will be sent as
+     * parameters in the layout signal. Use {@link Gdk.Popup.get_rect_anchor}
+     * and {@link Gdk.Popup.get_surface_anchor} to get the resulting anchors.
+     *
+     * Presenting may fail, for example if the `popup` is set to autohide
+     * and is immediately hidden upon being presented. If presenting failed,
+     * the {@link Gdk.Surface.:layout} signal will not me emitted.
+     */
+    present(width: number, height: number, layout: Gdk.PopupLayout): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_popup_present",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    value: width,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    value: height,
+                },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GdkPopupLayout",
+                        library: "libgtk-4.so.1",
+                        getTypeFn: "gdk_popup_layout_get_type",
+                    },
+                    value: layout.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+}
+registerNativeClass(WaylandPopup);

package/src/generated/gdkwayland/wayland-seat.ts

@@ -0,0 +1,45 @@
+import { isInstantiating, setInstantiating } from "../../lifecycle.js";
+import { NativeHandle } from "../../object.js";
+import { call } from "../../native.js";
+import { registerNativeClass, registerNativeObject } from "../../registry.js";
+import * as Gdk from "../gdk/index.js";
+
+/**
+ * The Wayland implementation of `GdkSeat`.
+ *
+ * Beyond the regular {@link Gdk.Seat} API, the Wayland implementation
+ * provides access to the Wayland `wl_seat` object with
+ * {@link GdkWayland.WaylandSeat.get_wl_seat}.
+ */
+export class WaylandSeat extends Gdk.Seat {
+    static override readonly glibTypeName: string = "GdkWaylandSeat";
+    static override readonly objectType = "gobject" as const;
+
+    constructor() {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            const gtype = call("libgtk-4.so.1", "gdk_wayland_seat_get_type", [], {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            });
+            this.handle = call(
+                "libgobject-2.0.so.0",
+                "g_object_new",
+                [
+                    { type: { type: "int", size: 64, unsigned: true }, value: gtype, optional: false },
+                    { type: { type: "null" }, value: null, optional: false },
+                ],
+                { type: "gobject", ownership: "full" },
+            ) as NativeHandle;
+            registerNativeObject(this);
+        } else {
+            // @ts-ignore
+            super();
+        }
+    }
+}
+registerNativeClass(WaylandSeat);

package/src/generated/gdkwayland/wayland-surface.ts

@@ -0,0 +1,65 @@
+import { isInstantiating, setInstantiating } from "../../lifecycle.js";
+import { NativeHandle } from "../../object.js";
+import { call } from "../../native.js";
+import { registerNativeClass, registerNativeObject } from "../../registry.js";
+import * as Gdk from "../gdk/index.js";
+
+/**
+ * The Wayland implementation of `GdkSurface`.
+ *
+ * Beyond the {@link Gdk.Surface} API, the Wayland implementation offers
+ * access to the Wayland `wl_surface` object with
+ * {@link GdkWayland.WaylandSurface.get_wl_surface}.
+ */
+export class WaylandSurface extends Gdk.Surface {
+    static override readonly glibTypeName: string = "GdkWaylandSurface";
+    static override readonly objectType = "gobject" as const;
+
+    constructor() {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            const gtype = call("libgtk-4.so.1", "gdk_wayland_surface_get_type", [], {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            });
+            this.handle = call(
+                "libgobject-2.0.so.0",
+                "g_object_new",
+                [
+                    { type: { type: "int", size: 64, unsigned: true }, value: gtype, optional: false },
+                    { type: { type: "null" }, value: null, optional: false },
+                ],
+                { type: "gobject", ownership: "full" },
+            ) as NativeHandle;
+            registerNativeObject(this);
+        } else {
+            // @ts-ignore
+            super();
+        }
+    }
+
+    /** Forces next commit. */
+    forceNextCommit() {
+        call(
+            "libgtk-4.so.1",
+            "gdk_wayland_surface_force_next_commit",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+}
+registerNativeClass(WaylandSurface);