@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/application-window.js

@@ -2,6 +2,77 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { ShortcutsWindow } from "./shortcuts-window.js";
 import { Window } from "./window.js";
+/**
+ * A `GtkWindow` subclass that integrates with `GtkApplication`.
+ *
+ * Notably, `GtkApplicationWindow` can handle an application menubar.
+ *
+ * This class implements the [iface@Gio.ActionGroup] and [iface@Gio.ActionMap]
+ * interfaces, to let you add window-specific actions that will be exported
+ * by the associated [class@Gtk.Application], together with its application-wide
+ * actions. Window-specific actions are prefixed with the “win.”
+ * prefix and application-wide actions are prefixed with the “app.”
+ * prefix. Actions must be addressed with the prefixed name when
+ * referring to them from a menu model.
+ *
+ * Note that widgets that are placed inside a `GtkApplicationWindow`
+ * can also activate these actions, if they implement the
+ * [iface@Gtk.Actionable] interface.
+ *
+ * The settings [property@Gtk.Settings:gtk-shell-shows-app-menu] and
+ * [property@Gtk.Settings:gtk-shell-shows-menubar] tell GTK whether the
+ * desktop environment is showing the application menu and menubar
+ * models outside the application as part of the desktop shell.
+ * For instance, on OS X, both menus will be displayed remotely;
+ * on Windows neither will be.
+ *
+ * If the desktop environment does not display the menubar, it can be shown in
+ * the `GtkApplicationWindow` by setting the
+ * [property@Gtk.ApplicationWindow:show-menubar] property to true. If the
+ * desktop environment does not display the application menu, then it will
+ * automatically be included in the menubar or in the window’s client-side
+ * decorations.
+ *
+ * See [class@Gtk.PopoverMenu] for information about the XML language
+ * used by `GtkBuilder` for menu models.
+ *
+ * See also: [method@Gtk.Application.set_menubar].
+ *
+ * ## A GtkApplicationWindow with a menubar
+ *
+ * The code sample below shows how to set up a `GtkApplicationWindow`
+ * with a menu bar defined on the [class@Gtk.Application]:
+ *
+ * ```c
+ * GtkApplication *app = gtk_application_new ("org.gtk.test", 0);
+ *
+ * GtkBuilder *builder = gtk_builder_new_from_string (
+ * "<interface>"
+ * "  <menu id='menubar'>"
+ * "    <submenu>"
+ * "      <attribute name='label' translatable='yes'>_Edit</attribute>"
+ * "      <item>"
+ * "        <attribute name='label' translatable='yes'>_Copy</attribute>"
+ * "        <attribute name='action'>win.copy</attribute>"
+ * "      </item>"
+ * "      <item>"
+ * "        <attribute name='label' translatable='yes'>_Paste</attribute>"
+ * "        <attribute name='action'>win.paste</attribute>"
+ * "      </item>"
+ * "    </submenu>"
+ * "  </menu>"
+ * "</interface>",
+ * -1);
+ *
+ * GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
+ * gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
+ * g_object_unref (builder);
+ *
+ * // ...
+ *
+ * GtkWidget *window = gtk_application_window_new (app);
+ * ```
+ */
 const SIGNAL_META = {
     "activate-default": { params: [], returnType: { type: "undefined" } },
     "activate-focus": { params: [], returnType: { type: "undefined" } },
@@ -25,6 +96,11 @@ export class ApplicationWindow extends Window {
             },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the `GtkShortcutsWindow` that is associated with @window.
+     *
+     * See [method@Gtk.ApplicationWindow.set_help_overlay].
+     */
     getHelpOverlay() {
         const ptr = call("libgtk-4.so.1", "gtk_application_window_get_help_overlay", [
             {
@@ -36,6 +112,11 @@ export class ApplicationWindow extends Window {
             return null;
         return getObject(ptr, ShortcutsWindow);
     }
+    /**
+     * Returns the unique ID of the window.
+     *
+     * If the window has not yet been added to a `GtkApplication`, returns `0`.
+     */
     getId() {
         return call("libgtk-4.so.1", "gtk_application_window_get_id", [
             {
@@ -44,6 +125,10 @@ export class ApplicationWindow extends Window {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Returns whether the window will display a menubar for the app menu
+     * and menubar as needed.
+     */
     getShowMenubar() {
         return call("libgtk-4.so.1", "gtk_application_window_get_show_menubar", [
             {
@@ -52,6 +137,15 @@ export class ApplicationWindow extends Window {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Associates a shortcuts window with the application window.
+     *
+     * Additionally, sets up an action with the name
+     * `win.show-help-overlay` to present it.
+     *
+     * The window takes responsibility for destroying the help overlay.
+     * @param helpOverlay - a shortcuts window
+     */
     setHelpOverlay(helpOverlay) {
         call("libgtk-4.so.1", "gtk_application_window_set_help_overlay", [
             {
@@ -65,6 +159,11 @@ export class ApplicationWindow extends Window {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the window will display a menubar for the app menu
+     * and menubar as needed.
+     * @param showMenubar - whether to show a menubar when needed
+     */
     setShowMenubar(showMenubar) {
         call("libgtk-4.so.1", "gtk_application_window_set_show_menubar", [
             {

package/dist/generated/gtk/application.d.ts

@@ -3,22 +3,213 @@ import { Window } from "./window.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 export declare class Application extends Gio.Application {
+    /**
+     * Creates a new application instance.
+     *
+     * When using `GtkApplication`, it is not necessary to call [func@Gtk.init]
+     * manually. It is called as soon as the application gets registered as
+     * the primary instance.
+     *
+     * Concretely, [func@Gtk.init] is called in the default handler for the
+     * `GApplication::startup` signal. Therefore, `GtkApplication` subclasses
+     * should always chain up in their [vfunc@GIO.Application.startup] handler
+     * before using any GTK API.
+     *
+     * Note that commandline arguments are not passed to [func@Gtk.init].
+     *
+     * If `application_id` is not `NULL`, then it must be valid. See
+     * [func@Gio.Application.id_is_valid].
+     *
+     * If no application ID is given then some features (most notably application
+     * uniqueness) will be disabled.
+     * @param applicationId - The application ID
+     * @param flags - the application flags
+     */
     constructor(flags: Gio.ApplicationFlags, applicationId?: string | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Adds a window to the application.
+     *
+     * This call can only happen after the application has started;
+     * typically, you should add new application windows in response
+     * to the emission of the [signal@GIO.Application::activate] signal.
+     *
+     * This call is equivalent to setting the [property@Gtk.Window:application]
+     * property of the window to @application.
+     *
+     * Normally, the connection between the application and the window
+     * will remain until the window is destroyed, but you can explicitly
+     * remove it with [method@Gtk.Application.remove_window].
+     *
+     * GTK will keep the application running as long as it has any windows.
+     * @param window - a window
+     */
     addWindow(window: Window): void;
+    /**
+     * Gets the accelerators that are currently associated with
+     * the given action.
+     * @param detailedActionName - a detailed action name, specifying an action
+     */
     getAccelsForAction(detailedActionName: string): string[];
+    /**
+     * Returns the list of actions (possibly empty) that the accelerator maps to.
+     *
+     * Each item in the list is a detailed action name in the usual form.
+     *
+     * This might be useful to discover if an accel already exists in
+     * order to prevent installation of a conflicting accelerator (from
+     * an accelerator editor or a plugin system, for example). Note that
+     * having more than one action per accelerator may not be a bad thing
+     * and might make sense in cases where the actions never appear in the
+     * same context.
+     *
+     * In case there are no actions for a given accelerator, an empty array
+     * is returned. `NULL` is never returned.
+     *
+     * It is a programmer error to pass an invalid accelerator string.
+     *
+     * If you are unsure, check it with [func@Gtk.accelerator_parse] first.
+     * @param accel - an accelerator that can be parsed by [func@Gtk.accelerator_parse]
+     */
     getActionsForAccel(accel: string): string[];
+    /**
+     * Gets the “active” window for the application.
+     *
+     * The active window is the one that was most recently focused
+     * (within the application). This window may not have the focus
+     * at the moment if another application has it — this is just
+     * the most recently-focused window within this application.
+     */
     getActiveWindow(): Window | null;
+    /**
+     * Gets a menu from automatically loaded resources.
+     *
+     * See the section on Automatic resources
+     * for more information.
+     * @param id - the ID of the menu to look up
+     */
     getMenuById(id: string): Gio.Menu | null;
+    /**
+     * Returns the menu model for the menu bar of the application.
+     */
     getMenubar(): Gio.MenuModel | null;
+    /**
+     * Returns the window with the given ID.
+     *
+     * The ID of a `GtkApplicationWindow` can be retrieved with
+     * [method@Gtk.ApplicationWindow.get_id].
+     * @param id - an identifier number
+     */
     getWindowById(id: number): Window | null;
+    /**
+     * Gets a list of the window associated with the application.
+     *
+     * The list is sorted by most recently focused window, such that the first
+     * element is the currently focused window. (Useful for choosing a parent
+     * for a transient window.)
+     *
+     * The list that is returned should not be modified in any way. It will
+     * only remain valid until the next focus change or window creation or
+     * deletion.
+     */
     getWindows(): Window[];
+    /**
+     * Informs the session manager that certain types of actions should be
+     * inhibited.
+     *
+     * This is not guaranteed to work on all platforms and for all types of
+     * actions.
+     *
+     * Applications should invoke this method when they begin an operation
+     * that should not be interrupted, such as creating a CD or DVD. The
+     * types of actions that may be blocked are specified by the `flags` parameter. When the application completes the operation it should
+     * call [method@Gtk.Application.uninhibit] to remove the inhibitor. Note
+     * that an application can have multiple inhibitors, and all of them must
+     * be individually removed. Inhibitors are also cleared when the
+     * application exits.
+     *
+     * Applications should not expect that they will always be able to block
+     * the action. In most cases, users will be given the option to force
+     * the action to take place.
+     *
+     * The `reason` message should be short and to the point.
+     *
+     * If a window is given, the session manager may point the user to
+     * this window to find out more about why the action is inhibited.
+     *
+     * The cookie that is returned by this function  should be used as an
+     * argument to [method@Gtk.Application.uninhibit] in order to remove
+     * the request.
+     * @param window - a window
+     * @param flags - what types of actions should be inhibited
+     * @param reason - a short, human-readable string that explains
+     */
     inhibit(flags: ApplicationInhibitFlags, window?: Window | null, reason?: string | null): number;
+    /**
+     * Lists the detailed action names which have associated accelerators.
+     *
+     * See [method@Gtk.Application.set_accels_for_action].
+     */
     listActionDescriptions(): string[];
+    /**
+     * Remove a window from the application.
+     *
+     * If the window belongs to the application then this call is
+     * equivalent to setting the [property@Gtk.Window:application]
+     * property of the window to `NULL`.
+     *
+     * The application may stop running as a result of a call to this
+     * function, if the window was the last window of the application.
+     * @param window - a window
+     */
     removeWindow(window: Window): void;
+    /**
+     * Sets zero or more keyboard accelerators that will trigger the
+     * given action.
+     *
+     * The first item in `accels` will be the primary accelerator,
+     * which may be displayed in the UI.
+     *
+     * To remove all accelerators for an action, use an empty,
+     * zero-terminated array for @accels.
+     *
+     * For the @detailed_action_name, see [func@Gio.Action.parse_detailed_name]
+     * and [Gio.Action.print_detailed_name].
+     * @param detailedActionName - a detailed action name, specifying an action
+     * @param accels - a list of accelerators in the format
+     */
     setAccelsForAction(detailedActionName: string, accels: string[]): void;
+    /**
+     * Sets or unsets the menubar for windows of the application.
+     *
+     * This is a menubar in the traditional sense.
+     *
+     * This can only be done in the primary instance of the application,
+     * after it has been registered. [vfunc@GIO.Application.startup] is
+     * a good place to call this.
+     *
+     * Depending on the desktop environment, this may appear at the top of
+     * each window, or at the top of the screen. In some environments, if
+     * both the application menu and the menubar are set, the application
+     * menu will be presented as if it were the first item of the menubar.
+     * Other environments treat the two as completely separate — for example,
+     * the application menu may be rendered by the desktop shell while the
+     * menubar (if set) remains in each individual window.
+     *
+     * Use the base `GActionMap` interface to add actions, to respond to the
+     * user selecting these menu items.
+     * @param menubar - a menu model
+     */
     setMenubar(menubar?: Gio.MenuModel | null): void;
+    /**
+     * Removes an inhibitor that has been previously established.
+     *
+     * See [method@Gtk.Application.inhibit].
+     *
+     * Inhibitors are also cleared when the application exits.
+     * @param cookie - a cookie that was returned by [method@Gtk.Application.inhibit]
+     */
     uninhibit(cookie: number): void;
     connect(signal: "query-end", handler: (self: Application) => void, after?: boolean): number;
     connect(signal: "window-added", handler: (self: Application, window: Window) => void, after?: boolean): number;

package/dist/generated/gtk/application.js

@@ -2,6 +2,76 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Window } from "./window.js";
 import * as Gio from "../gio/index.js";
+/**
+ * A high-level API for writing applications.
+ *
+ * `GtkApplication` supports many aspects of writing a GTK application
+ * in a convenient fashion, without enforcing a one-size-fits-all model.
+ *
+ * Currently, it handles GTK initialization, application uniqueness, session
+ * management, provides some basic scriptability and desktop shell integration
+ * by exporting actions and menus and manages a list of toplevel windows whose
+ * life-cycle is automatically tied to the life-cycle of your application.
+ *
+ * While `GtkApplication` works fine with plain [class@Gtk.Window]s,
+ * it is recommended to use it together with [class@Gtk.ApplicationWindow].
+ *
+ * ## Automatic resources
+ *
+ * `GtkApplication` will automatically load menus from the `GtkBuilder`
+ * resource located at "gtk/menus.ui", relative to the application's
+ * resource base path (see [method@Gio.Application.set_resource_base_path]).
+ * The menu with the ID "menubar" is taken as the application's
+ * menubar. Additional menus (most interesting submenus) can be named
+ * and accessed via [method@Gtk.Application.get_menu_by_id] which allows for
+ * dynamic population of a part of the menu structure.
+ *
+ * Note that automatic resource loading uses the resource base path
+ * that is set at construction time and will not work if the resource
+ * base path is changed at a later time.
+ *
+ * It is also possible to provide the menubar manually using
+ * [method@Gtk.Application.set_menubar].
+ *
+ * `GtkApplication` will also automatically setup an icon search path for
+ * the default icon theme by appending "icons" to the resource base
+ * path. This allows your application to easily store its icons as
+ * resources. See [method@Gtk.IconTheme.add_resource_path] for more
+ * information.
+ *
+ * If there is a resource located at `gtk/help-overlay.ui` which
+ * defines a [class@Gtk.ShortcutsWindow] with ID `help_overlay` then
+ * `GtkApplication` associates an instance of this shortcuts window with
+ * each [class@Gtk.ApplicationWindow] and sets up the keyboard accelerator
+ * `Control`+`?` to open it. To create a menu item that
+ * displays the shortcuts window, associate the item with the action
+ * `win.show-help-overlay`.
+ *
+ * `GtkApplication` will also automatically set the application id as the
+ * default window icon. Use [func@Gtk.Window.set_default_icon_name] or
+ * [property@Gtk.Window:icon-name] to override that behavior.
+ *
+ * ## A simple application
+ *
+ * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/bp/bloatpad.c)
+ * is available in the GTK source code repository
+ *
+ * `GtkApplication` registers with a session manager if possible and
+ * offers various functionality related to the session life-cycle.
+ *
+ * An application can block various ways to end the session with
+ * the [method@Gtk.Application.inhibit] function. Typical use cases for
+ * this kind of inhibiting are long-running, uninterruptible operations,
+ * such as burning a CD or performing a disk backup. The session
+ * manager may not honor the inhibitor, but it can be expected to
+ * inform the user about the negative consequences of ending the
+ * session while inhibitors are present.
+ *
+ * ## See Also
+ *
+ * - Using GtkApplication
+ * - Getting Started with GTK: Basics
+ */
 const SIGNAL_META = {
     "query-end": { params: [], returnType: { type: "undefined" } },
     "window-added": {
@@ -35,6 +105,23 @@ export class Application extends Gio.Application {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Adds a window to the application.
+     *
+     * This call can only happen after the application has started;
+     * typically, you should add new application windows in response
+     * to the emission of the [signal@GIO.Application::activate] signal.
+     *
+     * This call is equivalent to setting the [property@Gtk.Window:application]
+     * property of the window to @application.
+     *
+     * Normally, the connection between the application and the window
+     * will remain until the window is destroyed, but you can explicitly
+     * remove it with [method@Gtk.Application.remove_window].
+     *
+     * GTK will keep the application running as long as it has any windows.
+     * @param window - a window
+     */
     addWindow(window) {
         call("libgtk-4.so.1", "gtk_application_add_window", [
             {
@@ -47,6 +134,11 @@ export class Application extends Gio.Application {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the accelerators that are currently associated with
+     * the given action.
+     * @param detailedActionName - a detailed action name, specifying an action
+     */
     getAccelsForAction(detailedActionName) {
         return call("libgtk-4.so.1", "gtk_application_get_accels_for_action", [
             {
@@ -59,6 +151,26 @@ export class Application extends Gio.Application {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Returns the list of actions (possibly empty) that the accelerator maps to.
+     *
+     * Each item in the list is a detailed action name in the usual form.
+     *
+     * This might be useful to discover if an accel already exists in
+     * order to prevent installation of a conflicting accelerator (from
+     * an accelerator editor or a plugin system, for example). Note that
+     * having more than one action per accelerator may not be a bad thing
+     * and might make sense in cases where the actions never appear in the
+     * same context.
+     *
+     * In case there are no actions for a given accelerator, an empty array
+     * is returned. `NULL` is never returned.
+     *
+     * It is a programmer error to pass an invalid accelerator string.
+     *
+     * If you are unsure, check it with [func@Gtk.accelerator_parse] first.
+     * @param accel - an accelerator that can be parsed by [func@Gtk.accelerator_parse]
+     */
     getActionsForAccel(accel) {
         return call("libgtk-4.so.1", "gtk_application_get_actions_for_accel", [
             {
@@ -71,6 +183,14 @@ export class Application extends Gio.Application {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Gets the “active” window for the application.
+     *
+     * The active window is the one that was most recently focused
+     * (within the application). This window may not have the focus
+     * at the moment if another application has it — this is just
+     * the most recently-focused window within this application.
+     */
     getActiveWindow() {
         const ptr = call("libgtk-4.so.1", "gtk_application_get_active_window", [
             {
@@ -82,6 +202,13 @@ export class Application extends Gio.Application {
             return null;
         return getObject(ptr, Window);
     }
+    /**
+     * Gets a menu from automatically loaded resources.
+     *
+     * See the section on Automatic resources
+     * for more information.
+     * @param id - the ID of the menu to look up
+     */
     getMenuById(id) {
         const ptr = call("libgtk-4.so.1", "gtk_application_get_menu_by_id", [
             {
@@ -97,6 +224,9 @@ export class Application extends Gio.Application {
             return null;
         return getObject(ptr, Gio.Menu);
     }
+    /**
+     * Returns the menu model for the menu bar of the application.
+     */
     getMenubar() {
         const ptr = call("libgtk-4.so.1", "gtk_application_get_menubar", [
             {
@@ -108,6 +238,13 @@ export class Application extends Gio.Application {
             return null;
         return getObject(ptr, Gio.MenuModel);
     }
+    /**
+     * Returns the window with the given ID.
+     *
+     * The ID of a `GtkApplicationWindow` can be retrieved with
+     * [method@Gtk.ApplicationWindow.get_id].
+     * @param id - an identifier number
+     */
     getWindowById(id) {
         const ptr = call("libgtk-4.so.1", "gtk_application_get_window_by_id", [
             {
@@ -123,6 +260,17 @@ export class Application extends Gio.Application {
             return null;
         return getObject(ptr, Window);
     }
+    /**
+     * Gets a list of the window associated with the application.
+     *
+     * The list is sorted by most recently focused window, such that the first
+     * element is the currently focused window. (Useful for choosing a parent
+     * for a transient window.)
+     *
+     * The list that is returned should not be modified in any way. It will
+     * only remain valid until the next focus change or window creation or
+     * deletion.
+     */
     getWindows() {
         const ptrs = call("libgtk-4.so.1", "gtk_application_get_windows", [
             {
@@ -137,6 +285,37 @@ export class Application extends Gio.Application {
         });
         return ptrs.map((ptr) => getObject(ptr, Window));
     }
+    /**
+     * Informs the session manager that certain types of actions should be
+     * inhibited.
+     *
+     * This is not guaranteed to work on all platforms and for all types of
+     * actions.
+     *
+     * Applications should invoke this method when they begin an operation
+     * that should not be interrupted, such as creating a CD or DVD. The
+     * types of actions that may be blocked are specified by the `flags` parameter. When the application completes the operation it should
+     * call [method@Gtk.Application.uninhibit] to remove the inhibitor. Note
+     * that an application can have multiple inhibitors, and all of them must
+     * be individually removed. Inhibitors are also cleared when the
+     * application exits.
+     *
+     * Applications should not expect that they will always be able to block
+     * the action. In most cases, users will be given the option to force
+     * the action to take place.
+     *
+     * The `reason` message should be short and to the point.
+     *
+     * If a window is given, the session manager may point the user to
+     * this window to find out more about why the action is inhibited.
+     *
+     * The cookie that is returned by this function  should be used as an
+     * argument to [method@Gtk.Application.uninhibit] in order to remove
+     * the request.
+     * @param window - a window
+     * @param flags - what types of actions should be inhibited
+     * @param reason - a short, human-readable string that explains
+     */
     inhibit(flags, window, reason) {
         return call("libgtk-4.so.1", "gtk_application_inhibit", [
             {
@@ -159,6 +338,11 @@ export class Application extends Gio.Application {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Lists the detailed action names which have associated accelerators.
+     *
+     * See [method@Gtk.Application.set_accels_for_action].
+     */
     listActionDescriptions() {
         return call("libgtk-4.so.1", "gtk_application_list_action_descriptions", [
             {
@@ -167,6 +351,17 @@ export class Application extends Gio.Application {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Remove a window from the application.
+     *
+     * If the window belongs to the application then this call is
+     * equivalent to setting the [property@Gtk.Window:application]
+     * property of the window to `NULL`.
+     *
+     * The application may stop running as a result of a call to this
+     * function, if the window was the last window of the application.
+     * @param window - a window
+     */
     removeWindow(window) {
         call("libgtk-4.so.1", "gtk_application_remove_window", [
             {
@@ -179,6 +374,21 @@ export class Application extends Gio.Application {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets zero or more keyboard accelerators that will trigger the
+     * given action.
+     *
+     * The first item in `accels` will be the primary accelerator,
+     * which may be displayed in the UI.
+     *
+     * To remove all accelerators for an action, use an empty,
+     * zero-terminated array for @accels.
+     *
+     * For the @detailed_action_name, see [func@Gio.Action.parse_detailed_name]
+     * and [Gio.Action.print_detailed_name].
+     * @param detailedActionName - a detailed action name, specifying an action
+     * @param accels - a list of accelerators in the format
+     */
     setAccelsForAction(detailedActionName, accels) {
         call("libgtk-4.so.1", "gtk_application_set_accels_for_action", [
             {
@@ -195,6 +405,27 @@ export class Application extends Gio.Application {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets or unsets the menubar for windows of the application.
+     *
+     * This is a menubar in the traditional sense.
+     *
+     * This can only be done in the primary instance of the application,
+     * after it has been registered. [vfunc@GIO.Application.startup] is
+     * a good place to call this.
+     *
+     * Depending on the desktop environment, this may appear at the top of
+     * each window, or at the top of the screen. In some environments, if
+     * both the application menu and the menubar are set, the application
+     * menu will be presented as if it were the first item of the menubar.
+     * Other environments treat the two as completely separate — for example,
+     * the application menu may be rendered by the desktop shell while the
+     * menubar (if set) remains in each individual window.
+     *
+     * Use the base `GActionMap` interface to add actions, to respond to the
+     * user selecting these menu items.
+     * @param menubar - a menu model
+     */
     setMenubar(menubar) {
         call("libgtk-4.so.1", "gtk_application_set_menubar", [
             {
@@ -208,6 +439,14 @@ export class Application extends Gio.Application {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes an inhibitor that has been previously established.
+     *
+     * See [method@Gtk.Application.inhibit].
+     *
+     * Inhibitors are also cleared when the application exits.
+     * @param cookie - a cookie that was returned by [method@Gtk.Application.inhibit]
+     */
     uninhibit(cookie) {
         call("libgtk-4.so.1", "gtk_application_uninhibit", [
             {