@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/window.js

@@ -5,6 +5,79 @@ import { WindowGroup } from "./window-group.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gsk from "../gsk/index.js";
 import { Widget } from "./widget.js";
+/**
+ * A toplevel window which can contain other widgets.
+ *
+ *
+ *
+ * Windows normally have decorations that are under the control
+ * of the windowing system and allow the user to manipulate the window
+ * (resize it, move it, close it,...).
+ *
+ * # GtkWindow as GtkBuildable
+ *
+ * The `GtkWindow` implementation of the [iface@Gtk.Buildable] interface supports
+ * setting a child as the titlebar by specifying “titlebar” as the “type”
+ * attribute of a `<child>` element.
+ *
+ * # Shortcuts and Gestures
+ *
+ * `GtkWindow` supports the following keyboard shortcuts:
+ *
+ * - `F10` activates the menubar, if present.
+ * - `Alt` makes the mnemonics visible while pressed.
+ *
+ * The following signals have default keybindings:
+ *
+ * - [signal@Gtk.Window::activate-default]
+ * - [signal@Gtk.Window::activate-focus]
+ * - [signal@Gtk.Window::enable-debugging]
+ *
+ * # Actions
+ *
+ * `GtkWindow` defines a set of built-in actions:
+ *
+ * - `default.activate` activates the default widget.
+ * - `window.minimize` minimizes the window.
+ * - `window.toggle-maximized` maximizes or restores the window.
+ * - `window.close` closes the window.
+ *
+ * # CSS nodes
+ *
+ * ```
+ * window.background [.csd / .solid-csd / .ssd] [.maximized / .fullscreen / .tiled]
+ * ├── <child>
+ * ╰── <titlebar child>.titlebar [.default-decoration]
+ * ```
+ *
+ * `GtkWindow` has a main CSS node with name window and style class .background.
+ *
+ * Style classes that are typically used with the main CSS node are .csd (when
+ * client-side decorations are in use), .solid-csd (for client-side decorations
+ * without invisible borders), .ssd (used by mutter when rendering server-side
+ * decorations). GtkWindow also represents window states with the following
+ * style classes on the main node: .maximized, .fullscreen, .tiled (when supported,
+ * also .tiled-top, .tiled-left, .tiled-right, .tiled-bottom).
+ *
+ * `GtkWindow` subclasses often add their own discriminating style classes,
+ * such as .dialog, .popup or .tooltip.
+ *
+ * Generally, some CSS properties don't make sense on the toplevel window node,
+ * such as margins or padding. When client-side decorations without invisible
+ * borders are in use (i.e. the .solid-csd style class is added to the
+ * main window node), the CSS border of the toplevel window is used for
+ * resize drags. In the .csd case, the shadow area outside of the window
+ * can be used to resize it.
+ *
+ * `GtkWindow` adds the .titlebar and .default-decoration style classes to the
+ * widget that is added as a titlebar child.
+ *
+ * # Accessibility
+ *
+ * `GtkWindow` uses the [enum@Gtk.AccessibleRole.window] role.
+ *
+ * From GTK 4.12 to 4.18, it used the [enum@Gtk.AccessibleRole.application] role.
+ */
 const SIGNAL_META = {
     "activate-default": { params: [], returnType: { type: "undefined" } },
     "activate-focus": { params: [], returnType: { type: "undefined" } },
@@ -16,6 +89,20 @@ const SIGNAL_META = {
     "keys-changed": { params: [], returnType: { type: "undefined" } },
 };
 export class Window extends Widget {
+    /**
+     * Creates a new `GtkWindow`.
+     *
+     * To get an undecorated window (without window borders),
+     * use [method@Gtk.Window.set_decorated].
+     *
+     * All top-level windows created by this function are stored
+     * in an internal top-level window list. This list can be obtained
+     * from [func@Gtk.Window.list_toplevels]. Due to GTK keeping a
+     * reference to the window internally, this function does not
+     * return a reference to the caller.
+     *
+     * To delete a `GtkWindow`, call [method@Gtk.Window.destroy].
+     */
     constructor(...args) {
         super(...args);
     }
@@ -25,18 +112,41 @@ export class Window extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Returns the fallback icon name for windows.
+     *
+     * The returned string is owned by GTK and should not
+     * be modified. It is only valid until the next call to
+     * [func@Gtk.Window.set_default_icon_name].
+     */
     static getDefaultIconName() {
         return call("libgtk-4.so.1", "gtk_window_get_default_icon_name", [], {
             type: "string",
             borrowed: true,
         });
     }
+    /**
+     * Returns the list of all existing toplevel windows.
+     *
+     * If you want to iterate through the list and perform actions involving
+     * callbacks that might destroy the widgets or add new ones, be aware that
+     * the list of toplevels will change and emit the "items-changed" signal.
+     */
     static getToplevels() {
         return call("libgtk-4.so.1", "gtk_window_get_toplevels", [], {
             type: "gobject",
             borrowed: true,
         });
     }
+    /**
+     * Returns the list of all existing toplevel windows.
+     *
+     * The widgets in the list are not individually referenced.
+     * If you want to iterate through the list and perform actions
+     * involving callbacks that might destroy the widgets, you must
+     * call `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first,
+     * and then unref all the widgets afterwards.
+     */
     static listToplevels() {
         return call("libgtk-4.so.1", "gtk_window_list_toplevels", [], {
             type: "array",
@@ -45,6 +155,21 @@ export class Window extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Sets whether the window should request startup notification.
+     *
+     * By default, after showing the first window, GTK calls
+     * [method@Gdk.Toplevel.set_startup_id]. Call this function
+     * to disable the automatic startup notification. You might do this
+     * if your first window is a splash screen, and you want to delay
+     * notification until after your real main window has been shown,
+     * for example.
+     *
+     * In that example, you would disable startup notification
+     * temporarily, show your splash screen, then re-enable it so that
+     * showing the main window would automatically result in notification.
+     * @param setting - true to automatically do startup notification
+     */
     static setAutoStartupNotification(setting) {
         call("libgtk-4.so.1", "gtk_window_set_auto_startup_notification", [
             {
@@ -53,6 +178,14 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets an icon to be used as fallback.
+     *
+     * The fallback icon is used for windows that
+     * haven't had [method@Gtk.Window.set_icon_name]
+     * called on them.
+     * @param name - the name of the themed icon
+     */
     static setDefaultIconName(name) {
         call("libgtk-4.so.1", "gtk_window_set_default_icon_name", [
             {
@@ -61,6 +194,21 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Opens or closes the interactive debugger.
+     *
+     * The debugger offers access to the widget hierarchy of the application
+     * and to useful debugging tools.
+     *
+     * This function allows applications that already use
+     * `Ctrl`+`Shift`+`I`
+     * (or `Ctrl`+`Shift`+`D`)
+     * for their own key shortcuts to add a different shortcut to open the Inspector.
+     *
+     * If you are not overriding the default key shortcuts for the Inspector,
+     * you should not use this function.
+     * @param enable - true to enable interactive debugging
+     */
     static setInteractiveDebugging(enable) {
         call("libgtk-4.so.1", "gtk_window_set_interactive_debugging", [
             {
@@ -69,6 +217,15 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Requests that the window is closed.
+     *
+     * This is similar to what happens when a window manager
+     * close button is clicked.
+     *
+     * This function can be used with close buttons in custom
+     * titlebars.
+     */
     close() {
         call("libgtk-4.so.1", "gtk_window_close", [
             {
@@ -77,6 +234,9 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Drops the internal reference GTK holds on toplevel windows.
+     */
     destroy() {
         call("libgtk-4.so.1", "gtk_window_destroy", [
             {
@@ -85,6 +245,21 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asks to place the window in the fullscreen state.
+     *
+     * Note that you shouldn’t assume the window is definitely fullscreen
+     * afterward, because other entities (e.g. the user or window manager)
+     * unfullscreen it again, and not all window managers honor requests
+     * to fullscreen windows.
+     *
+     * If a window is not explicitly fullscreened or unfullscreened before
+     * it is shown, the initial state is at the window managers discretion.
+     *
+     * You can track the result of this operation via the
+     * [property@Gdk.Toplevel:state] property, or by listening to
+     * notifications of the [property@Gtk.Window:fullscreened] property.
+     */
     fullscreen() {
         call("libgtk-4.so.1", "gtk_window_fullscreen", [
             {
@@ -93,6 +268,18 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asks to place the window in the fullscreen state on the given monitor.
+     *
+     * Note that you shouldn't assume the window is definitely fullscreen
+     * afterward, or that the windowing system allows fullscreen windows on
+     * any given monitor.
+     *
+     * You can track the result of this operation via the
+     * [property@Gdk.Toplevel:state] property, or by listening to
+     * notifications of the [property@Gtk.Window:fullscreened] property.
+     * @param monitor - which monitor to go fullscreen on
+     */
     fullscreenOnMonitor(monitor) {
         call("libgtk-4.so.1", "gtk_window_fullscreen_on_monitor", [
             {
@@ -105,6 +292,9 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the application object associated with the window.
+     */
     getApplication() {
         const ptr = call("libgtk-4.so.1", "gtk_window_get_application", [
             {
@@ -116,6 +306,9 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Application);
     }
+    /**
+     * Gets the child widget of the window.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_window_get_child", [
             {
@@ -127,6 +320,9 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns whether the window has been set to have decorations.
+     */
     getDecorated() {
         return call("libgtk-4.so.1", "gtk_window_get_decorated", [
             {
@@ -135,6 +331,18 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the default size of the window.
+     *
+     * A value of 0 for the width or height indicates that a default
+     * size has not been explicitly set for that dimension, so the
+     * “natural” size of the window will be used.
+     *
+     * This function is the recommended way for saving window state
+     * across restarts of applications.
+     * @param width - location to store the default width
+     * @param height - location to store the default height
+     */
     getDefaultSize(width, height) {
         call("libgtk-4.so.1", "gtk_window_get_default_size", [
             {
@@ -159,6 +367,9 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the default widget for @window.
+     */
     getDefaultWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_window_get_default_widget", [
             {
@@ -170,6 +381,9 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns whether the window has been set to have a close button.
+     */
     getDeletable() {
         return call("libgtk-4.so.1", "gtk_window_get_deletable", [
             {
@@ -178,6 +392,9 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the window will be destroyed with its transient parent.
+     */
     getDestroyWithParent() {
         return call("libgtk-4.so.1", "gtk_window_get_destroy_with_parent", [
             {
@@ -186,6 +403,14 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the current focused widget within the window.
+     *
+     * Note that this is the widget that would have the focus
+     * if the toplevel window focused; if the toplevel window
+     * is not focused then `gtk_widget_has_focus (widget)` will
+     * not be false for the widget.
+     */
     getFocus() {
         const ptr = call("libgtk-4.so.1", "gtk_window_get_focus", [
             {
@@ -197,6 +422,9 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets whether “focus rectangles” are supposed to be visible.
+     */
     getFocusVisible() {
         return call("libgtk-4.so.1", "gtk_window_get_focus_visible", [
             {
@@ -205,6 +433,9 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the gravity that is used when changing the window size programmatically.
+     */
     getGravity() {
         return call("libgtk-4.so.1", "gtk_window_get_gravity", [
             {
@@ -213,6 +444,11 @@ export class Window extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the group for the window.
+     *
+     * If the window has no group, then the default group is returned.
+     */
     getGroup() {
         const ptr = call("libgtk-4.so.1", "gtk_window_get_group", [
             {
@@ -222,6 +458,10 @@ export class Window extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, WindowGroup);
     }
+    /**
+     * Returns whether this window reacts to `F10`
+     * presses by activating a menubar it contains.
+     */
     getHandleMenubarAccel() {
         return call("libgtk-4.so.1", "gtk_window_get_handle_menubar_accel", [
             {
@@ -230,6 +470,10 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the window will be hidden instead of destroyed when the close
+     * button is clicked.
+     */
     getHideOnClose() {
         return call("libgtk-4.so.1", "gtk_window_get_hide_on_close", [
             {
@@ -238,6 +482,9 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the name of the themed icon for the window.
+     */
     getIconName() {
         return call("libgtk-4.so.1", "gtk_window_get_icon_name", [
             {
@@ -246,6 +493,9 @@ export class Window extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets whether mnemonics are supposed to be visible.
+     */
     getMnemonicsVisible() {
         return call("libgtk-4.so.1", "gtk_window_get_mnemonics_visible", [
             {
@@ -254,6 +504,9 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the window is modal.
+     */
     getModal() {
         return call("libgtk-4.so.1", "gtk_window_get_modal", [
             {
@@ -262,6 +515,9 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether the user can resize the window.
+     */
     getResizable() {
         return call("libgtk-4.so.1", "gtk_window_get_resizable", [
             {
@@ -270,6 +526,9 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the title of the window.
+     */
     getTitle() {
         return call("libgtk-4.so.1", "gtk_window_get_title", [
             {
@@ -278,6 +537,10 @@ export class Window extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns the titlebar that has been set with
+     * [method@Gtk.Window.set_titlebar].
+     */
     getTitlebar() {
         const ptr = call("libgtk-4.so.1", "gtk_window_get_titlebar", [
             {
@@ -289,6 +552,9 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Fetches the transient parent for this window.
+     */
     getTransientFor() {
         const ptr = call("libgtk-4.so.1", "gtk_window_get_transient_for", [
             {
@@ -300,6 +566,9 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Window);
     }
+    /**
+     * Returns whether the window has an explicit window group.
+     */
     hasGroup() {
         return call("libgtk-4.so.1", "gtk_window_has_group", [
             {
@@ -308,6 +577,15 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the window is part of the current active toplevel.
+     *
+     * The active toplevel is the window receiving keystrokes.
+     *
+     * The return value is %TRUE if the window is active toplevel itself.
+     * You might use this function if you wanted to draw a widget
+     * differently in an active window from a widget in an inactive window.
+     */
     isActive() {
         return call("libgtk-4.so.1", "gtk_window_is_active", [
             {
@@ -316,6 +594,18 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the current fullscreen state of the window.
+     *
+     * Note that since fullscreening is ultimately handled by the window
+     * manager and happens asynchronously to an application request, you
+     * shouldn’t assume the return value of this function changing
+     * immediately (or at all), as an effect of calling
+     * [method@Gtk.Window.fullscreen] or [method@Gtk.Window.unfullscreen].
+     *
+     * If the window isn't yet mapped, the value returned will whether the
+     * initial requested state is fullscreen.
+     */
     isFullscreen() {
         return call("libgtk-4.so.1", "gtk_window_is_fullscreen", [
             {
@@ -324,6 +614,18 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the current maximized state of the window.
+     *
+     * Note that since maximization is ultimately handled by the window
+     * manager and happens asynchronously to an application request, you
+     * shouldn’t assume the return value of this function changing
+     * immediately (or at all), as an effect of calling
+     * [method@Gtk.Window.maximize] or [method@Gtk.Window.unmaximize].
+     *
+     * If the window isn't yet mapped, the value returned will whether the
+     * initial requested state is maximized.
+     */
     isMaximized() {
         return call("libgtk-4.so.1", "gtk_window_is_maximized", [
             {
@@ -332,6 +634,13 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the current suspended state of the window.
+     *
+     * A window being suspended means it's currently not visible
+     * to the user, for example by being on a inactive workspace,
+     * minimized, obstructed.
+     */
     isSuspended() {
         return call("libgtk-4.so.1", "gtk_window_is_suspended", [
             {
@@ -340,6 +649,28 @@ export class Window extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Asks to maximize the window, so that it fills the screen.
+     *
+     * Note that you shouldn’t assume the window is definitely maximized
+     * afterward, because other entities (e.g. the user or window manager)
+     * could unmaximize it again, and not all window managers support
+     * maximization.
+     *
+     * It’s permitted to call this function before showing a window,
+     * in which case the window will be maximized when it appears onscreen
+     * initially.
+     *
+     * If a window is not explicitly maximized or unmaximized before it is
+     * shown, the initial state is at the window managers discretion. For
+     * example, it might decide to maximize a window that almost fills the
+     * screen.
+     *
+     * You can track the result of this operation via the
+     * [property@Gdk.Toplevel:state] property, or by listening to
+     * notifications on the [property@Gtk.Window:maximized]
+     * property.
+     */
     maximize() {
         call("libgtk-4.so.1", "gtk_window_maximize", [
             {
@@ -348,6 +679,22 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asks to minimize the window.
+     *
+     * Note that you shouldn’t assume the window is definitely minimized
+     * afterward, because the windowing system might not support this
+     * functionality; other entities (e.g. the user or the window manager)
+     * could unminimize it again, or there may not be a window manager in
+     * which case minimization isn’t possible, etc.
+     *
+     * It’s permitted to call this function before showing a window,
+     * in which case the window will be minimized before it ever appears
+     * onscreen.
+     *
+     * You can track result of this operation via the
+     * [property@Gdk.Toplevel:state] property.
+     */
     minimize() {
         call("libgtk-4.so.1", "gtk_window_minimize", [
             {
@@ -356,6 +703,16 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Presents a window to the user.
+     *
+     * This may mean raising the window in the stacking order,
+     * unminimizing it, moving it to the current desktop and/or
+     * giving it the keyboard focus (possibly dependent on the user’s
+     * platform, window manager and preferences).
+     *
+     * If `window` is hidden, this function also makes it visible.
+     */
     present() {
         call("libgtk-4.so.1", "gtk_window_present", [
             {
@@ -364,6 +721,16 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Presents a window to the user in response to an user interaction.
+     *
+     * See [method@Gtk.Window.present] for more details.
+     *
+     * The timestamp should be gathered when the window was requested
+     * to be shown (when clicking a link for example), rather than once
+     * the window is ready to be shown.
+     * @param timestamp - the timestamp of the user interaction (typically a
+     */
     presentWithTime(timestamp) {
         call("libgtk-4.so.1", "gtk_window_present_with_time", [
             {
@@ -376,6 +743,22 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets or unsets the application object associated with the window.
+     *
+     * The application will be kept alive for at least as long as it has
+     * any windows associated with it (see [method@Gio.Application.hold]
+     * for a way to keep it alive without windows).
+     *
+     * Normally, the connection between the application and the window will
+     * remain until the window is destroyed, but you can explicitly remove
+     * it by setting the `application` to %NULL.
+     *
+     * This is equivalent to calling [method@Gtk.Application.remove_window]
+     * and/or [method@Gtk.Application.add_window] on the old/new applications
+     * as relevant.
+     * @param application - a `GtkApplication`
+     */
     setApplication(application) {
         call("libgtk-4.so.1", "gtk_window_set_application", [
             {
@@ -389,6 +772,10 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the child widget of the window.
+     * @param child - the child widget
+     */
     setChild(child) {
         call("libgtk-4.so.1", "gtk_window_set_child", [
             {
@@ -402,6 +789,22 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the window should be decorated.
+     *
+     * By default, windows are decorated with a title bar, resize
+     * controls, etc. Some window managers allow GTK to disable these
+     * decorations, creating a borderless window. If you set the decorated
+     * property to false using this function, GTK will do its best to
+     * convince the window manager not to decorate the window. Depending on
+     * the system, this function may not have any effect when called on a
+     * window that is already visible, so you should call it before calling
+     * [method@Gtk.Widget.show].
+     *
+     * On Windows, this function always works, since there’s no window manager
+     * policy involved.
+     * @param setting - true to decorate the window
+     */
     setDecorated(setting) {
         call("libgtk-4.so.1", "gtk_window_set_decorated", [
             {
@@ -414,6 +817,40 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default size of a window.
+     *
+     * The default size of a window is the size that will be used
+     * if no other constraints apply.
+     *
+     * The default size will be updated whenever the window is resized
+     * to reflect the new size, unless the window is forced to a size,
+     * like when it is maximized or fullscreened.
+     *
+     * If the window’s minimum size request is larger than
+     * the default, the default will be ignored.
+     *
+     * Setting the default size to a value <= 0 will cause it to be
+     * ignored and the natural size request will be used instead. It
+     * is possible to do this while the window is showing to "reset"
+     * it to its initial size.
+     *
+     * Unlike [method@Gtk.Widget.set_size_request], which sets a size
+     * request for a widget and thus would keep users from shrinking
+     * the window, this function only sets the initial size, just as
+     * if the user had resized the window themselves. Users can still
+     * shrink the window again as they normally would. Setting a default
+     * size of -1 means to use the “natural” default size (the size request
+     * of the window).
+     *
+     * If you use this function to reestablish a previously saved window size,
+     * note that the appropriate size to save is the one returned by
+     * [method@Gtk.Window.get_default_size]. Using the window allocation
+     * directly will not work in all circumstances and can lead to growing
+     * or shrinking windows.
+     * @param width - width in pixels, or -1 to unset the default width
+     * @param height - height in pixels, or -1 to unset the default height
+     */
     setDefaultSize(width, height) {
         call("libgtk-4.so.1", "gtk_window_set_default_size", [
             {
@@ -430,6 +867,14 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default widget.
+     *
+     * The default widget is the widget that is activated
+     * when the user presses `Enter` in a dialog
+     * (for example).
+     * @param defaultWidget - widget to be the default
+     */
     setDefaultWidget(defaultWidget) {
         call("libgtk-4.so.1", "gtk_window_set_default_widget", [
             {
@@ -443,6 +888,21 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the window should be deletable.
+     *
+     * By default, windows have a close button in the window frame.
+     * Some  window managers allow GTK to disable this button. If you
+     * set the deletable property to false using this function, GTK
+     * will do its best to convince the window manager not to show a
+     * close button. Depending on the system, this function may not
+     * have any effect when called on a window that is already visible,
+     * so you should call it before calling [method@Gtk.Widget.show].
+     *
+     * On Windows, this function always works, since there’s no window
+     * manager policy involved.
+     * @param setting - true to decorate the window as deletable
+     */
     setDeletable(setting) {
         call("libgtk-4.so.1", "gtk_window_set_deletable", [
             {
@@ -455,6 +915,13 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to destroy the window when the transient parent is destroyed.
+     *
+     * This is useful for dialogs that shouldn’t persist beyond the lifetime
+     * of the main window they are associated with, for example.
+     * @param setting - whether to destroy the window with its transient parent
+     */
     setDestroyWithParent(setting) {
         call("libgtk-4.so.1", "gtk_window_set_destroy_with_parent", [
             {
@@ -467,6 +934,13 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the display where the window is displayed.
+     *
+     * If the window is already mapped, it will be unmapped,
+     * and then remapped on the new display.
+     * @param display - a display
+     */
     setDisplay(display) {
         call("libgtk-4.so.1", "gtk_window_set_display", [
             {
@@ -479,6 +953,16 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the focus widget.
+     *
+     * If `focus` is not the current focus widget, and is focusable,
+     * sets it as the focus widget for the window. If `focus` is %NULL,
+     * unsets the focus widget for this window. To set the focus to a
+     * particular widget in the toplevel, it is usually more convenient
+     * to use [method@Gtk.Widget.grab_focus] instead of this function.
+     * @param focus - the new focus widget
+     */
     setFocus(focus) {
         call("libgtk-4.so.1", "gtk_window_set_focus", [
             {
@@ -492,6 +976,13 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether “focus rectangles” are supposed to be visible.
+     *
+     * This property is maintained by GTK based on user input,
+     * and should not be set by applications.
+     * @param setting - the new value
+     */
     setFocusVisible(setting) {
         call("libgtk-4.so.1", "gtk_window_set_focus_visible", [
             {
@@ -504,6 +995,10 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the gravity that is used when changing the window size programmatically.
+     * @param gravity - the new gravity
+     */
     setGravity(gravity) {
         call("libgtk-4.so.1", "gtk_window_set_gravity", [
             {
@@ -516,6 +1011,11 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether this window should react to `F10`
+     * presses by activating a menubar it contains.
+     * @param handleMenubarAccel - true to make `window` handle `F10`
+     */
     setHandleMenubarAccel(handleMenubarAccel) {
         call("libgtk-4.so.1", "gtk_window_set_handle_menubar_accel", [
             {
@@ -528,6 +1028,11 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether clicking the close button will hide the window instead
+     * of destroying it.
+     * @param setting - whether to hide the window when it is closed
+     */
     setHideOnClose(setting) {
         call("libgtk-4.so.1", "gtk_window_set_hide_on_close", [
             {
@@ -540,6 +1045,16 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the icon for the window from a named themed icon.
+     *
+     * See the docs for [class@Gtk.IconTheme] for more details.
+     * On some platforms, the window icon is not used at all.
+     *
+     * Note that this has nothing to do with the WM_ICON_NAME
+     * property which is mentioned in the ICCCM.
+     * @param name - the name of the themed icon
+     */
     setIconName(name) {
         call("libgtk-4.so.1", "gtk_window_set_icon_name", [
             {
@@ -553,6 +1068,13 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether mnemonics are supposed to be visible.
+     *
+     * This property is maintained by GTK based on user input,
+     * and should not be set by applications.
+     * @param setting - the new value
+     */
     setMnemonicsVisible(setting) {
         call("libgtk-4.so.1", "gtk_window_set_mnemonics_visible", [
             {
@@ -565,6 +1087,16 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a window modal or non-modal.
+     *
+     * Modal windows prevent interaction with other windows in the same
+     * application. To keep modal dialogs on top of main application windows,
+     * use [method@Gtk.Window.set_transient_for] to make the dialog transient
+     * for the parent; most window managers will then disallow lowering the
+     * dialog below the parent.
+     * @param modal - whether the window is modal
+     */
     setModal(modal) {
         call("libgtk-4.so.1", "gtk_window_set_modal", [
             {
@@ -577,6 +1109,12 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the user can resize a window.
+     *
+     * Windows are user resizable by default.
+     * @param resizable - true if the user can resize this window
+     */
     setResizable(resizable) {
         call("libgtk-4.so.1", "gtk_window_set_resizable", [
             {
@@ -589,6 +1127,24 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the startup notification ID.
+     *
+     * Startup notification identifiers are used by desktop environment
+     * to track application startup, to provide user feedback and other
+     * features. This function changes the corresponding property on the
+     * underlying `GdkSurface`.
+     *
+     * Normally, startup identifier is managed automatically and you should
+     * only use this function in special cases like transferring focus from
+     * other processes. You should use this function before calling
+     * [method@Gtk.Window.present] or any equivalent function generating
+     * a window map event.
+     *
+     * This function is only useful on Wayland or X11, not with other GDK
+     * backends.
+     * @param startupId - a string with startup-notification identifier
+     */
     setStartupId(startupId) {
         call("libgtk-4.so.1", "gtk_window_set_startup_id", [
             {
@@ -601,6 +1157,19 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the title of the window.
+     *
+     * The title of a window will be displayed in its title bar; on the
+     * X Window System, the title bar is rendered by the window manager
+     * so exactly how the title appears to users may vary according to a
+     * user’s exact configuration. The title should help a user distinguish
+     * this window from other windows they may have open. A good title might
+     * include the application name and current document filename, for example.
+     *
+     * Passing `NULL` does the same as setting the title to an empty string.
+     * @param title - title of the window
+     */
     setTitle(title) {
         call("libgtk-4.so.1", "gtk_window_set_title", [
             {
@@ -614,6 +1183,20 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a custom titlebar for the window.
+     *
+     * A typical widget used here is [class@Gtk.HeaderBar], as it
+     * provides various features expected of a titlebar while allowing
+     * the addition of child widgets to it.
+     *
+     * If you set a custom titlebar, GTK will do its best to convince
+     * the window manager not to put its own titlebar on the window.
+     * Depending on the system, this function may not work for a window
+     * that is already visible, so you set the titlebar before calling
+     * [method@Gtk.Widget.show].
+     * @param titlebar - the widget to use as titlebar
+     */
     setTitlebar(titlebar) {
         call("libgtk-4.so.1", "gtk_window_set_titlebar", [
             {
@@ -627,6 +1210,22 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a transient parent for the window.
+     *
+     * Dialog windows should be set transient for the main application
+     * window they were spawned from. This allows window managers to e.g.
+     * keep the dialog on top of the main window, or center the dialog
+     * over the main window. [ctor@Gtk.Dialog.new_with_buttons] and other
+     * convenience functions in GTK will sometimes call this function on
+     * your behalf.
+     *
+     * Passing `NULL` for `parent` unsets the current transient window.
+     *
+     * On Windows, this function puts the child window on top of the parent,
+     * much as the window manager would have done on X.
+     * @param parent - parent window
+     */
     setTransientFor(parent) {
         call("libgtk-4.so.1", "gtk_window_set_transient_for", [
             {
@@ -640,6 +1239,24 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asks to remove the fullscreen state for the window, and return to
+     * its previous state.
+     *
+     * Note that you shouldn’t assume the window is definitely not
+     * fullscreen afterward, because other entities (e.g. the user or
+     * window manager) could fullscreen it again, and not all window
+     * managers honor requests to unfullscreen windows; normally the
+     * window will end up restored to its normal state. Just don’t
+     * write code that crashes if not.
+     *
+     * If a window is not explicitly fullscreened or unfullscreened before
+     * it is shown, the initial state is at the window managers discretion.
+     *
+     * You can track the result of this operation via the
+     * [property@Gdk.Toplevel:state] property, or by listening to
+     * notifications of the [property@Gtk.Window:fullscreened] property.
+     */
     unfullscreen() {
         call("libgtk-4.so.1", "gtk_window_unfullscreen", [
             {
@@ -648,6 +1265,23 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asks to unmaximize the window.
+     *
+     * Note that you shouldn’t assume the window is definitely unmaximized
+     * afterward, because other entities (e.g. the user or window manager)
+     * maximize it again, and not all window managers honor requests to
+     * unmaximize.
+     *
+     * If a window is not explicitly maximized or unmaximized before it is
+     * shown, the initial state is at the window managers discretion. For
+     * example, it might decide to maximize a window that almost fills the
+     * screen.
+     *
+     * You can track the result of this operation via the
+     * [property@Gdk.Toplevel:state] property, or by listening to
+     * notifications on the [property@Gtk.Window:maximized] property.
+     */
     unmaximize() {
         call("libgtk-4.so.1", "gtk_window_unmaximize", [
             {
@@ -656,6 +1290,18 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asks to unminimize the window.
+     *
+     * Note that you shouldn’t assume the window is definitely unminimized
+     * afterward, because the windowing system might not support this
+     * functionality; other entities (e.g. the user or the window manager)
+     * could minimize it again, or there may not be a window manager in
+     * which case minimization isn’t possible, etc.
+     *
+     * You can track result of this operation via the
+     * [property@Gdk.Toplevel:state] property.
+     */
     unminimize() {
         call("libgtk-4.so.1", "gtk_window_unminimize", [
             {
@@ -664,6 +1310,9 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the renderer that is used for this `GtkNative`.
+     */
     getRenderer() {
         const ptr = call("libgtk-4.so.1", "gtk_native_get_renderer", [
             {
@@ -675,6 +1324,9 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Gsk.Renderer);
     }
+    /**
+     * Returns the surface of this `GtkNative`.
+     */
     getSurface() {
         const ptr = call("libgtk-4.so.1", "gtk_native_get_surface", [
             {
@@ -686,6 +1338,14 @@ export class Window extends Widget {
             return null;
         return getObject(ptr, Gdk.Surface);
     }
+    /**
+     * Retrieves the surface transform of @self.
+     *
+     * This is the translation from @self's surface coordinates into
+     * @self's widget coordinates.
+     * @param x - return location for the x coordinate
+     * @param y - return location for the y coordinate
+     */
     getSurfaceTransform(x, y) {
         call("libgtk-4.so.1", "gtk_native_get_surface_transform", [
             {