@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/pango/layout.js

@@ -8,6 +8,43 @@ import { TabArray } from "./tab-array.js";
 import { Context } from "./context.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A `PangoLayout` structure represents an entire paragraph of text.
+ *
+ * While complete access to the layout capabilities of Pango is provided
+ * using the detailed interfaces for itemization and shaping, using
+ * that functionality directly involves writing a fairly large amount
+ * of code. `PangoLayout` provides a high-level driver for formatting
+ * entire paragraphs of text at once. This includes paragraph-level
+ * functionality such as line breaking, justification, alignment and
+ * ellipsization.
+ *
+ * A `PangoLayout` is initialized with a `PangoContext`, UTF-8 string
+ * and set of attributes for that string. Once that is done, the set of
+ * formatted lines can be extracted from the object, the layout can be
+ * rendered, and conversion between logical character positions within
+ * the layout's text, and the physical position of the resulting glyphs
+ * can be made.
+ *
+ * There are a number of parameters to adjust the formatting of a
+ * `PangoLayout`. The following image shows adjustable parameters
+ * (on the left) and font metrics (on the right):
+ *
+ *
+ *
+ * The following images demonstrate the effect of alignment and
+ * justification on the layout of text:
+ *
+ * | | |
+ * | --- | --- |
+ * |  |  |
+ * |  |  |
+ * |  |  |
+ *
+ *
+ * It is possible, as well, to ignore the 2-D setup,
+ * and simply treat the results of a `PangoLayout` as a list of lines.
+ */
 export class Layout extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -21,6 +58,18 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Loads data previously created via [method@Pango.Layout.serialize].
+     *
+     * For a discussion of the supported format, see that function.
+     *
+     * Note: to verify that the returned layout is identical to
+     * the one that was serialized, you can compare `bytes` to the
+     * result of serializing the layout again.
+     * @param context - a `PangoContext`
+     * @param bytes - the bytes containing the data
+     * @param flags - `PangoLayoutDeserializeFlags`
+     */
     static deserialize(context, bytes, flags) {
         const error = { value: null };
         const ptr = call("libpango-1.0.so.0", "pango_layout_deserialize", [
@@ -58,6 +107,13 @@ export class Layout extends GObject.GObject {
         }
         return getObject(ptr, Layout);
     }
+    /**
+     * Forces recomputation of any state in the `PangoLayout` that
+     * might depend on the layout's context.
+     *
+     * This function should be called if you make changes to the context
+     * subsequent to creating the layout.
+     */
     contextChanged() {
         call("libpango-1.0.so.0", "pango_layout_context_changed", [
             {
@@ -66,6 +122,12 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a deep copy-by-value of the layout.
+     *
+     * The attribute list, tab array, and text from the original layout
+     * are all copied by value.
+     */
     copy() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_copy", [
             {
@@ -75,6 +137,10 @@ export class Layout extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Layout);
     }
+    /**
+     * Gets the alignment for the layout: how partial lines are
+     * positioned within the horizontal space available.
+     */
     getAlignment() {
         return call("libpango-1.0.so.0", "pango_layout_get_alignment", [
             {
@@ -83,6 +149,9 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the attribute list for the layout, if any.
+     */
     getAttributes() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_get_attributes", [
             {
@@ -99,6 +168,12 @@ export class Layout extends GObject.GObject {
             return null;
         return getObject(ptr, AttrList);
     }
+    /**
+     * Gets whether to calculate the base direction for the layout
+     * according to its contents.
+     *
+     * See [method@Pango.Layout.set_auto_dir].
+     */
     getAutoDir() {
         return call("libpango-1.0.so.0", "pango_layout_get_auto_dir", [
             {
@@ -107,6 +182,9 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the Y position of baseline of the first line in @layout.
+     */
     getBaseline() {
         return call("libpango-1.0.so.0", "pango_layout_get_baseline", [
             {
@@ -115,6 +193,17 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Given an index within a layout, determines the positions that of the
+     * strong and weak cursors if the insertion point is at that index.
+     *
+     * This is a variant of [method@Pango.Layout.get_cursor_pos] that applies
+     * font metric information about caret slope and offset to the positions
+     * it returns.
+     * @param index_ - the byte index of the cursor
+     * @param strongPos - location to store the strong cursor position
+     * @param weakPos - location to store the weak cursor position
+     */
     getCaretPos(index_, strongPos, weakPos) {
         call("libpango-1.0.so.0", "pango_layout_get_caret_pos", [
             {
@@ -143,6 +232,10 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the number of Unicode characters in the
+     * the text of @layout.
+     */
     getCharacterCount() {
         return call("libpango-1.0.so.0", "pango_layout_get_character_count", [
             {
@@ -151,6 +244,9 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the `PangoContext` used for this layout.
+     */
     getContext() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_get_context", [
             {
@@ -160,6 +256,32 @@ export class Layout extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Context);
     }
+    /**
+     * Given an index within a layout, determines the positions that of the
+     * strong and weak cursors if the insertion point is at that index.
+     *
+     * The position of each cursor is stored as a zero-width rectangle
+     * with the height of the run extents.
+     *
+     *
+     *
+     * The strong cursor location is the location where characters of the
+     * directionality equal to the base direction of the layout are inserted.
+     * The weak cursor location is the location where characters of the
+     * directionality opposite to the base direction of the layout are inserted.
+     *
+     * The following example shows text with both a strong and a weak cursor.
+     *
+     *
+     *
+     * The strong cursor has a little arrow pointing to the right, the weak
+     * cursor to the left. Typing a 'c' in this situation will insert the
+     * character after the 'b', and typing another Hebrew character, like 'ג',
+     * will insert it at the end.
+     * @param index_ - the byte index of the cursor
+     * @param strongPos - location to store the strong cursor position
+     * @param weakPos - location to store the weak cursor position
+     */
     getCursorPos(index_, strongPos, weakPos) {
         call("libpango-1.0.so.0", "pango_layout_get_cursor_pos", [
             {
@@ -188,6 +310,10 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the text direction at the given character position in @layout.
+     * @param index - the byte index of the char
+     */
     getDirection(index) {
         return call("libpango-1.0.so.0", "pango_layout_get_direction", [
             {
@@ -200,6 +326,14 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the type of ellipsization being performed for @layout.
+     *
+     * See [method@Pango.Layout.set_ellipsize].
+     *
+     * Use [method@Pango.Layout.is_ellipsized] to query whether any
+     * paragraphs were actually ellipsized.
+     */
     getEllipsize() {
         return call("libpango-1.0.so.0", "pango_layout_get_ellipsize", [
             {
@@ -208,6 +342,20 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Computes the logical and ink extents of @layout.
+     *
+     * Logical extents are usually what you want for positioning things. Note
+     * that both extents may have non-zero x and y. You may want to use those
+     * to offset where you render the layout. Not doing that is a very typical
+     * bug that shows up as right-to-left layouts not being correctly positioned
+     * in a layout with a set width.
+     *
+     * The extents are given in layout coordinates and in Pango units; layout
+     * coordinates begin at the top left corner of the layout.
+     * @param inkRect - rectangle used to store the extents of the
+     * @param logicalRect - rectangle used to store the logical
+     */
     getExtents(inkRect, logicalRect) {
         call("libpango-1.0.so.0", "pango_layout_get_extents", [
             {
@@ -232,6 +380,9 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the font description for the layout, if any.
+     */
     getFontDescription() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_get_font_description", [
             {
@@ -248,6 +399,11 @@ export class Layout extends GObject.GObject {
             return null;
         return getObject(ptr, FontDescription);
     }
+    /**
+     * Gets the height of layout used for ellipsization.
+     *
+     * See [method@Pango.Layout.set_height] for details.
+     */
     getHeight() {
         return call("libpango-1.0.so.0", "pango_layout_get_height", [
             {
@@ -256,6 +412,11 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the paragraph indent width in Pango units.
+     *
+     * A negative value indicates a hanging indentation.
+     */
     getIndent() {
         return call("libpango-1.0.so.0", "pango_layout_get_indent", [
             {
@@ -264,6 +425,9 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns an iterator to iterate over the visual extents of the layout.
+     */
     getIter() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_get_iter", [
             {
@@ -278,6 +442,10 @@ export class Layout extends GObject.GObject {
         });
         return getObject(ptr, LayoutIter);
     }
+    /**
+     * Gets whether each complete line should be stretched to fill the entire
+     * width of the layout.
+     */
     getJustify() {
         return call("libpango-1.0.so.0", "pango_layout_get_justify", [
             {
@@ -286,6 +454,10 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether the last line should be stretched
+     * to fill the entire width of the layout.
+     */
     getJustifyLastLine() {
         return call("libpango-1.0.so.0", "pango_layout_get_justify_last_line", [
             {
@@ -294,6 +466,13 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves a particular line from a `PangoLayout`.
+     *
+     * Use the faster [method@Pango.Layout.get_line_readonly] if you do not
+     * plan to modify the contents of the line (glyphs, glyph widths, etc.).
+     * @param line - the index of a line, which must be between 0 and
+     */
     getLine(line) {
         const ptr = call("libpango-1.0.so.0", "pango_layout_get_line", [
             {
@@ -314,6 +493,9 @@ export class Layout extends GObject.GObject {
             return null;
         return getObject(ptr, LayoutLine);
     }
+    /**
+     * Retrieves the count of lines for the @layout.
+     */
     getLineCount() {
         return call("libpango-1.0.so.0", "pango_layout_get_line_count", [
             {
@@ -322,6 +504,14 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves a particular line from a `PangoLayout`.
+     *
+     * This is a faster alternative to [method@Pango.Layout.get_line],
+     * but the user is not expected to modify the contents of the line
+     * (glyphs, glyph widths, etc.).
+     * @param line - the index of a line, which must be between 0 and
+     */
     getLineReadonly(line) {
         const ptr = call("libpango-1.0.so.0", "pango_layout_get_line_readonly", [
             {
@@ -342,6 +532,11 @@ export class Layout extends GObject.GObject {
             return null;
         return getObject(ptr, LayoutLine);
     }
+    /**
+     * Gets the line spacing factor of @layout.
+     *
+     * See [method@Pango.Layout.set_line_spacing].
+     */
     getLineSpacing() {
         return call("libpango-1.0.so.0", "pango_layout_get_line_spacing", [
             {
@@ -350,6 +545,12 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Returns the lines of the `layout` as a list.
+     *
+     * Use the faster [method@Pango.Layout.get_lines_readonly] if you do not
+     * plan to modify the contents of the lines (glyphs, glyph widths, etc.).
+     */
     getLines() {
         return call("libpango-1.0.so.0", "pango_layout_get_lines", [
             {
@@ -367,6 +568,13 @@ export class Layout extends GObject.GObject {
             borrowed: true,
         });
     }
+    /**
+     * Returns the lines of the `layout` as a list.
+     *
+     * This is a faster alternative to [method@Pango.Layout.get_lines],
+     * but the user is not expected to modify the contents of the lines
+     * (glyphs, glyph widths, etc.).
+     */
     getLinesReadonly() {
         return call("libpango-1.0.so.0", "pango_layout_get_lines_readonly", [
             {
@@ -384,6 +592,12 @@ export class Layout extends GObject.GObject {
             borrowed: true,
         });
     }
+    /**
+     * Retrieves an array of logical attributes for each character in
+     * the @layout.
+     * @param attrs - location to store a pointer to an array of logical attributes.
+     * @param nAttrs - location to store the number of the attributes in the
+     */
     getLogAttrs(attrs, nAttrs) {
         call("libpango-1.0.so.0", "pango_layout_get_log_attrs", [
             {
@@ -409,6 +623,20 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves an array of logical attributes for each character in
+     * the @layout.
+     *
+     * This is a faster alternative to [method@Pango.Layout.get_log_attrs].
+     * The returned array is part of `layout` and must not be modified.
+     * Modifying the layout will invalidate the returned array.
+     *
+     * The number of attributes returned in `n_attrs` will be one more
+     * than the total number of characters in the layout, since there
+     * need to be attributes corresponding to both the position before
+     * the first character and the position after the last character.
+     * @param nAttrs - location to store the number of the attributes in
+     */
     getLogAttrsReadonly(nAttrs) {
         return call("libpango-1.0.so.0", "pango_layout_get_log_attrs_readonly", [
             {
@@ -424,6 +652,15 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "int", size: 64, unsigned: true } });
     }
+    /**
+     * Computes the logical and ink extents of `layout` in device units.
+     *
+     * This function just calls [method@Pango.Layout.get_extents] followed by
+     * two [func@extents_to_pixels] calls, rounding `ink_rect` and `logical_rect` such that the rounded rectangles fully contain the unrounded one (that is,
+     * passes them as first argument to [func@Pango.extents_to_pixels]).
+     * @param inkRect - rectangle used to store the extents of the
+     * @param logicalRect - rectangle used to store the logical
+     */
     getPixelExtents(inkRect, logicalRect) {
         call("libpango-1.0.so.0", "pango_layout_get_pixel_extents", [
             {
@@ -448,6 +685,16 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Determines the logical width and height of a `PangoLayout` in device
+     * units.
+     *
+     * [method@Pango.Layout.get_size] returns the width and height
+     * scaled by %PANGO_SCALE. This is simply a convenience function
+     * around [method@Pango.Layout.get_pixel_extents].
+     * @param width - location to store the logical width
+     * @param height - location to store the logical height
+     */
     getPixelSize(width, height) {
         call("libpango-1.0.so.0", "pango_layout_get_pixel_size", [
             {
@@ -472,6 +719,20 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the current serial number of @layout.
+     *
+     * The serial number is initialized to an small number larger than zero
+     * when a new layout is created and is increased whenever the layout is
+     * changed using any of the setter functions, or the `PangoContext` it
+     * uses has changed. The serial may wrap, but will never have the value 0.
+     * Since it can wrap, never compare it with "less than", always use "not equals".
+     *
+     * This can be used to automatically detect changes to a `PangoLayout`,
+     * and is useful for example to decide whether a layout needs redrawing.
+     * To force the serial to be increased, use
+     * [method@Pango.Layout.context_changed].
+     */
     getSerial() {
         return call("libpango-1.0.so.0", "pango_layout_get_serial", [
             {
@@ -480,6 +741,11 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Obtains whether `layout` is in single paragraph mode.
+     *
+     * See [method@Pango.Layout.set_single_paragraph_mode].
+     */
     getSingleParagraphMode() {
         return call("libpango-1.0.so.0", "pango_layout_get_single_paragraph_mode", [
             {
@@ -488,6 +754,14 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines the logical width and height of a `PangoLayout` in Pango
+     * units.
+     *
+     * This is simply a convenience function around [method@Pango.Layout.get_extents].
+     * @param width - location to store the logical width
+     * @param height - location to store the logical height
+     */
     getLayoutSize(width, height) {
         call("libpango-1.0.so.0", "pango_layout_get_size", [
             {
@@ -512,6 +786,9 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the amount of spacing between the lines of the layout.
+     */
     getSpacing() {
         return call("libpango-1.0.so.0", "pango_layout_get_spacing", [
             {
@@ -520,6 +797,14 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the current `PangoTabArray` used by this layout.
+     *
+     * If no `PangoTabArray` has been set, then the default tabs are
+     * in use and %NULL is returned. Default tabs are every 8 spaces.
+     *
+     * The return value should be freed with [method@Pango.TabArray.free].
+     */
     getTabs() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_get_tabs", [
             {
@@ -536,6 +821,11 @@ export class Layout extends GObject.GObject {
             return null;
         return getObject(ptr, TabArray);
     }
+    /**
+     * Gets the text in the layout.
+     *
+     * The returned text should not be freed or modified.
+     */
     getText() {
         return call("libpango-1.0.so.0", "pango_layout_get_text", [
             {
@@ -544,6 +834,14 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Counts the number of unknown glyphs in @layout.
+     *
+     * This function can be used to determine if there are any fonts
+     * available to render all characters in a certain string, or when
+     * used in combination with %PANGO_ATTR_FALLBACK, to check if a
+     * certain font supports all the characters in the string.
+     */
     getUnknownGlyphsCount() {
         return call("libpango-1.0.so.0", "pango_layout_get_unknown_glyphs_count", [
             {
@@ -552,6 +850,9 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the width to which the lines of the `PangoLayout` should wrap.
+     */
     getWidth() {
         return call("libpango-1.0.so.0", "pango_layout_get_width", [
             {
@@ -560,6 +861,12 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the wrap mode for the layout.
+     *
+     * Use [method@Pango.Layout.is_wrapped] to query whether
+     * any paragraphs were actually wrapped.
+     */
     getWrap() {
         return call("libpango-1.0.so.0", "pango_layout_get_wrap", [
             {
@@ -568,6 +875,15 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Converts from byte `index_` within the `layout` to line and X position.
+     *
+     * The X position is measured from the left edge of the line.
+     * @param index_ - the byte index of a grapheme within the layout
+     * @param trailing - an integer indicating the edge of the grapheme to retrieve the
+     * @param line - location to store resulting line index. (which will
+     * @param xPos - location to store resulting position within line
+     */
     indexToLineX(index_, trailing, line, xPos) {
         call("libpango-1.0.so.0", "pango_layout_index_to_line_x", [
             {
@@ -600,6 +916,17 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts from an index within a `PangoLayout` to the onscreen position
+     * corresponding to the grapheme at that index.
+     *
+     * The returns is represented as rectangle. Note that `pos->x` is
+     * always the leading edge of the grapheme and `pos->x + pos->width` the
+     * trailing edge of the grapheme. If the directionality of the grapheme
+     * is right-to-left, then `pos->width` will be negative.
+     * @param index_ - byte index within @layout
+     * @param pos - rectangle in which to store the position of the grapheme
+     */
     indexToPos(index_, pos) {
         call("libpango-1.0.so.0", "pango_layout_index_to_pos", [
             {
@@ -619,6 +946,13 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Queries whether the layout had to ellipsize any paragraphs.
+     *
+     * This returns %TRUE if the ellipsization mode for `layout` is not %PANGO_ELLIPSIZE_NONE, a positive width is set on @layout,
+     * and there are paragraphs exceeding that width that have to be
+     * ellipsized.
+     */
     isEllipsized() {
         return call("libpango-1.0.so.0", "pango_layout_is_ellipsized", [
             {
@@ -627,6 +961,13 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Queries whether the layout had to wrap any paragraphs.
+     *
+     * This returns %TRUE if a positive width is set on @layout,
+     * and there are paragraphs exceeding the layout width that have
+     * to be wrapped.
+     */
     isWrapped() {
         return call("libpango-1.0.so.0", "pango_layout_is_wrapped", [
             {
@@ -635,6 +976,29 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Computes a new cursor position from an old position and a direction.
+     *
+     * If `direction` is positive, then the new position will cause the strong
+     * or weak cursor to be displayed one position to right of where it was
+     * with the old cursor position. If `direction` is negative, it will be
+     * moved to the left.
+     *
+     * In the presence of bidirectional text, the correspondence between
+     * logical and visual order will depend on the direction of the current
+     * run, and there may be jumps when the cursor is moved off of the end
+     * of a run.
+     *
+     * Motion here is in cursor positions, not in characters, so a single
+     * call to this function may move the cursor over multiple characters
+     * when multiple characters combine to form a single grapheme.
+     * @param strong - whether the moving cursor is the strong cursor or the
+     * @param oldIndex - the byte index of the current cursor position
+     * @param oldTrailing - if 0, the cursor was at the leading edge of the
+     * @param direction - direction to move cursor. A negative
+     * @param newIndex - location to store the new cursor byte index.
+     * @param newTrailing - number of characters to move forward from
+     */
     moveCursorVisually(strong, oldIndex, oldTrailing, direction, newIndex, newTrailing) {
         call("libpango-1.0.so.0", "pango_layout_move_cursor_visually", [
             {
@@ -673,6 +1037,17 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Serializes the `layout` for later deserialization via [func@Pango.Layout.deserialize].
+     *
+     * There are no guarantees about the format of the output across different
+     * versions of Pango and [func@Pango.Layout.deserialize] will reject data
+     * that it cannot parse.
+     *
+     * The intended use of this function is testing, benchmarking and debugging.
+     * The format is not meant as a permanent storage format.
+     * @param flags - `PangoLayoutSerializeFlags`
+     */
     serialize(flags) {
         const ptr = call("libpango-1.0.so.0", "pango_layout_serialize", [
             {
@@ -691,6 +1066,13 @@ export class Layout extends GObject.GObject {
         });
         return getObject(ptr, GLib.Bytes);
     }
+    /**
+     * Sets the alignment for the layout: how partial lines are
+     * positioned within the horizontal space available.
+     *
+     * The default alignment is %PANGO_ALIGN_LEFT.
+     * @param alignment - the alignment
+     */
     setAlignment(alignment) {
         call("libpango-1.0.so.0", "pango_layout_set_alignment", [
             {
@@ -703,6 +1085,12 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text attributes for a layout object.
+     *
+     * References @attrs, so the caller can unref its reference.
+     * @param attrs - a `PangoAttrList`
+     */
     setAttributes(attrs) {
         call("libpango-1.0.so.0", "pango_layout_set_attributes", [
             {
@@ -721,6 +1109,25 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to calculate the base direction
+     * for the layout according to its contents.
+     *
+     * When this flag is on (the default), then paragraphs in `layout` that
+     * begin with strong right-to-left characters (Arabic and Hebrew principally),
+     * will have right-to-left layout, paragraphs with letters from other scripts
+     * will have left-to-right layout. Paragraphs with only neutral characters
+     * get their direction from the surrounding paragraphs.
+     *
+     * When %FALSE, the choice between left-to-right and right-to-left
+     * layout is done according to the base direction of the layout's
+     * `PangoContext`. (See [method@Pango.Context.set_base_dir]).
+     *
+     * When the auto-computed direction of a paragraph differs from the
+     * base direction of the context, the interpretation of
+     * %PANGO_ALIGN_LEFT and %PANGO_ALIGN_RIGHT are swapped.
+     * @param autoDir - if %TRUE, compute the bidirectional base direction
+     */
     setAutoDir(autoDir) {
         call("libpango-1.0.so.0", "pango_layout_set_auto_dir", [
             {
@@ -733,6 +1140,24 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the type of ellipsization being performed for @layout.
+     *
+     * Depending on the ellipsization mode `ellipsize` text is
+     * removed from the start, middle, or end of text so they
+     * fit within the width and height of layout set with
+     * [method@Pango.Layout.set_width] and [method@Pango.Layout.set_height].
+     *
+     * If the layout contains characters such as newlines that
+     * force it to be layed out in multiple paragraphs, then whether
+     * each paragraph is ellipsized separately or the entire layout
+     * is ellipsized as a whole depends on the set height of the layout.
+     *
+     * The default value is %PANGO_ELLIPSIZE_NONE.
+     *
+     * See [method@Pango.Layout.set_height] for details.
+     * @param ellipsize - the new ellipsization mode for @layout
+     */
     setEllipsize(ellipsize) {
         call("libpango-1.0.so.0", "pango_layout_set_ellipsize", [
             {
@@ -745,6 +1170,13 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default font description for the layout.
+     *
+     * If no font description is set on the layout, the
+     * font description from the layout's context is used.
+     * @param desc - the new `PangoFontDescription`
+     */
     setFontDescription(desc) {
         call("libpango-1.0.so.0", "pango_layout_set_font_description", [
             {
@@ -763,6 +1195,34 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the height to which the `PangoLayout` should be ellipsized at.
+     *
+     * There are two different behaviors, based on whether `height` is positive
+     * or negative.
+     *
+     * If `height` is positive, it will be the maximum height of the layout. Only
+     * lines would be shown that would fit, and if there is any text omitted,
+     * an ellipsis added. At least one line is included in each paragraph regardless
+     * of how small the height value is. A value of zero will render exactly one
+     * line for the entire layout.
+     *
+     * If `height` is negative, it will be the (negative of) maximum number of lines
+     * per paragraph. That is, the total number of lines shown may well be more than
+     * this value if the layout contains multiple paragraphs of text.
+     * The default value of -1 means that the first line of each paragraph is ellipsized.
+     * This behavior may be changed in the future to act per layout instead of per
+     * paragraph. File a bug against pango at
+     * [https://gitlab.gnome.org/gnome/pango](https://gitlab.gnome.org/gnome/pango)
+     * if your code relies on this behavior.
+     *
+     * Height setting only has effect if a positive width is set on
+     * `layout` and ellipsization mode of `layout` is not %PANGO_ELLIPSIZE_NONE.
+     * The behavior is undefined if a height other than -1 is set and
+     * ellipsization mode is set to %PANGO_ELLIPSIZE_NONE, and may change in the
+     * future.
+     * @param height - the desired height of the layout in Pango units if positive,
+     */
     setHeight(height) {
         call("libpango-1.0.so.0", "pango_layout_set_height", [
             {
@@ -775,6 +1235,19 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the width in Pango units to indent each paragraph.
+     *
+     * A negative value of `indent` will produce a hanging indentation.
+     * That is, the first line will have the full width, and subsequent
+     * lines will be indented by the absolute value of @indent.
+     *
+     * The indent setting is ignored if layout alignment is set to
+     * %PANGO_ALIGN_CENTER.
+     *
+     * The default value is 0.
+     * @param indent - the amount by which to indent
+     */
     setIndent(indent) {
         call("libpango-1.0.so.0", "pango_layout_set_indent", [
             {
@@ -787,6 +1260,26 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether each complete line should be stretched to fill the
+     * entire width of the layout.
+     *
+     * Stretching is typically done by adding whitespace, but for some scripts
+     * (such as Arabic), the justification may be done in more complex ways,
+     * like extending the characters.
+     *
+     * Note that this setting is not implemented and so is ignored in
+     * Pango older than 1.18.
+     *
+     * Note that tabs and justification conflict with each other:
+     * Justification will move content away from its tab-aligned
+     * positions.
+     *
+     * The default value is %FALSE.
+     *
+     * Also see [method@Pango.Layout.set_justify_last_line].
+     * @param justify - whether the lines in the layout should be justified
+     */
     setJustify(justify) {
         call("libpango-1.0.so.0", "pango_layout_set_justify", [
             {
@@ -799,6 +1292,16 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the last line should be stretched to fill the
+     * entire width of the layout.
+     *
+     * This only has an effect if [method@Pango.Layout.set_justify] has
+     * been called as well.
+     *
+     * The default value is %FALSE.
+     * @param justify - whether the last line in the layout should be justified
+     */
     setJustifyLastLine(justify) {
         call("libpango-1.0.so.0", "pango_layout_set_justify_last_line", [
             {
@@ -811,6 +1314,25 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a factor for line spacing.
+     *
+     * Typical values are: 0, 1, 1.5, 2. The default values is 0.
+     *
+     * If `factor` is non-zero, lines are placed so that
+     *
+     * baseline2 = baseline1 + factor * height2
+     *
+     * where height2 is the line height of the second line
+     * (as determined by the font(s)). In this case, the spacing
+     * set with [method@Pango.Layout.set_spacing] is ignored.
+     *
+     * If `factor` is zero (the default), spacing is applied as before.
+     *
+     * Note: for semantics that are closer to the CSS line-height
+     * property, see [func@Pango.attr_line_height_new].
+     * @param factor - the new line spacing factor
+     */
     setLineSpacing(factor) {
         call("libpango-1.0.so.0", "pango_layout_set_line_spacing", [
             {
@@ -823,6 +1345,18 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the layout text and attribute list from marked-up text.
+     *
+     * See Pango Markup).
+     *
+     * Replaces the current text and attribute list.
+     *
+     * This is the same as [method@Pango.Layout.set_markup_with_accel],
+     * but the markup text isn't scanned for accelerators.
+     * @param markup - marked-up text
+     * @param length - length of marked-up text in bytes, or -1 if `markup` is
+     */
     setMarkup(markup, length) {
         call("libpango-1.0.so.0", "pango_layout_set_markup", [
             {
@@ -839,6 +1373,24 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the layout text and attribute list from marked-up text.
+     *
+     * See Pango Markup).
+     *
+     * Replaces the current text and attribute list.
+     *
+     * If `accel_marker` is nonzero, the given character will mark the
+     * character following it as an accelerator. For example, `accel_marker` might be an ampersand or underscore. All characters marked
+     * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
+     * and the first character so marked will be returned in @accel_char.
+     * Two `accel_marker` characters following each other produce a single
+     * literal `accel_marker` character.
+     * @param markup - marked-up text (see Pango Markup)
+     * @param length - length of marked-up text in bytes, or -1 if `markup` is
+     * @param accelMarker - marker for accelerators in the text
+     * @param accelChar - return location
+     */
     setMarkupWithAccel(markup, length, accelMarker, accelChar) {
         call("libpango-1.0.so.0", "pango_layout_set_markup_with_accel", [
             {
@@ -867,6 +1419,17 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the single paragraph mode of @layout.
+     *
+     * If `setting` is %TRUE, do not treat newlines and similar characters
+     * as paragraph separators; instead, keep all text in a single paragraph,
+     * and display a glyph for paragraph separator characters. Used when
+     * you want to allow editing of newlines on a single text line.
+     *
+     * The default value is %FALSE.
+     * @param setting - new setting
+     */
     setSingleParagraphMode(setting) {
         call("libpango-1.0.so.0", "pango_layout_set_single_paragraph_mode", [
             {
@@ -879,6 +1442,25 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the amount of spacing in Pango units between
+     * the lines of the layout.
+     *
+     * When placing lines with spacing, Pango arranges things so that
+     *
+     * line2.top = line1.bottom + spacing
+     *
+     * The default value is 0.
+     *
+     * Note: Since 1.44, Pango is using the line height (as determined
+     * by the font) for placing lines when the line spacing factor is set
+     * to a non-zero value with [method@Pango.Layout.set_line_spacing].
+     * In that case, the `spacing` set with this function is ignored.
+     *
+     * Note: for semantics that are closer to the CSS line-height
+     * property, see [func@Pango.attr_line_height_new].
+     * @param spacing - the amount of spacing
+     */
     setSpacing(spacing) {
         call("libpango-1.0.so.0", "pango_layout_set_spacing", [
             {
@@ -891,6 +1473,22 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the tabs to use for @layout, overriding the default tabs.
+     *
+     * `PangoLayout` will place content at the next tab position
+     * whenever it meets a Tab character (U+0009).
+     *
+     * By default, tabs are every 8 spaces. If `tabs` is %NULL, the
+     * default tabs are reinstated. `tabs` is copied into the layout;
+     * you must free your copy of `tabs` yourself.
+     *
+     * Note that tabs and justification conflict with each other:
+     * Justification will move content away from its tab-aligned
+     * positions. The same is true for alignments other than
+     * %PANGO_ALIGN_LEFT.
+     * @param tabs - a `PangoTabArray`
+     */
     setTabs(tabs) {
         call("libpango-1.0.so.0", "pango_layout_set_tabs", [
             {
@@ -909,6 +1507,20 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text of the layout.
+     *
+     * This function validates `text` and renders invalid UTF-8
+     * with a placeholder glyph.
+     *
+     * Note that if you have used [method@Pango.Layout.set_markup] or
+     * [method@Pango.Layout.set_markup_with_accel] on `layout` before, you
+     * may want to call [method@Pango.Layout.set_attributes] to clear the
+     * attributes set on the layout from the markup as this function does
+     * not clear attributes.
+     * @param text - the text
+     * @param length - maximum length of @text, in bytes. -1 indicates that
+     */
     setText(text, length) {
         call("libpango-1.0.so.0", "pango_layout_set_text", [
             {
@@ -925,6 +1537,13 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the width to which the lines of the `PangoLayout` should wrap or
+     * get ellipsized.
+     *
+     * The default value is -1: no width set.
+     * @param width - the desired width in Pango units, or -1 to indicate that no
+     */
     setWidth(width) {
         call("libpango-1.0.so.0", "pango_layout_set_width", [
             {
@@ -937,6 +1556,16 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the wrap mode.
+     *
+     * The wrap mode only has effect if a width is set on the layout
+     * with [method@Pango.Layout.set_width]. To turn off wrapping,
+     * set the width to -1.
+     *
+     * The default value is %PANGO_WRAP_WORD.
+     * @param wrap - the wrap mode
+     */
     setWrap(wrap) {
         call("libpango-1.0.so.0", "pango_layout_set_wrap", [
             {
@@ -949,6 +1578,19 @@ export class Layout extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * A convenience method to serialize a layout to a file.
+     *
+     * It is equivalent to calling [method@Pango.Layout.serialize]
+     * followed by [func@GLib.file_set_contents].
+     *
+     * See those two functions for details on the arguments.
+     *
+     * It is mostly intended for use inside a debugger to quickly dump
+     * a layout to a file for later inspection.
+     * @param flags - `PangoLayoutSerializeFlags`
+     * @param filename - the file to save it to
+     */
     writeToFile(flags, filename) {
         const error = { value: null };
         const result = call("libpango-1.0.so.0", "pango_layout_write_to_file", [
@@ -981,6 +1623,21 @@ export class Layout extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Converts from X and Y position within a layout to the byte index to the
+     * character at that logical position.
+     *
+     * If the Y position is not inside the layout, the closest position is
+     * chosen (the position will be clamped inside the layout). If the X position
+     * is not within the layout, then the start or the end of the line is
+     * chosen as described for [method@Pango.LayoutLine.x_to_index]. If either
+     * the X or Y positions were not inside the layout, then the function returns
+     * %FALSE; on an exact hit, it returns %TRUE.
+     * @param x - the X offset (in Pango units) from the left edge of the layout
+     * @param y - the Y offset (in Pango units) from the top edge of the layout
+     * @param index_ - location to store calculated byte index
+     * @param trailing - location to store a integer indicating where
+     */
     xyToIndex(x, y, index_, trailing) {
         return call("libpango-1.0.so.0", "pango_layout_xy_to_index", [
             {