@gtkx/ffi 0.18.5 → 0.18.6

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

@@ -0,0 +1,1260 @@
+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 GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
+
+/**
+ * The Wayland implementation of `GdkToplevel`.
+ *
+ * Beyond the {@link Gdk.Toplevel} API, the Wayland implementation
+ * has API to set up cross-process parent-child relationships between
+ * surfaces with {@link GdkWayland.WaylandToplevel.export_handle} and
+ * {@link GdkWayland.WaylandToplevel.set_transient_for_exported}.
+ */
+export class WaylandToplevel extends WaylandSurface {
+    static override readonly glibTypeName: string = "GdkWaylandToplevel";
+    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_toplevel_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();
+        }
+    }
+
+    /**
+     * Destroy a handle that was obtained with gdk_wayland_toplevel_export_handle().
+     *
+     * Note that this API depends on an unstable Wayland protocol,
+     * and thus may require changes in the future.
+     */
+    dropExportedHandle(handle: string) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_wayland_toplevel_drop_exported_handle",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "borrowed",
+                    },
+                    value: handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /** Sets the application id on a `GdkToplevel`. */
+    setApplicationId(applicationId: string) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_wayland_toplevel_set_application_id",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "borrowed",
+                    },
+                    value: applicationId,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Marks `toplevel` as transient for the surface to which the given
+     * `parent_handle_str` refers.
+     *
+     * Typically, the handle will originate from a
+     * {@link GdkWayland.WaylandToplevel.export_handle} call in another process.
+     *
+     * Note that this API depends on an unstable Wayland protocol,
+     * and thus may require changes in the future.
+     */
+    setTransientForExported(parentHandleStr: string): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_wayland_toplevel_set_transient_for_exported",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "borrowed",
+                    },
+                    value: parentHandleStr,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /**
+     * Destroys the handle that was obtained with
+     * gdk_wayland_toplevel_export_handle().
+     *
+     * It is an error to call this function on a surface that
+     * does not have a handle.
+     *
+     * Since 4.12, this function does nothing. Use
+     * {@link GdkWayland.WaylandToplevel.drop_exported_handle} instead to drop a
+     * handle that was obtained with {@link GdkWayland.WaylandToplevel.export_handle}.
+     *
+     * Note that this API depends on an unstable Wayland protocol,
+     * and thus may require changes in the future.
+     */
+    unexportHandle() {
+        call(
+            "libgtk-4.so.1",
+            "gdk_wayland_toplevel_unexport_handle",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Begins an interactive move operation.
+     *
+     * You might use this function to implement draggable titlebars.
+     */
+    beginMove(device: Gdk.Device, button: number, x: number, y: number, timestamp: number) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_begin_move",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: device.handle,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    value: button,
+                },
+                {
+                    type: {
+                        type: "float",
+                        size: 64,
+                    },
+                    value: x,
+                },
+                {
+                    type: {
+                        type: "float",
+                        size: 64,
+                    },
+                    value: y,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                    value: timestamp,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Begins an interactive resize operation.
+     *
+     * You might use this function to implement a “window resize grip.”
+     */
+    beginResize(
+        edge: Gdk.SurfaceEdge,
+        button: number,
+        x: number,
+        y: number,
+        timestamp: number,
+        device?: Gdk.Device | null,
+    ) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_begin_resize",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                        library: "libgtk-4.so.1",
+                        getTypeFn: "gdk_surface_edge_get_type",
+                    },
+                    value: edge,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: device?.handle,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    value: button,
+                },
+                {
+                    type: {
+                        type: "float",
+                        size: 64,
+                    },
+                    value: x,
+                },
+                {
+                    type: {
+                        type: "float",
+                        size: 64,
+                    },
+                    value: y,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                    value: timestamp,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets keyboard focus to `surface`.
+     *
+     * In most cases, gtk_window_present_with_time()
+     * should be used on a GtkWindow, rather than
+     * calling this function.
+     */
+    focus(timestamp: number) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_focus",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                    value: timestamp,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /** The capabilities that are available for this toplevel. */
+    getCapabilities(): Gdk.ToplevelCapabilities {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_get_capabilities",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "int",
+                size: 32,
+                unsigned: true,
+                library: "libgtk-4.so.1",
+                getTypeFn: "gdk_toplevel_capabilities_get_type",
+            },
+        ) as Gdk.ToplevelCapabilities;
+    }
+
+    /**
+     * Returns the gravity that is used when changing the toplevel
+     * size programmatically.
+     */
+    getGravity(): Gdk.Gravity {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_get_gravity",
+            [
+                {
+                    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 bitwise or of the currently active surface state flags,
+     * from the `GdkToplevelState` enumeration.
+     */
+    getState(): Gdk.ToplevelState {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_get_state",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "int",
+                size: 32,
+                unsigned: true,
+                library: "libgtk-4.so.1",
+                getTypeFn: "gdk_toplevel_state_get_type",
+            },
+        ) as Gdk.ToplevelState;
+    }
+
+    /**
+     * Requests that the `toplevel` inhibit the system shortcuts.
+     *
+     * This is asking the desktop environment/windowing system to let all
+     * keyboard events reach the surface, as long as it is focused, instead
+     * of triggering system actions.
+     *
+     * If granted, the rerouting remains active until the default shortcuts
+     * processing is restored with {@link Gdk.Toplevel.restore_system_shortcuts},
+     * or the request is revoked by the desktop environment, windowing system
+     * or the user.
+     *
+     * A typical use case for this API is remote desktop or virtual machine
+     * viewers which need to inhibit the default system keyboard shortcuts
+     * so that the remote session or virtual host gets those instead of the
+     * local environment.
+     *
+     * The windowing system or desktop environment may ask the user to grant
+     * or deny the request or even choose to ignore the request entirely.
+     *
+     * The caller can be notified whenever the request is granted or revoked
+     * by listening to the {@link Gdk.Toplevel.shortcuts-inhibited} property.
+     */
+    inhibitSystemShortcuts(event?: Gdk.Event | null) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_inhibit_system_shortcuts",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "fundamental",
+                        ownership: "borrowed",
+                        library: "libgtk-4.so.1",
+                        refFn: "gdk_event_ref",
+                        unrefFn: "gdk_event_unref",
+                    },
+                    value: event?.handle,
+                    optional: true,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Asks to lower the `toplevel` below other windows.
+     *
+     * The windowing system may choose to ignore the request.
+     */
+    lower(): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_lower",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /**
+     * Asks to minimize the `toplevel`.
+     *
+     * The windowing system may choose to ignore the request.
+     */
+    minimize(): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_minimize",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /**
+     * Present `toplevel` after having processed the `GdkToplevelLayout` rules.
+     *
+     * If the toplevel was previously not showing, it will be showed,
+     * otherwise it will change layout according to `layout`.
+     *
+     * GDK may emit the {@link Gdk.Toplevel.:compute-size} signal to let
+     * the user of this toplevel compute the preferred size of the toplevel
+     * surface.
+     *
+     * Presenting is asynchronous and the specified layout parameters are not
+     * guaranteed to be respected.
+     */
+    present(layout: Gdk.ToplevelLayout) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_present",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GdkToplevelLayout",
+                        library: "libgtk-4.so.1",
+                        getTypeFn: "gdk_toplevel_layout_get_type",
+                    },
+                    value: layout.handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Restore default system keyboard shortcuts which were previously
+     * inhibited.
+     *
+     * This undoes the effect of {@link Gdk.Toplevel.inhibit_system_shortcuts}.
+     */
+    restoreSystemShortcuts() {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_restore_system_shortcuts",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets the toplevel to be decorated.
+     *
+     * Setting `decorated` to %FALSE hints the desktop environment
+     * that the surface has its own, client-side decorations and
+     * does not need to have window decorations added.
+     */
+    setDecorated(decorated: boolean) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_decorated",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "boolean",
+                    },
+                    value: decorated,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets the toplevel to be deletable.
+     *
+     * Setting `deletable` to %TRUE hints the desktop environment
+     * that it should offer the user a way to close the surface.
+     */
+    setDeletable(deletable: boolean) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_deletable",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "boolean",
+                    },
+                    value: deletable,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets the gravity that is used when changing the toplevel
+     * size programmatically.
+     */
+    setGravity(gravity: Gdk.Gravity) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_gravity",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                        library: "libgtk-4.so.1",
+                        getTypeFn: "gdk_gravity_get_type",
+                    },
+                    value: gravity,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets a list of icons for the surface.
+     *
+     * One of these will be used to represent the surface in iconic form.
+     * The icon may be shown in window lists or task bars. Which icon
+     * size is shown depends on the window manager. The window manager
+     * can scale the icon but setting several size icons can give better
+     * image quality.
+     *
+     * Note that some platforms don't support surface icons.
+     */
+    setIconList(surfaces: Gdk.Texture[]) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_icon_list",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "array",
+                        itemType: {
+                            type: "gobject",
+                            ownership: "borrowed",
+                        },
+                        kind: "glist",
+                        ownership: "borrowed",
+                    },
+                    value: surfaces.map((item) => item.handle),
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets the toplevel to be modal.
+     *
+     * The application can use this hint to tell the
+     * window manager that a certain surface has modal
+     * behaviour. The window manager can use this information
+     * to handle modal surfaces in a special way.
+     *
+     * You should only use this on surfaces for which you have
+     * previously called {@link Gdk.Toplevel.set_transient_for}.
+     */
+    setModal(modal: boolean) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_modal",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "boolean",
+                    },
+                    value: modal,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets the startup notification ID.
+     *
+     * When using GTK, typically you should use
+     * gtk_window_set_startup_id()
+     * instead of this low-level function.
+     */
+    setStartupId(startupId: string) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_startup_id",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "borrowed",
+                    },
+                    value: startupId,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets the title of a toplevel surface.
+     *
+     * The title maybe be displayed in the titlebar,
+     * in lists of windows, etc.
+     */
+    setTitle(title: string) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_title",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "borrowed",
+                    },
+                    value: title,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Sets a transient-for parent.
+     *
+     * Indicates to the window manager that `surface` is a transient
+     * dialog associated with the application surface `parent`. This
+     * allows the window manager to do things like center `surface`
+     * on `parent` and keep `surface` above `parent`.
+     *
+     * See gtk_window_set_transient_for()
+     * if you’re using GtkWindow.
+     */
+    setTransientFor(parent: Gdk.Surface) {
+        call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_set_transient_for",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: parent.handle,
+                },
+            ],
+            {
+                type: "undefined",
+            },
+        );
+    }
+
+    /**
+     * Asks the windowing system to show the window menu.
+     *
+     * The window menu is the menu shown when right-clicking the titlebar
+     * on traditional windows managed by the window manager. This is useful
+     * for windows using client-side decorations, activating it with a
+     * right-click on the window decorations.
+     */
+    showWindowMenu(event: Gdk.Event): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_show_window_menu",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "fundamental",
+                        ownership: "borrowed",
+                        library: "libgtk-4.so.1",
+                        refFn: "gdk_event_ref",
+                        unrefFn: "gdk_event_unref",
+                    },
+                    value: event.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /**
+     * Returns whether the desktop environment supports
+     * tiled window states.
+     */
+    supportsEdgeConstraints(): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_supports_edge_constraints",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    /** Performs a title bar gesture. */
+    titlebarGesture(gesture: Gdk.TitlebarGesture): boolean {
+        return call(
+            "libgtk-4.so.1",
+            "gdk_toplevel_titlebar_gesture",
+            [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "borrowed",
+                    },
+                    value: this.handle,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                        library: "libgtk-4.so.1",
+                        getTypeFn: "gdk_titlebar_gesture_get_type",
+                    },
+                    value: gesture,
+                },
+            ],
+            {
+                type: "boolean",
+            },
+        ) as boolean;
+    }
+
+    connect(
+        signal: "compute-size",
+        handler: (self: WaylandToplevel, size: Gdk.ToplevelSize) => void,
+        after?: boolean,
+    ): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
+    /**
+     * Connects a handler to a signal on this WaylandToplevel.
+     *
+     * @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 "compute-size": {
+                const wrappedHandler = (...args: unknown[]) => {
+                    return handler(
+                        getNativeObject(args[0] as NativeHandle) as WaylandToplevel,
+                        getNativeObject(args[1] as NativeHandle, Gdk.ToplevelSize),
+                    );
+                };
+                return call(
+                    "libgtk-4.so.1",
+                    "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: "boxed",
+                                        ownership: "borrowed",
+                                        innerType: "GdkToplevelSize",
+                                        library: "libgtk-4.so.1",
+                                        getTypeFn: "gdk_toplevel_size_get_type",
+                                    },
+                                ],
+                                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);
+        }
+    }
+
+    /** Gets Whether the window manager should add decorations. */
+    getDecorated(): boolean {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gboolean"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "decorated" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getBoolean();
+    }
+
+    /** Gets Whether the window manager should allow to close the surface. */
+    getDeletable(): boolean {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gboolean"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "deletable" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getBoolean();
+    }
+
+    /** Gets The fullscreen mode of the surface. */
+    getFullscreenMode(): Gdk.FullscreenMode {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gint"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "fullscreen-mode" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getEnum() as Gdk.FullscreenMode;
+    }
+
+    /** Gets Whether the surface is modal. */
+    getModal(): boolean {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gboolean"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "modal" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getBoolean();
+    }
+
+    /** Gets Whether the surface should inhibit keyboard shortcuts. */
+    getShortcutsInhibited(): boolean {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gboolean"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "shortcuts-inhibited" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getBoolean();
+    }
+
+    /**
+     * Gets The startup ID of the surface.
+     *
+     * See {@link Gdk.AppLaunchContext} for more information about
+     * startup feedback.
+     */
+    getStartupId(): string {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gchararray"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "startup-id" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getString() as string;
+    }
+
+    /** Gets The title of the surface. */
+    getTitle(): string {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gchararray"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "title" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getString() as string;
+    }
+
+    /** Gets The transient parent of the surface. */
+    getTransientFor(): Gdk.Surface {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("GObject"));
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_get_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "transient-for" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+        return gvalue.getObject() as Gdk.Surface;
+    }
+
+    /** Sets The fullscreen mode of the surface. */
+    setFullscreenMode(value: Gdk.FullscreenMode): void {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gint"));
+        gvalue.setInt(value as number);
+        call(
+            "libgobject-2.0.so.0",
+            "g_object_set_property",
+            [
+                { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
+                { type: { type: "string", ownership: "borrowed" }, value: "fullscreen-mode" },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "borrowed",
+                        innerType: "GValue",
+                        library: "libgobject-2.0.so.0",
+                        getTypeFn: "g_value_get_type",
+                    },
+                    value: gvalue.handle,
+                },
+            ],
+            { type: "undefined" },
+        );
+    }
+}
+registerNativeClass(WaylandToplevel);