@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/label.js

@@ -3,6 +3,221 @@ import { getObject } from "@gtkx/ffi";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Displays a small amount of text.
+ *
+ * Most labels are used to label another widget (such as an [class@Entry]).
+ *
+ *
+ *
+ * ## Shortcuts and Gestures
+ *
+ * `GtkLabel` supports the following keyboard shortcuts, when the cursor is
+ * visible:
+ *
+ * - `Shift`+`F10` or `Menu` opens the context menu.
+ * - `Ctrl`+`A` or `Ctrl`+`/`
+ * selects all.
+ * - `Ctrl`+`Shift`+`A` or
+ * `Ctrl`+`\` unselects all.
+ *
+ * Additionally, the following signals have default keybindings:
+ *
+ * - [signal@Gtk.Label::activate-current-link]
+ * - [signal@Gtk.Label::copy-clipboard]
+ * - [signal@Gtk.Label::move-cursor]
+ *
+ * ## Actions
+ *
+ * `GtkLabel` defines a set of built-in actions:
+ *
+ * - `clipboard.copy` copies the text to the clipboard.
+ * - `clipboard.cut` doesn't do anything, since text in labels can't be deleted.
+ * - `clipboard.paste` doesn't do anything, since text in labels can't be
+ * edited.
+ * - `link.open` opens the link, when activated on a link inside the label.
+ * - `link.copy` copies the link to the clipboard, when activated on a link
+ * inside the label.
+ * - `menu.popup` opens the context menu.
+ * - `selection.delete` doesn't do anything, since text in labels can't be
+ * deleted.
+ * - `selection.select-all` selects all of the text, if the label allows
+ * selection.
+ *
+ * ## CSS nodes
+ *
+ * ```
+ * label
+ * ├── [selection]
+ * ├── [link]
+ * ┊
+ * ╰── [link]
+ * ```
+ *
+ * `GtkLabel` has a single CSS node with the name label. A wide variety
+ * of style classes may be applied to labels, such as .title, .subtitle,
+ * .dim-label, etc. In the `GtkShortcutsWindow`, labels are used with the
+ * .keycap style class.
+ *
+ * If the label has a selection, it gets a subnode with name selection.
+ *
+ * If the label has links, there is one subnode per link. These subnodes
+ * carry the link or visited state depending on whether they have been
+ * visited. In this case, label node also gets a .link style class.
+ *
+ * ## GtkLabel as GtkBuildable
+ *
+ * The GtkLabel implementation of the GtkBuildable interface supports a
+ * custom `<attributes>` element, which supports any number of `<attribute>`
+ * elements. The `<attribute>` element has attributes named “name“, “value“,
+ * “start“ and “end“ and allows you to specify [struct@Pango.Attribute]
+ * values for this label.
+ *
+ * An example of a UI definition fragment specifying Pango attributes:
+ *
+ * ```xml
+ * <object class="GtkLabel">
+ * <attributes>
+ * <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
+ * <attribute name="background" value="red" start="5" end="10"/>
+ * </attributes>
+ * </object>
+ * ```
+ *
+ * The start and end attributes specify the range of characters to which the
+ * Pango attribute applies. If start and end are not specified, the attribute is
+ * applied to the whole text. Note that specifying ranges does not make much
+ * sense with translatable attributes. Use markup embedded in the translatable
+ * content instead.
+ *
+ * ## Accessibility
+ *
+ * `GtkLabel` uses the [enum@Gtk.AccessibleRole.label] role.
+ *
+ * ## Mnemonics
+ *
+ * Labels may contain “mnemonics”. Mnemonics are underlined characters in the
+ * label, used for keyboard navigation. Mnemonics are created by providing a
+ * string with an underscore before the mnemonic character, such as `"_File"`,
+ * to the functions [ctor@Gtk.Label.new_with_mnemonic] or
+ * [method@Gtk.Label.set_text_with_mnemonic].
+ *
+ * Mnemonics automatically activate any activatable widget the label is
+ * inside, such as a [class@Gtk.Button]; if the label is not inside the
+ * mnemonic’s target widget, you have to tell the label about the target
+ * using [method@Gtk.Label.set_mnemonic_widget].
+ *
+ * Here’s a simple example where the label is inside a button:
+ *
+ * ```c
+ * // Pressing Alt+H will activate this button
+ * GtkWidget *button = gtk_button_new ();
+ * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
+ * gtk_button_set_child (GTK_BUTTON (button), label);
+ * ```
+ *
+ * There’s a convenience function to create buttons with a mnemonic label
+ * already inside:
+ *
+ * ```c
+ * // Pressing Alt+H will activate this button
+ * GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");
+ * ```
+ *
+ * To create a mnemonic for a widget alongside the label, such as a
+ * [class@Gtk.Entry], you have to point the label at the entry with
+ * [method@Gtk.Label.set_mnemonic_widget]:
+ *
+ * ```c
+ * // Pressing Alt+H will focus the entry
+ * GtkWidget *entry = gtk_entry_new ();
+ * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
+ * gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
+ * ```
+ *
+ * ## Markup (styled text)
+ *
+ * To make it easy to format text in a label (changing colors, fonts, etc.),
+ * label text can be provided in a simple markup format:
+ *
+ * Here’s how to create a label with a small font:
+ * ```c
+ * GtkWidget *label = gtk_label_new (NULL);
+ * gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");
+ * ```
+ *
+ * (See the Pango manual for complete documentation] of available
+ * tags, [func@Pango.parse_markup])
+ *
+ * The markup passed to [method@Gtk.Label.set_markup] must be valid XML; for example,
+ * literal `<`, `>` and `&` characters must be escaped as `&lt;`, `&gt;`, and `&amp;`.
+ * If you pass text obtained from the user, file, or a network to
+ * [method@Gtk.Label.set_markup], you’ll want to escape it with
+ * [func@GLib.markup_escape_text] or [func@GLib.markup_printf_escaped].
+ *
+ * Markup strings are just a convenient way to set the [struct@Pango.AttrList]
+ * on a label; [method@Gtk.Label.set_attributes] may be a simpler way to set
+ * attributes in some cases. Be careful though; [struct@Pango.AttrList] tends
+ * to cause internationalization problems, unless you’re applying attributes
+ * to the entire string (i.e. unless you set the range of each attribute
+ * to [0, `G_MAXINT`)). The reason is that specifying the `start_index` and
+ * `end_index` for a [struct@Pango.Attribute] requires knowledge of the exact
+ * string being displayed, so translations will cause problems.
+ *
+ * ## Selectable labels
+ *
+ * Labels can be made selectable with [method@Gtk.Label.set_selectable].
+ * Selectable labels allow the user to copy the label contents to the
+ * clipboard. Only labels that contain useful-to-copy information — such
+ * as error messages — should be made selectable.
+ *
+ * ## Text layout
+ *
+ * A label can contain any number of paragraphs, but will have
+ * performance problems if it contains more than a small number.
+ * Paragraphs are separated by newlines or other paragraph separators
+ * understood by Pango.
+ *
+ * Labels can automatically wrap text if you call [method@Gtk.Label.set_wrap].
+ *
+ * [method@Gtk.Label.set_justify] sets how the lines in a label align
+ * with one another. If you want to set how the label as a whole aligns
+ * in its available space, see the [property@Gtk.Widget:halign] and
+ * [property@Gtk.Widget:valign] properties.
+ *
+ * The [property@Gtk.Label:width-chars] and [property@Gtk.Label:max-width-chars]
+ * properties can be used to control the size allocation of ellipsized or
+ * wrapped labels. For ellipsizing labels, if either is specified (and less
+ * than the actual text size), it is used as the minimum width, and the actual
+ * text size is used as the natural width of the label. For wrapping labels,
+ * width-chars is used as the minimum width, if specified, and max-width-chars
+ * is used as the natural width. Even if max-width-chars specified, wrapping
+ * labels will be rewrapped to use all of the available width.
+ *
+ * ## Links
+ *
+ * GTK supports markup for clickable hyperlinks in addition to regular Pango
+ * markup. The markup for links is borrowed from HTML, using the `<a>` tag
+ * with “href“, “title“ and “class“ attributes. GTK renders links similar to
+ * the way they appear in web browsers, with colored, underlined text. The
+ * “title“ attribute is displayed as a tooltip on the link. The “class“
+ * attribute is used as style class on the CSS node for the link.
+ *
+ * An example of inline links looks like this:
+ *
+ * ```c
+ * const char *text =
+ * "Go to the "
+ * "<a href=\"https://www.gtk.org\" title=\"&lt;i&gt;Our&lt;/i&gt; website\">"
+ * "GTK website</a> for more...";
+ * GtkWidget *label = gtk_label_new (NULL);
+ * gtk_label_set_markup (GTK_LABEL (label), text);
+ * ```
+ *
+ * It is possible to implement custom handling for links and their tooltips
+ * with the [signal@Gtk.Label::activate-link] signal and the
+ * [method@Gtk.Label.get_current_uri] function.
+ */
 const SIGNAL_META = {
     "activate-current-link": { params: [], returnType: { type: "undefined" } },
     "activate-link": {
@@ -23,6 +238,23 @@ export class Label extends Widget {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new label with the given text inside it, and a mnemonic.
+     *
+     * If characters in `str` are preceded by an underscore, they are
+     * underlined. If you need a literal underscore character in a label, use
+     * '__' (two underscores). The first underlined character represents a
+     * keyboard accelerator called a mnemonic. The mnemonic key can be used
+     * to activate another widget, chosen automatically, or explicitly using
+     * [method@Gtk.Label.set_mnemonic_widget].
+     *
+     * If [method@Gtk.Label.set_mnemonic_widget] is not called, then the first
+     * activatable ancestor of the label will be chosen as the mnemonic
+     * widget. For instance, if the label is inside a button or menu item,
+     * the button or menu item will automatically become the mnemonic widget
+     * and be activated by the mnemonic.
+     * @param str - the text of the label, with an underscore in front of the
+     */
     static newWithMnemonic(str) {
         const ptr = call("libgtk-4.so.1", "gtk_label_new_with_mnemonic", [
             {
@@ -43,6 +275,16 @@ export class Label extends Widget {
             },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the label's attribute list.
+     *
+     * This is the [struct@Pango.AttrList] that was set on the label using
+     * [method@Gtk.Label.set_attributes], if any. This function does not
+     * reflect attributes that come from the label's markup (see
+     * [method@Gtk.Label.set_markup]). If you want to get the effective
+     * attributes for the label, use
+     * `pango_layout_get_attributes (gtk_label_get_layout (self))`.
+     */
     getAttributes() {
         const ptr = call("libgtk-4.so.1", "gtk_label_get_attributes", [
             {
@@ -59,6 +301,16 @@ export class Label extends Widget {
             return null;
         return getObject(ptr, Pango.AttrList);
     }
+    /**
+     * Returns the URI for the active link in the label.
+     *
+     * The active link is the one under the mouse pointer or, in a
+     * selectable label, the link in which the text cursor is currently
+     * positioned.
+     *
+     * This function is intended for use in a [signal@Gtk.Label::activate-link]
+     * handler or for use in a [signal@Gtk.Widget::query-tooltip] handler.
+     */
     getCurrentUri() {
         return call("libgtk-4.so.1", "gtk_label_get_current_uri", [
             {
@@ -67,6 +319,11 @@ export class Label extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns the ellipsization mode of the label.
+     *
+     * See [method@Gtk.Label.set_ellipsize].
+     */
     getEllipsize() {
         return call("libgtk-4.so.1", "gtk_label_get_ellipsize", [
             {
@@ -75,6 +332,11 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the extra menu model of the label.
+     *
+     * See [method@Gtk.Label.set_extra_menu].
+     */
     getExtraMenu() {
         const ptr = call("libgtk-4.so.1", "gtk_label_get_extra_menu", [
             {
@@ -86,6 +348,11 @@ export class Label extends Widget {
             return null;
         return getObject(ptr, Gio.MenuModel);
     }
+    /**
+     * Returns the justification of the label.
+     *
+     * See [method@Gtk.Label.set_justify].
+     */
     getJustify() {
         return call("libgtk-4.so.1", "gtk_label_get_justify", [
             {
@@ -94,6 +361,12 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Fetches the text from a label.
+     *
+     * The returned text includes any embedded underlines indicating
+     * mnemonics and Pango markup. (See [method@Gtk.Label.get_text]).
+     */
     getLabel() {
         return call("libgtk-4.so.1", "gtk_label_get_label", [
             {
@@ -102,6 +375,15 @@ export class Label extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the Pango layout used to display the label.
+     *
+     * The layout is useful to e.g. convert text positions to pixel
+     * positions, in combination with [method@Gtk.Label.get_layout_offsets].
+     * The returned layout is owned by the `label` so need not be
+     * freed by the caller. The `label` is free to recreate its layout
+     * at any time, so it should be considered read-only.
+     */
     getLayout() {
         const ptr = call("libgtk-4.so.1", "gtk_label_get_layout", [
             {
@@ -111,6 +393,17 @@ export class Label extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pango.Layout);
     }
+    /**
+     * Obtains the coordinates where the label will draw its Pango layout.
+     *
+     * The coordinates are useful to convert mouse events into coordinates
+     * inside the [class@Pango.Layout], e.g. to take some action if some part
+     * of the label is clicked. Remember when using the [class@Pango.Layout]
+     * functions you need to convert to and from pixels using `PANGO_PIXELS()`
+     * or [const@Pango.SCALE].
+     * @param x - location to store X offset of layout
+     * @param y - location to store Y offset of layout
+     */
     getLayoutOffsets(x, y) {
         call("libgtk-4.so.1", "gtk_label_get_layout_offsets", [
             {
@@ -135,6 +428,12 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the number of lines to which an ellipsized, wrapping
+     * label should be limited.
+     *
+     * See [method@Gtk.Label.set_lines].
+     */
     getLines() {
         return call("libgtk-4.so.1", "gtk_label_get_lines", [
             {
@@ -143,6 +442,11 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the maximum width of the label in characters.
+     *
+     * See [method@Gtk.Label.set_width_chars].
+     */
     getMaxWidthChars() {
         return call("libgtk-4.so.1", "gtk_label_get_max_width_chars", [
             {
@@ -151,6 +455,13 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Return the mnemonic accelerator.
+     *
+     * If the label has been set so that it has a mnemonic key this function
+     * returns the keyval used for the mnemonic accelerator. If there is no
+     * mnemonic set up it returns `GDK_KEY_VoidSymbol`.
+     */
     getMnemonicKeyval() {
         return call("libgtk-4.so.1", "gtk_label_get_mnemonic_keyval", [
             {
@@ -159,6 +470,11 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Retrieves the mnemonic target of this label.
+     *
+     * See [method@Gtk.Label.set_mnemonic_widget].
+     */
     getMnemonicWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_label_get_mnemonic_widget", [
             {
@@ -170,6 +486,11 @@ export class Label extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns natural line wrap mode used by the label.
+     *
+     * See [method@Gtk.Label.set_natural_wrap_mode].
+     */
     getNaturalWrapMode() {
         return call("libgtk-4.so.1", "gtk_label_get_natural_wrap_mode", [
             {
@@ -178,6 +499,9 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns whether the label is selectable.
+     */
     getSelectable() {
         return call("libgtk-4.so.1", "gtk_label_get_selectable", [
             {
@@ -186,6 +510,13 @@ export class Label extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the selected range of characters in the label.
+     *
+     * The returned `start` and `end` positions are in characters.
+     * @param start - return location for start of selection
+     * @param end - return location for end of selection
+     */
     getSelectionBounds(start, end) {
         return call("libgtk-4.so.1", "gtk_label_get_selection_bounds", [
             {
@@ -210,6 +541,9 @@ export class Label extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the label is in single line mode.
+     */
     getSingleLineMode() {
         return call("libgtk-4.so.1", "gtk_label_get_single_line_mode", [
             {
@@ -218,6 +552,11 @@ export class Label extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the tab stops for the label.
+     *
+     * The returned array will be `NULL` if “standard” (8-space) tabs are used.
+     */
     getTabs() {
         const ptr = call("libgtk-4.so.1", "gtk_label_get_tabs", [
             {
@@ -234,6 +573,13 @@ export class Label extends Widget {
             return null;
         return getObject(ptr, Pango.TabArray);
     }
+    /**
+     * Gets the text of the label.
+     *
+     * The returned text is as it appears on screen. This does not include
+     * any embedded underlines indicating mnemonics or Pango markup. (See
+     * [method@Gtk.Label.get_label])
+     */
     getText() {
         return call("libgtk-4.so.1", "gtk_label_get_text", [
             {
@@ -242,6 +588,11 @@ export class Label extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns whether the label’s text is interpreted as Pango markup.
+     *
+     * See [method@Gtk.Label.set_use_markup].
+     */
     getUseMarkup() {
         return call("libgtk-4.so.1", "gtk_label_get_use_markup", [
             {
@@ -250,6 +601,11 @@ export class Label extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether underlines in the label indicate mnemonics.
+     *
+     * See [method@Gtk.Label.set_use_underline].
+     */
     getUseUnderline() {
         return call("libgtk-4.so.1", "gtk_label_get_use_underline", [
             {
@@ -258,6 +614,11 @@ export class Label extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the desired width of the label in characters.
+     *
+     * See [method@Gtk.Label.set_width_chars].
+     */
     getWidthChars() {
         return call("libgtk-4.so.1", "gtk_label_get_width_chars", [
             {
@@ -266,6 +627,11 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns whether lines in the label are automatically wrapped.
+     *
+     * See [method@Gtk.Label.set_wrap].
+     */
     getWrap() {
         return call("libgtk-4.so.1", "gtk_label_get_wrap", [
             {
@@ -274,6 +640,11 @@ export class Label extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns line wrap mode used by the label.
+     *
+     * See [method@Gtk.Label.set_wrap_mode].
+     */
     getWrapMode() {
         return call("libgtk-4.so.1", "gtk_label_get_wrap_mode", [
             {
@@ -282,6 +653,11 @@ export class Label extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the `xalign` of the label.
+     *
+     * See the [property@Gtk.Label:xalign] property.
+     */
     getXalign() {
         return call("libgtk-4.so.1", "gtk_label_get_xalign", [
             {
@@ -290,6 +666,11 @@ export class Label extends Widget {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Gets the `yalign` of the label.
+     *
+     * See the [property@Gtk.Label:yalign] property.
+     */
     getYalign() {
         return call("libgtk-4.so.1", "gtk_label_get_yalign", [
             {
@@ -298,6 +679,15 @@ export class Label extends Widget {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Selects a range of characters in the label, if the label is selectable.
+     *
+     * See [method@Gtk.Label.set_selectable]. If the label is not selectable,
+     * this function has no effect. If `start_offset` or
+     * `end_offset` are -1, then the end of the label will be substituted.
+     * @param startOffset - start offset, in characters
+     * @param endOffset - end offset, in characters
+     */
     selectRegion(startOffset, endOffset) {
         call("libgtk-4.so.1", "gtk_label_select_region", [
             {
@@ -314,6 +704,19 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Apply attributes to the label text.
+     *
+     * The attributes set with this function will be applied and merged with
+     * any other attributes previously effected by way of the
+     * [property@Gtk.Label:use-underline] or [property@Gtk.Label:use-markup]
+     * properties
+     *
+     * While it is not recommended to mix markup strings with manually set
+     * attributes, if you must; know that the attributes will be applied
+     * to the label after the markup string is parsed.
+     * @param attrs - a list of style attributes
+     */
     setAttributes(attrs) {
         call("libgtk-4.so.1", "gtk_label_set_attributes", [
             {
@@ -332,6 +735,13 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the mode used to ellipsize the text.
+     *
+     * The text will be ellipsized if there is not
+     * enough space to render the entire string.
+     * @param mode - the ellipsization mode
+     */
     setEllipsize(mode) {
         call("libgtk-4.so.1", "gtk_label_set_ellipsize", [
             {
@@ -344,6 +754,10 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a menu model to add to the context menu of the label.
+     * @param model - a menu model
+     */
     setExtraMenu(model) {
         call("libgtk-4.so.1", "gtk_label_set_extra_menu", [
             {
@@ -357,6 +771,18 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the alignment of lines in the label relative to each other.
+     *
+     * This function has no effect on labels containing only a single line.
+     *
+     * [enum@Gtk.Justification.left] is the default value when the widget
+     * is first created with [ctor@Gtk.Label.new].
+     *
+     * If you instead want to set the alignment of the label as a whole,
+     * use [method@Gtk.Widget.set_halign] instead.
+     * @param jtype - the new justification
+     */
     setJustify(jtype) {
         call("libgtk-4.so.1", "gtk_label_set_justify", [
             {
@@ -369,6 +795,14 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text of the label.
+     *
+     * The label is interpreted as including embedded underlines and/or Pango
+     * markup depending on the values of the [property@Gtk.Label:use-underline]
+     * and [property@Gtk.Label:use-markup] properties.
+     * @param str - the new text to set for the label
+     */
     setLabel(str) {
         call("libgtk-4.so.1", "gtk_label_set_label", [
             {
@@ -381,6 +815,14 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the number of lines to which an ellipsized, wrapping label
+     * should be limited.
+     *
+     * This has no effect if the label is not wrapping or ellipsized.
+     * Set this to -1 if you don’t want to limit the number of lines.
+     * @param lines - the desired number of lines, or -1
+     */
     setLines(lines) {
         call("libgtk-4.so.1", "gtk_label_set_lines", [
             {
@@ -393,6 +835,32 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the labels text and attributes from markup.
+     *
+     * The string must be marked up with Pango markup
+     * (see [func@Pango.parse_markup]).
+     *
+     * If `str` is external data, you may need to escape it
+     * with [func@GLib.markup_escape_text] or [func@GLib.markup_printf_escaped]:
+     *
+     * ```c
+     * GtkWidget *self = gtk_label_new (NULL);
+     * const char *str = "...";
+     * const char *format = "<span style=\"italic\">\%s</span>";
+     * char *markup;
+     *
+     * markup = g_markup_printf_escaped (format, str);
+     * gtk_label_set_markup (GTK_LABEL (self), markup);
+     * g_free (markup);
+     * ```
+     *
+     * This function sets the [property@Gtk.Label:use-markup] property
+     * to true.
+     *
+     * Also see [method@Gtk.Label.set_text].
+     * @param str - the markup string
+     */
     setMarkup(str) {
         call("libgtk-4.so.1", "gtk_label_set_markup", [
             {
@@ -405,6 +873,18 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the labels text, attributes and mnemonic from markup.
+     *
+     * Parses `str` which is marked up with Pango markup (see [func@Pango.parse_markup]),
+     * setting the label’s text and attribute list based on the parse results.
+     * If characters in `str` are preceded by an underscore, they are underlined
+     * indicating that they represent a keyboard accelerator called a mnemonic.
+     *
+     * The mnemonic key can be used to activate another widget, chosen
+     * automatically, or explicitly using [method@Gtk.Label.set_mnemonic_widget].
+     * @param str - the markup string
+     */
     setMarkupWithMnemonic(str) {
         call("libgtk-4.so.1", "gtk_label_set_markup_with_mnemonic", [
             {
@@ -417,6 +897,10 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the maximum width of the label in characters.
+     * @param nChars - the new maximum width, in characters.
+     */
     setMaxWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_label_set_max_width_chars", [
             {
@@ -429,6 +913,26 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Associate the label with its mnemonic target.
+     *
+     * If the label has been set so that it has a mnemonic key (using
+     * i.e. [method@Gtk.Label.set_markup_with_mnemonic],
+     * [method@Gtk.Label.set_text_with_mnemonic],
+     * [ctor@Gtk.Label.new_with_mnemonic]
+     * or the [property@Gtk.Label:use_underline] property) the label can
+     * be associated with a widget that is the target of the mnemonic.
+     * When the label is inside a widget (like a [class@Gtk.Button] or a
+     * [class@Gtk.Notebook] tab) it is automatically associated with the
+     * correct widget, but sometimes (i.e. when the target is a [class@Gtk.Entry]
+     * next to the label) you need to set it explicitly using this function.
+     *
+     * The target widget will be accelerated by emitting the
+     * [signal@Gtk.Widget::mnemonic-activate] signal on it. The default handler
+     * for this signal will activate the widget if there are no mnemonic
+     * collisions and toggle focus between the colliding widgets otherwise.
+     * @param widget - the target widget
+     */
     setMnemonicWidget(widget) {
         call("libgtk-4.so.1", "gtk_label_set_mnemonic_widget", [
             {
@@ -442,6 +946,13 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Selects the line wrapping for the natural size request.
+     *
+     * This only affects the natural size requested, for the actual wrapping used,
+     * see the [property@Gtk.Label:wrap-mode] property.
+     * @param wrapMode - the line wrapping mode
+     */
     setNaturalWrapMode(wrapMode) {
         call("libgtk-4.so.1", "gtk_label_set_natural_wrap_mode", [
             {
@@ -454,6 +965,13 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Makes text in the label selectable.
+     *
+     * Selectable labels allow the user to select text from the label,
+     * for copy-and-paste.
+     * @param setting - true to allow selecting text in the label
+     */
     setSelectable(setting) {
         call("libgtk-4.so.1", "gtk_label_set_selectable", [
             {
@@ -466,6 +984,10 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the label is in single line mode.
+     * @param singleLineMode - true to enable single line mode
+     */
     setSingleLineMode(singleLineMode) {
         call("libgtk-4.so.1", "gtk_label_set_single_line_mode", [
             {
@@ -478,6 +1000,10 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets tab stops for the label.
+     * @param tabs - tab stops
+     */
     setTabs(tabs) {
         call("libgtk-4.so.1", "gtk_label_set_tabs", [
             {
@@ -496,6 +1022,17 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text for the label.
+     *
+     * It overwrites any text that was there before and clears any
+     * previously set mnemonic accelerators, and sets the
+     * [property@Gtk.Label:use-underline] and
+     * [property@Gtk.Label:use-markup] properties to false.
+     *
+     * Also see [method@Gtk.Label.set_markup].
+     * @param str - the text to show in @self
+     */
     setText(str) {
         call("libgtk-4.so.1", "gtk_label_set_text", [
             {
@@ -508,6 +1045,15 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text for the label, with mnemonics.
+     *
+     * If characters in `str` are preceded by an underscore, they are underlined
+     * indicating that they represent a keyboard accelerator called a mnemonic.
+     * The mnemonic key can be used to activate another widget, chosen
+     * automatically, or explicitly using [method@Gtk.Label.set_mnemonic_widget].
+     * @param str - the text
+     */
     setTextWithMnemonic(str) {
         call("libgtk-4.so.1", "gtk_label_set_text_with_mnemonic", [
             {
@@ -520,6 +1066,12 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the text of the label contains markup.
+     *
+     * See [method@Gtk.Label.set_markup].
+     * @param setting - true if the label’s text should be parsed for markup.
+     */
     setUseMarkup(setting) {
         call("libgtk-4.so.1", "gtk_label_set_use_markup", [
             {
@@ -532,6 +1084,10 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether underlines in the text indicate mnemonics.
+     * @param setting - true if underlines in the text indicate mnemonics
+     */
     setUseUnderline(setting) {
         call("libgtk-4.so.1", "gtk_label_set_use_underline", [
             {
@@ -544,6 +1100,10 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the desired width in characters of the label.
+     * @param nChars - the new desired width, in characters.
+     */
     setWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_label_set_width_chars", [
             {
@@ -556,6 +1116,20 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Toggles line wrapping within the label.
+     *
+     * True makes it break lines if text exceeds the widget’s size.
+     * false lets the text get cut off by the edge of the widget if
+     * it exceeds the widget size.
+     *
+     * Note that setting line wrapping to true does not make the label
+     * wrap at its parent widget’s width, because GTK widgets conceptually
+     * can’t make their requisition depend on the parent  widget’s size.
+     * For a label that wraps at a specific position, set the label’s width
+     * using [method@Gtk.Widget.set_size_request].
+     * @param wrap - whether to wrap lines
+     */
     setWrap(wrap) {
         call("libgtk-4.so.1", "gtk_label_set_wrap", [
             {
@@ -568,6 +1142,19 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Controls how line wrapping is done.
+     *
+     * This only affects the label if line wrapping is on. (See
+     * [method@Gtk.Label.set_wrap])
+     *
+     * The default is [enum@Pango.WrapMode.word], which means
+     * wrap on word boundaries.
+     *
+     * For sizing behavior, also consider the
+     * [property@Gtk.Label:natural-wrap-mode] property.
+     * @param wrapMode - the line wrapping mode
+     */
     setWrapMode(wrapMode) {
         call("libgtk-4.so.1", "gtk_label_set_wrap_mode", [
             {
@@ -580,6 +1167,12 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `xalign` of the label.
+     *
+     * See the [property@Gtk.Label:xalign] property.
+     * @param xalign - the new xalign value, between 0 and 1
+     */
     setXalign(xalign) {
         call("libgtk-4.so.1", "gtk_label_set_xalign", [
             {
@@ -592,6 +1185,12 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `yalign` of the label.
+     *
+     * See the [property@Gtk.Label:yalign] property.
+     * @param yalign - the new yalign value, between 0 and 1
+     */
     setYalign(yalign) {
         call("libgtk-4.so.1", "gtk_label_set_yalign", [
             {
@@ -604,6 +1203,13 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates the position of the caret.
+     *
+     * Implementations of the `GtkAccessibleText` interface should call this
+     * function every time the caret has moved, in order to notify assistive
+     * technologies.
+     */
     updateCaretPosition() {
         call("libgtk-4.so.1", "gtk_accessible_text_update_caret_position", [
             {
@@ -612,6 +1218,20 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Notifies assistive technologies of a change in contents.
+     *
+     * Implementations of the `GtkAccessibleText` interface should call this
+     * function every time their contents change as the result of an operation,
+     * like an insertion or a removal.
+     *
+     * Note: If the change is a deletion, this function must be called *before*
+     * removing the contents, if it is an insertion, it must be called *after*
+     * inserting the new contents.
+     * @param change - the type of change in the contents
+     * @param start - the starting offset of the change, in characters
+     * @param end - the end offset of the change, in characters
+     */
     updateContents(change, start, end) {
         call("libgtk-4.so.1", "gtk_accessible_text_update_contents", [
             {
@@ -632,6 +1252,13 @@ export class Label extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates the boundary of the selection.
+     *
+     * Implementations of the `GtkAccessibleText` interface should call this
+     * function every time the selection has moved, in order to notify assistive
+     * technologies.
+     */
     updateSelectionBound() {
         call("libgtk-4.so.1", "gtk_accessible_text_update_selection_bound", [
             {