@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/pango/layout.d.ts

@@ -8,74 +8,736 @@ 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 declare class Layout extends GObject.GObject {
+    /**
+     * Create a new `PangoLayout` object with attributes initialized to
+     * default values for a particular `PangoContext`.
+     * @param context - a `PangoContext`
+     */
     constructor(context: Context);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * 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: Context, bytes: GLib.Bytes, flags: LayoutDeserializeFlags): 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(): void;
+    /**
+     * 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(): Layout;
+    /**
+     * Gets the alignment for the layout: how partial lines are
+     * positioned within the horizontal space available.
+     */
     getAlignment(): Alignment;
+    /**
+     * Gets the attribute list for the layout, if any.
+     */
     getAttributes(): AttrList | null;
+    /**
+     * Gets whether to calculate the base direction for the layout
+     * according to its contents.
+     *
+     * See [method@Pango.Layout.set_auto_dir].
+     */
     getAutoDir(): boolean;
+    /**
+     * Gets the Y position of baseline of the first line in @layout.
+     */
     getBaseline(): number;
+    /**
+     * 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_: number, strongPos?: Ref<number> | null, weakPos?: Ref<number> | null): void;
+    /**
+     * Returns the number of Unicode characters in the
+     * the text of @layout.
+     */
     getCharacterCount(): number;
+    /**
+     * Retrieves the `PangoContext` used for this layout.
+     */
     getContext(): 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_: number, strongPos?: Ref<number> | null, weakPos?: Ref<number> | null): void;
+    /**
+     * Gets the text direction at the given character position in @layout.
+     * @param index - the byte index of the char
+     */
     getDirection(index: number): Direction;
+    /**
+     * 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(): EllipsizeMode;
+    /**
+     * 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?: Ref<number> | null, logicalRect?: Ref<number> | null): void;
+    /**
+     * Gets the font description for the layout, if any.
+     */
     getFontDescription(): FontDescription | null;
+    /**
+     * Gets the height of layout used for ellipsization.
+     *
+     * See [method@Pango.Layout.set_height] for details.
+     */
     getHeight(): number;
+    /**
+     * Gets the paragraph indent width in Pango units.
+     *
+     * A negative value indicates a hanging indentation.
+     */
     getIndent(): number;
+    /**
+     * Returns an iterator to iterate over the visual extents of the layout.
+     */
     getIter(): LayoutIter;
+    /**
+     * Gets whether each complete line should be stretched to fill the entire
+     * width of the layout.
+     */
     getJustify(): boolean;
+    /**
+     * Gets whether the last line should be stretched
+     * to fill the entire width of the layout.
+     */
     getJustifyLastLine(): 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: number): LayoutLine | null;
+    /**
+     * Retrieves the count of lines for the @layout.
+     */
     getLineCount(): number;
+    /**
+     * 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: number): LayoutLine | null;
+    /**
+     * Gets the line spacing factor of @layout.
+     *
+     * See [method@Pango.Layout.set_line_spacing].
+     */
     getLineSpacing(): number;
+    /**
+     * 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(): LayoutLine[];
+    /**
+     * 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(): LayoutLine[];
+    /**
+     * 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: Ref<number[]>, nAttrs: Ref<number>): void;
+    /**
+     * 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: Ref<number>): number[];
+    /**
+     * 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?: Ref<number> | null, logicalRect?: Ref<number> | null): void;
+    /**
+     * 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?: Ref<number> | null, height?: Ref<number> | null): void;
+    /**
+     * 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(): number;
+    /**
+     * Obtains whether `layout` is in single paragraph mode.
+     *
+     * See [method@Pango.Layout.set_single_paragraph_mode].
+     */
     getSingleParagraphMode(): 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?: Ref<number> | null, height?: Ref<number> | null): void;
+    /**
+     * Gets the amount of spacing between the lines of the layout.
+     */
     getSpacing(): number;
+    /**
+     * 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(): TabArray | null;
+    /**
+     * Gets the text in the layout.
+     *
+     * The returned text should not be freed or modified.
+     */
     getText(): string;
+    /**
+     * 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(): number;
+    /**
+     * Gets the width to which the lines of the `PangoLayout` should wrap.
+     */
     getWidth(): number;
+    /**
+     * Gets the wrap mode for the layout.
+     *
+     * Use [method@Pango.Layout.is_wrapped] to query whether
+     * any paragraphs were actually wrapped.
+     */
     getWrap(): WrapMode;
+    /**
+     * 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_: number, trailing: boolean, line?: Ref<number> | null, xPos?: Ref<number> | null): void;
+    /**
+     * 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_: number, pos: Ref<number>): void;
+    /**
+     * 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(): 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(): 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: boolean, oldIndex: number, oldTrailing: number, direction: number, newIndex: Ref<number>, newTrailing: Ref<number>): void;
+    /**
+     * 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: LayoutSerializeFlags): 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: Alignment): void;
+    /**
+     * Sets the text attributes for a layout object.
+     *
+     * References @attrs, so the caller can unref its reference.
+     * @param attrs - a `PangoAttrList`
+     */
     setAttributes(attrs?: AttrList | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: EllipsizeMode): void;
+    /**
+     * 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?: FontDescription | null): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: string, length: number): void;
+    /**
+     * 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: string, length: number, accelMarker: number, accelChar?: Ref<number> | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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?: TabArray | null): void;
+    /**
+     * 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: string, length: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: WrapMode): void;
+    /**
+     * 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: LayoutSerializeFlags, filename: string): boolean;
+    /**
+     * 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: number, y: number, index_: Ref<number>, trailing: Ref<number>): boolean;
     connect(signal: "notify", handler: (self: Layout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;