@gtkx/ffi 0.5.2 → 0.6.1

package/dist/generated/adw/message-dialog.js

@@ -0,0 +1,697 @@
+import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import * as Gtk from "../gtk/index.js";
+/**
+ * A dialog presenting a message or a question.
+ *
+ *
+ *
+ * Message dialogs have a heading, a body, an optional child widget, and one or
+ * multiple responses, each presented as a button.
+ *
+ * Each response has a unique string ID, and a button label. Additionally, each
+ * response can be enabled or disabled, and can have a suggested or destructive
+ * appearance.
+ *
+ * When one of the responses is activated, or the dialog is closed, the
+ * [signal@MessageDialog::response] signal will be emitted. This signal is
+ * detailed, and the detail, as well as the `response` parameter will be set to
+ * the ID of the activated response, or to the value of the
+ * [property@MessageDialog:close-response] property if the dialog had been
+ * closed without activating any of the responses.
+ *
+ * Response buttons can be presented horizontally or vertically depending on
+ * available space.
+ *
+ * When a response is activated, `AdwMessageDialog` is closed automatically.
+ *
+ * An example of using a message dialog:
+ *
+ * ```c
+ * GtkWidget *dialog;
+ *
+ * dialog = adw_message_dialog_new (parent, _("Replace File?"), NULL);
+ *
+ * adw_message_dialog_format_body (ADW_MESSAGE_DIALOG (dialog),
+ * _("A file named “%s” already exists. Do you want to replace it?"),
+ * filename);
+ *
+ * adw_message_dialog_add_responses (ADW_MESSAGE_DIALOG (dialog),
+ * "cancel",  _("_Cancel"),
+ * "replace", _("_Replace"),
+ * NULL);
+ *
+ * adw_message_dialog_set_response_appearance (ADW_MESSAGE_DIALOG (dialog), "replace", ADW_RESPONSE_DESTRUCTIVE);
+ *
+ * adw_message_dialog_set_default_response (ADW_MESSAGE_DIALOG (dialog), "cancel");
+ * adw_message_dialog_set_close_response (ADW_MESSAGE_DIALOG (dialog), "cancel");
+ *
+ * g_signal_connect (dialog, "response", G_CALLBACK (response_cb), self);
+ *
+ * gtk_window_present (GTK_WINDOW (dialog));
+ * ```
+ *
+ * ## Async API
+ *
+ * `AdwMessageDialog` can also be used via the [method@MessageDialog.choose]
+ * method. This API follows the GIO async pattern, for example:
+ *
+ * ```c
+ * static void
+ * dialog_cb (AdwMessageDialog *dialog,
+ * GAsyncResult     *result,
+ * MyWindow         *self)
+ * {
+ * const char *response = adw_message_dialog_choose_finish (dialog, result);
+ *
+ * // ...
+ * }
+ *
+ * static void
+ * show_dialog (MyWindow *self)
+ * {
+ * GtkWidget *dialog;
+ *
+ * dialog = adw_message_dialog_new (GTK_WINDOW (self), _("Replace File?"), NULL);
+ *
+ * adw_message_dialog_format_body (ADW_MESSAGE_DIALOG (dialog),
+ * _("A file named “%s” already exists. Do you want to replace it?"),
+ * filename);
+ *
+ * adw_message_dialog_add_responses (ADW_MESSAGE_DIALOG (dialog),
+ * "cancel",  _("_Cancel"),
+ * "replace", _("_Replace"),
+ * NULL);
+ *
+ * adw_message_dialog_set_response_appearance (ADW_MESSAGE_DIALOG (dialog), "replace", ADW_RESPONSE_DESTRUCTIVE);
+ *
+ * adw_message_dialog_set_default_response (ADW_MESSAGE_DIALOG (dialog), "cancel");
+ * adw_message_dialog_set_close_response (ADW_MESSAGE_DIALOG (dialog), "cancel");
+ *
+ * adw_message_dialog_choose (ADW_MESSAGE_DIALOG (dialog), NULL, (GAsyncReadyCallback) dialog_cb, self);
+ * }
+ * ```
+ *
+ * ## AdwMessageDialog as GtkBuildable
+ *
+ * `AdwMessageDialog` supports adding responses in UI definitions by via the
+ * `<responses>` element that may contain multiple `<response>` elements, each
+ * representing a response.
+ *
+ * Each of the `<response>` elements must have the `id` attribute specifying the
+ * response ID. The contents of the element are used as the response label.
+ *
+ * Response labels can be translated with the usual `translatable`, `context`
+ * and `comments` attributes.
+ *
+ * The `<response>` elements can also have `enabled` and/or `appearance`
+ * attributes. See [method@MessageDialog.set_response_enabled] and
+ * [method@MessageDialog.set_response_appearance] for details.
+ *
+ * Example of an `AdwMessageDialog` UI definition:
+ *
+ * ```xml
+ * <object class="AdwMessageDialog" id="dialog">
+ * <property name="heading" translatable="yes">Save Changes?</property>
+ * <property name="body" translatable="yes">Open documents contain unsaved changes. Changes which are not saved will be permanently lost.</property>
+ * <property name="default-response">save</property>
+ * <property name="close-response">cancel</property>
+ * <signal name="response" handler="response_cb"/>
+ * <responses>
+ * <response id="cancel" translatable="yes">_Cancel</response>
+ * <response id="discard" translatable="yes" appearance="destructive">_Discard</response>
+ * <response id="save" translatable="yes" appearance="suggested" enabled="false">_Save</response>
+ * </responses>
+ * </object>
+ * ```
+ *
+ * ## Accessibility
+ *
+ * `AdwMessageDialog` uses the `GTK_ACCESSIBLE_ROLE_DIALOG` role.
+ */
+const SIGNAL_META = {
+    response: {
+        params: [{ type: { type: "string", borrowed: false } }],
+        returnType: { type: "undefined" },
+    },
+};
+export class MessageDialog extends Gtk.Window {
+    static glibTypeName = "AdwMessageDialog";
+    /**
+     * Creates a new `AdwMessageDialog`.
+     *
+     * `heading` and `body` can be set to `NULL`. This can be useful if they need to
+     * be formatted or use markup. In that case, set them to `NULL` and call
+     * [method@MessageDialog.format_body] or similar methods afterwards:
+     *
+     * ```c
+     * GtkWidget *dialog;
+     *
+     * dialog = adw_message_dialog_new (parent, _("Replace File?"), NULL);
+     * adw_message_dialog_format_body (ADW_MESSAGE_DIALOG (dialog),
+     * _("A file named “%s” already exists.  Do you want to replace it?"),
+     * filename);
+     * ```
+     * @param parent - transient parent
+     * @param heading - the heading
+     * @param body - the body text
+     */
+    constructor(parent, heading, body) {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            this.id = call("libadwaita-1.so.0", "adw_message_dialog_new", [
+                {
+                    type: { type: "gobject", borrowed: true },
+                    value: parent?.id ?? parent,
+                    optional: true,
+                },
+                {
+                    type: { type: "string" },
+                    value: heading,
+                    optional: true,
+                },
+                {
+                    type: { type: "string" },
+                    value: body,
+                    optional: true,
+                },
+            ], { type: "gobject", borrowed: true });
+        }
+        else {
+            // @ts-ignore
+            super();
+        }
+    }
+    /**
+     * Adds a response with `id` and `label` to @self.
+     *
+     * Responses are represented as buttons in the dialog.
+     *
+     * Response ID must be unique. It will be used in
+     * [signal@MessageDialog::response] to tell which response had been activated,
+     * as well as to inspect and modify the response later.
+     *
+     * An embedded underline in `label` indicates a mnemonic.
+     *
+     * [method@MessageDialog.set_response_label] can be used to change the response
+     * label after it had been added.
+     *
+     * [method@MessageDialog.set_response_enabled] and
+     * [method@MessageDialog.set_response_appearance] can be used to customize the
+     * responses further.
+     * @param id - the response ID
+     * @param label - the response label
+     */
+    addResponse(id, label) {
+        call("libadwaita-1.so.0", "adw_message_dialog_add_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: id,
+            },
+            {
+                type: { type: "string" },
+                value: label,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Promise-based version of choose.
+     * This function shows `self` to the user.
+     */
+    choose(cancellable) {
+        return new Promise((resolve, reject) => {
+            const callback = (_source, asyncResult) => {
+                try {
+                    const result = call("libadwaita-1.so.0", "adw_message_dialog_choose_finish", [
+                        { type: { type: "gobject" }, value: this.id },
+                        { type: { type: "gobject" }, value: asyncResult },
+                    ], { type: "string", borrowed: true });
+                    resolve(result);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            call("libadwaita-1.so.0", "adw_message_dialog_choose", [
+                { type: { type: "gobject" }, value: this.id },
+                {
+                    type: { type: "gobject", borrowed: true },
+                    value: cancellable?.id ?? cancellable,
+                },
+                {
+                    type: {
+                        type: "callback",
+                        trampoline: "asyncReady",
+                        sourceType: { type: "gobject", borrowed: true },
+                        resultType: { type: "gobject", borrowed: true },
+                    },
+                    value: callback,
+                },
+            ], { type: "undefined" });
+        });
+    }
+    /**
+     * Gets the body text of @self.
+     */
+    getBody() {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_body", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets whether the body text of `self` includes Pango markup.
+     */
+    getBodyUseMarkup() {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_body_use_markup", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets the ID of the close response of @self.
+     */
+    getCloseResponse() {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_close_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets the ID of the default response of @self.
+     */
+    getDefaultResponse() {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_default_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets the child widget of @self.
+     */
+    getExtraChild() {
+        const ptr = call("libadwaita-1.so.0", "adw_message_dialog_get_extra_child", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets the heading of @self.
+     */
+    getHeading() {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_heading", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets whether the heading of `self` includes Pango markup.
+     */
+    getHeadingUseMarkup() {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_heading_use_markup", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets the appearance of @response.
+     *
+     * See [method@MessageDialog.set_response_appearance].
+     * @param response - a response ID
+     */
+    getResponseAppearance(response) {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_response_appearance", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets whether `response` is enabled.
+     *
+     * See [method@MessageDialog.set_response_enabled].
+     * @param response - a response ID
+     */
+    getResponseEnabled(response) {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_response_enabled", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets the label of @response.
+     *
+     * See [method@MessageDialog.set_response_label].
+     * @param response - a response ID
+     */
+    getResponseLabel(response) {
+        return call("libadwaita-1.so.0", "adw_message_dialog_get_response_label", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets whether `self` has a response with the ID @response.
+     * @param response - response ID
+     */
+    hasResponse(response) {
+        return call("libadwaita-1.so.0", "adw_message_dialog_has_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Removes a response from @self.
+     * @param id - the response ID
+     */
+    removeResponse(id) {
+        call("libadwaita-1.so.0", "adw_message_dialog_remove_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Emits the [signal@MessageDialog::response] signal with the given response ID.
+     *
+     * Used to indicate that the user has responded to the dialog in some way.
+     * @param response - response ID
+     */
+    response(response) {
+        call("libadwaita-1.so.0", "adw_message_dialog_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the body text of @self.
+     * @param body - the body of @self
+     */
+    setBody(body) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_body", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: body,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets whether the body text of `self` includes Pango markup.
+     *
+     * See [func@Pango.parse_markup].
+     * @param useMarkup - whether to use markup for body text
+     */
+    setBodyUseMarkup(useMarkup) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_body_use_markup", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: useMarkup,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the ID of the close response of @self.
+     *
+     * It will be passed to [signal@MessageDialog::response] if the window is
+     * closed by pressing `Escape` or with a system action.
+     *
+     * It doesn't have to correspond to any of the responses in the dialog.
+     *
+     * The default close response is `close`.
+     * @param response - the close response ID
+     */
+    setCloseResponse(response) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_close_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the ID of the default response of @self.
+     *
+     * The button corresponding to this response will be set as the default widget
+     * of @self.
+     *
+     * If not set, the default widget will not be set, and the last added response
+     * will be focused by default.
+     *
+     * See [property@Gtk.Window:default-widget].
+     * @param response - the default response ID
+     */
+    setDefaultResponse(response) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_default_response", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the child widget of @self.
+     *
+     * The child widget is displayed below the heading and body.
+     * @param child - the child widget
+     */
+    setExtraChild(child) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_extra_child", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the heading of @self.
+     * @param heading - the heading of @self
+     */
+    setHeading(heading) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_heading", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: heading,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets whether the heading of `self` includes Pango markup.
+     *
+     * See [func@Pango.parse_markup].
+     * @param useMarkup - whether to use markup for heading
+     */
+    setHeadingUseMarkup(useMarkup) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_heading_use_markup", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: useMarkup,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the appearance for @response.
+     *
+     *
+     *
+     * Use `ADW_RESPONSE_SUGGESTED` to mark important responses such as the
+     * affirmative action, like the Save button in the example.
+     *
+     * Use `ADW_RESPONSE_DESTRUCTIVE` to draw attention to the potentially damaging
+     * consequences of using @response. This appearance acts as a warning to the
+     * user. The Discard button in the example is using this appearance.
+     *
+     * The default appearance is `ADW_RESPONSE_DEFAULT`.
+     *
+     * Negative responses like Cancel or Close should use the default appearance.
+     * @param response - a response ID
+     * @param appearance - appearance for @response
+     */
+    setResponseAppearance(response, appearance) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_response_appearance", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: appearance,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets whether `response` is enabled.
+     *
+     * If `response` is not enabled, the corresponding button will have
+     * [property@Gtk.Widget:sensitive] set to `FALSE` and it can't be activated as
+     * a default response.
+     *
+     * `response` can still be used as [property@MessageDialog:close-response] while
+     * it's not enabled.
+     *
+     * Responses are enabled by default.
+     * @param response - a response ID
+     * @param enabled - whether to enable @response
+     */
+    setResponseEnabled(response, enabled) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_response_enabled", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+            {
+                type: { type: "boolean" },
+                value: enabled,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the label of `response` to @label.
+     *
+     * Labels are displayed on the dialog buttons. An embedded underline in `label` indicates a mnemonic.
+     * @param response - a response ID
+     * @param label - the label of @response
+     */
+    setResponseLabel(response, label) {
+        call("libadwaita-1.so.0", "adw_message_dialog_set_response_label", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: response,
+            },
+            {
+                type: { type: "string" },
+                value: label,
+            },
+        ], { type: "undefined" });
+    }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0]);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(signalArgs[i]);
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libadwaita-1.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.id },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
+}
+registerType(MessageDialog);