@gtkx/ffi 0.18.5 → 0.18.6

package/dist/generated/gdkwayland/wayland-toplevel.js

@@ -0,0 +1,1022 @@
+import { isInstantiating, setInstantiating } from "../../lifecycle.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 glibTypeName = "GdkWaylandToplevel";
+    static objectType = "gobject";
+    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" });
+            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) {
+        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) {
+        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) {
+        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",
+        });
+    }
+    /**
+     * 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, button, x, y, timestamp) {
+        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, button, x, y, timestamp, device) {
+        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) {
+        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() {
+        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",
+        });
+    }
+    /**
+     * Returns the gravity that is used when changing the toplevel
+     * size programmatically.
+     */
+    getGravity() {
+        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",
+        });
+    }
+    /**
+     * Gets the bitwise or of the currently active surface state flags,
+     * from the `GdkToplevelState` enumeration.
+     */
+    getState() {
+        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",
+        });
+    }
+    /**
+     * 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) {
+        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() {
+        return call("libgtk-4.so.1", "gdk_toplevel_lower", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Asks to minimize the `toplevel`.
+     *
+     * The windowing system may choose to ignore the request.
+     */
+    minimize() {
+        return call("libgtk-4.so.1", "gdk_toplevel_minimize", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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",
+        });
+    }
+    /**
+     * Returns whether the desktop environment supports
+     * tiled window states.
+     */
+    supportsEdgeConstraints() {
+        return call("libgtk-4.so.1", "gdk_toplevel_supports_edge_constraints", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Performs a title bar gesture. */
+    titlebarGesture(gesture) {
+        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",
+        });
+    }
+    /**
+     * 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, handler, after = false) {
+        switch (signal) {
+            case "compute-size": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], 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 });
+            }
+            default:
+                return super.connect(signal, handler, after);
+        }
+    }
+    /** Gets Whether the window manager should add decorations. */
+    getDecorated() {
+        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() {
+        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() {
+        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();
+    }
+    /** Gets Whether the surface is modal. */
+    getModal() {
+        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() {
+        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() {
+        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();
+    }
+    /** Gets The title of the surface. */
+    getTitle() {
+        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();
+    }
+    /** Gets The transient parent of the surface. */
+    getTransientFor() {
+        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();
+    }
+    /** Sets The fullscreen mode of the surface. */
+    setFullscreenMode(value) {
+        const gvalue = new GObject.Value();
+        gvalue.init(GObject.typeFromName("gint"));
+        gvalue.setInt(value);
+        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);
+//# sourceMappingURL=wayland-toplevel.js.map