@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/constraint-layout.js

@@ -3,7 +3,175 @@ import { NativeError, getObject } from "@gtkx/ffi";
 import { Constraint } from "./constraint.js";
 import * as Gio from "../gio/index.js";
 import { LayoutManager } from "./layout-manager.js";
+/**
+ * Uses constraints to describe relations between widgets.
+ *
+ * `GtkConstraintLayout` is a layout manager that uses relations between
+ * widget attributes, expressed via [class@Gtk.Constraint] instances, to
+ * measure and allocate widgets.
+ *
+ * ### How do constraints work
+ *
+ * Constraints are objects defining the relationship between attributes
+ * of a widget; you can read the description of the [class@Gtk.Constraint]
+ * class to have a more in depth definition.
+ *
+ * By taking multiple constraints and applying them to the children of
+ * a widget using `GtkConstraintLayout`, it's possible to describe
+ * complex layout policies; each constraint applied to a child or to the parent
+ * widgets contributes to the full description of the layout, in terms of
+ * parameters for resolving the value of each attribute.
+ *
+ * It is important to note that a layout is defined by the totality of
+ * constraints; removing a child, or a constraint, from an existing layout
+ * without changing the remaining constraints may result in an unstable
+ * or unsolvable layout.
+ *
+ * Constraints have an implicit "reading order"; you should start describing
+ * each edge of each child, as well as their relationship with the parent
+ * container, from the top left (or top right, in RTL languages), horizontally
+ * first, and then vertically.
+ *
+ * A constraint-based layout with too few constraints can become "unstable",
+ * that is: have more than one solution. The behavior of an unstable layout
+ * is undefined.
+ *
+ * A constraint-based layout with conflicting constraints may be unsolvable,
+ * and lead to an unstable layout. You can use the [property@Gtk.Constraint:strength]
+ * property of [class@Gtk.Constraint] to "nudge" the layout towards a solution.
+ *
+ * ### GtkConstraintLayout as GtkBuildable
+ *
+ * `GtkConstraintLayout` implements the [iface@Gtk.Buildable] interface and
+ * has a custom "constraints" element which allows describing constraints in
+ * a [class@Gtk.Builder] UI file.
+ *
+ * An example of a UI definition fragment specifying a constraint:
+ *
+ * ```xml
+ * <object class="GtkConstraintLayout">
+ * <constraints>
+ * <constraint target="button" target-attribute="start"
+ * relation="eq"
+ * source="super" source-attribute="start"
+ * constant="12"
+ * strength="required" />
+ * <constraint target="button" target-attribute="width"
+ * relation="ge"
+ * constant="250"
+ * strength="strong" />
+ * </constraints>
+ * </object>
+ * ```
+ *
+ * The definition above will add two constraints to the GtkConstraintLayout:
+ *
+ * - a required constraint between the leading edge of "button" and
+ * the leading edge of the widget using the constraint layout, plus
+ * 12 pixels
+ * - a strong, constant constraint making the width of "button" greater
+ * than, or equal to 250 pixels
+ *
+ * The "target" and "target-attribute" attributes are required.
+ *
+ * The "source" and "source-attribute" attributes of the "constraint"
+ * element are optional; if they are not specified, the constraint is
+ * assumed to be a constant.
+ *
+ * The "relation" attribute is optional; if not specified, the constraint
+ * is assumed to be an equality.
+ *
+ * The "strength" attribute is optional; if not specified, the constraint
+ * is assumed to be required.
+ *
+ * The "source" and "target" attributes can be set to "super" to indicate
+ * that the constraint target is the widget using the GtkConstraintLayout.
+ *
+ * There can be "constant" and "multiplier" attributes.
+ *
+ * Additionally, the "constraints" element can also contain a description
+ * of the `GtkConstraintGuides` used by the layout:
+ *
+ * ```xml
+ * <constraints>
+ * <guide min-width="100" max-width="500" name="hspace"/>
+ * <guide min-height="64" nat-height="128" name="vspace" strength="strong"/>
+ * </constraints>
+ * ```
+ *
+ * The "guide" element has the following optional attributes:
+ *
+ * - "min-width", "nat-width", and "max-width", describe the minimum,
+ * natural, and maximum width of the guide, respectively
+ * - "min-height", "nat-height", and "max-height", describe the minimum,
+ * natural, and maximum height of the guide, respectively
+ * - "strength" describes the strength of the constraint on the natural
+ * size of the guide; if not specified, the constraint is assumed to
+ * have a medium strength
+ * - "name" describes a name for the guide, useful when debugging
+ *
+ * ### Using the Visual Format Language
+ *
+ * Complex constraints can be described using a compact syntax called VFL,
+ * or *Visual Format Language*.
+ *
+ * The Visual Format Language describes all the constraints on a row or
+ * column, typically starting from the leading edge towards the trailing
+ * one. Each element of the layout is composed by "views", which identify
+ * a [iface@Gtk.ConstraintTarget].
+ *
+ * For instance:
+ *
+ * ```
+ * [button]-[textField]
+ * ```
+ *
+ * Describes a constraint that binds the trailing edge of "button" to the
+ * leading edge of "textField", leaving a default space between the two.
+ *
+ * Using VFL is also possible to specify predicates that describe constraints
+ * on attributes like width and height:
+ *
+ * ```
+ * // Width must be greater than, or equal to 50
+ * [button(>=50)]
+ *
+ * // Width of button1 must be equal to width of button2
+ * [button1(==button2)]
+ * ```
+ *
+ * The default orientation for a VFL description is horizontal, unless
+ * otherwise specified:
+ *
+ * ```
+ * // horizontal orientation, default attribute: width
+ * H:[button(>=150)]
+ *
+ * // vertical orientation, default attribute: height
+ * V:[button1(==button2)]
+ * ```
+ *
+ * It's also possible to specify multiple predicates, as well as their
+ * strength:
+ *
+ * ```
+ * // minimum width of button must be 150
+ * // natural width of button can be 250
+ * [button(>=150@required, ==250@medium)]
+ * ```
+ *
+ * Finally, it's also possible to use simple arithmetic operators:
+ *
+ * ```
+ * // width of button1 must be equal to width of button2
+ * // divided by 2 plus 12
+ * [button1(button2 / 2 + 12)]
+ * ```
+ */
 export class ConstraintLayout extends LayoutManager {
+    /**
+     * Creates a new `GtkConstraintLayout` layout manager.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -13,6 +181,22 @@ export class ConstraintLayout extends LayoutManager {
             borrowed: false,
         });
     }
+    /**
+     * Adds a constraint to the layout manager.
+     *
+     * The [property@Gtk.Constraint:source] and [property@Gtk.Constraint:target]
+     * properties of `constraint` can be:
+     *
+     * - set to `NULL` to indicate that the constraint refers to the
+     * widget using `layout`
+     * - set to the [class@Gtk.Widget] using `layout`
+     * - set to a child of the [class@Gtk.Widget] using `layout`
+     * - set to a [class@Gtk.ConstraintGuide] that is part of `layout`
+     *
+     * The `layout` acquires the ownership of `constraint` after calling
+     * this function.
+     * @param constraint - a [class@Gtk.Constraint]
+     */
     addConstraint(constraint) {
         call("libgtk-4.so.1", "gtk_constraint_layout_add_constraint", [
             {
@@ -25,6 +209,90 @@ export class ConstraintLayout extends LayoutManager {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a list of constraints from a VFL description.
+     *
+     * The Visual Format Language, VFL, is based on Apple's AutoLayout VFL.
+     *
+     * The `views` dictionary is used to match [iface@Gtk.ConstraintTarget]
+     * instances to the symbolic view name inside the VFL.
+     *
+     * The VFL grammar is:
+     *
+     * ```
+     * <visualFormatString> = (<orientation>)?
+     * (<superview><connection>)?
+     * <view>(<connection><view>)*
+     * (<connection><superview>)?
+     * <orientation> = 'H' | 'V'
+     * <superview> = '|'
+     * <connection> = '' | '-' <predicateList> '-' | '-'
+     * <predicateList> = <simplePredicate> | <predicateListWithParens>
+     * <simplePredicate> = <metricName> | <positiveNumber>
+     * <predicateListWithParens> = '(' <predicate> (',' <predicate>)* ')'
+     * <predicate> = (<relation>)? <objectOfPredicate> (<operatorList>)? ('@' <priority>)?
+     * <relation> = '==' | '<=' | '>='
+     * <objectOfPredicate> = <constant> | <viewName> | ('.' <attributeName>)?
+     * <priority> = <positiveNumber> | 'required' | 'strong' | 'medium' | 'weak'
+     * <constant> = <number>
+     * <operatorList> = (<multiplyOperator>)? (<addOperator>)?
+     * <multiplyOperator> = [ '*' | '/' ] <positiveNumber>
+     * <addOperator> = [ '+' | '-' ] <positiveNumber>
+     * <viewName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
+     * <metricName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
+     * <attributeName> = 'top' | 'bottom' | 'left' | 'right' | 'width' | 'height' |
+     * 'start' | 'end' | 'centerX' | 'centerY' | 'baseline'
+     * <positiveNumber> // A positive real number parseable by g_ascii_strtod()
+     * <number> // A real number parseable by g_ascii_strtod()
+     * ```
+     *
+     * **Note**: The VFL grammar used by GTK is slightly different than the one
+     * defined by Apple, as it can use symbolic values for the constraint's
+     * strength instead of numeric values; additionally, GTK allows adding
+     * simple arithmetic operations inside predicates.
+     *
+     * Examples of VFL descriptions are:
+     *
+     * ```
+     * // Default spacing
+     * [button]-[textField]
+     *
+     * // Width constraint
+     * [button(>=50)]
+     *
+     * // Connection to super view
+     * |-50-[purpleBox]-50-|
+     *
+     * // Vertical layout
+     * V:[topField]-10-[bottomField]
+     *
+     * // Flush views
+     * [maroonView][blueView]
+     *
+     * // Priority
+     * [button(100@strong)]
+     *
+     * // Equal widths
+     * [button1(==button2)]
+     *
+     * // Multiple predicates
+     * [flexibleButton(>=70,<=100)]
+     *
+     * // A complete line of layout
+     * |-[find]-[findNext]-[findField(>=20)]-|
+     *
+     * // Operators
+     * [button1(button2 / 3 + 50)]
+     *
+     * // Named attributes
+     * [button1(==button2.height)]
+     * ```
+     * @param lines - an array of Visual Format Language lines
+     * @param nLines - the number of lines
+     * @param hspacing - default horizontal spacing value, or -1 for the fallback value
+     * @param vspacing - default vertical spacing value, or -1 for the fallback value
+     * @param views - a dictionary of `[ name, target ]`
+     */
     addConstraintsFromDescriptionv(lines, nLines, hspacing, vspacing, views) {
         const error = { value: null };
         const ptrs = call("libgtk-4.so.1", "gtk_constraint_layout_add_constraints_from_descriptionv", [
@@ -79,6 +347,16 @@ export class ConstraintLayout extends LayoutManager {
         }
         return ptrs.map((ptr) => getObject(ptr, Constraint));
     }
+    /**
+     * Adds a guide to `layout`.
+     *
+     * A guide can be used as the source or target of constraints,
+     * like a widget, but it is not visible.
+     *
+     * The `layout` acquires the ownership of `guide` after calling
+     * this function.
+     * @param guide - a [class@Gtk.ConstraintGuide] object
+     */
     addGuide(guide) {
         call("libgtk-4.so.1", "gtk_constraint_layout_add_guide", [
             {
@@ -91,6 +369,17 @@ export class ConstraintLayout extends LayoutManager {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns a `GListModel` to track the constraints that are
+     * part of the layout.
+     *
+     * Calling this function will enable extra internal bookkeeping
+     * to track constraints and emit signals on the returned listmodel.
+     * It may slow down operations a lot.
+     *
+     * Applications should try hard to avoid calling this function
+     * because of the slowdowns.
+     */
     observeConstraints() {
         const ptr = call("libgtk-4.so.1", "gtk_constraint_layout_observe_constraints", [
             {
@@ -100,6 +389,17 @@ export class ConstraintLayout extends LayoutManager {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gio.ListModel);
     }
+    /**
+     * Returns a `GListModel` to track the guides that are
+     * part of the layout.
+     *
+     * Calling this function will enable extra internal bookkeeping
+     * to track guides and emit signals on the returned listmodel.
+     * It may slow down operations a lot.
+     *
+     * Applications should try hard to avoid calling this function
+     * because of the slowdowns.
+     */
     observeGuides() {
         const ptr = call("libgtk-4.so.1", "gtk_constraint_layout_observe_guides", [
             {
@@ -109,6 +409,9 @@ export class ConstraintLayout extends LayoutManager {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gio.ListModel);
     }
+    /**
+     * Removes all constraints from the layout manager.
+     */
     removeAllConstraints() {
         call("libgtk-4.so.1", "gtk_constraint_layout_remove_all_constraints", [
             {
@@ -117,6 +420,11 @@ export class ConstraintLayout extends LayoutManager {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes `constraint` from the layout manager,
+     * so that it no longer influences the layout.
+     * @param constraint - a [class@Gtk.Constraint]
+     */
     removeConstraint(constraint) {
         call("libgtk-4.so.1", "gtk_constraint_layout_remove_constraint", [
             {
@@ -129,6 +437,11 @@ export class ConstraintLayout extends LayoutManager {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes `guide` from the layout manager,
+     * so that it no longer influences the layout.
+     * @param guide - a [class@Gtk.ConstraintGuide] object
+     */
     removeGuide(guide) {
         call("libgtk-4.so.1", "gtk_constraint_layout_remove_guide", [
             {
@@ -141,6 +454,12 @@ export class ConstraintLayout extends LayoutManager {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the ID of the `buildable` object.
+     *
+     * `GtkBuilder` sets the name based on the ID attribute
+     * of the `<object>` tag used to construct the @buildable.
+     */
     getBuildableId() {
         return call("libgtk-4.so.1", "gtk_buildable_get_buildable_id", [
             {

package/dist/generated/gtk/constraint-target.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Makes it possible to use an object as source or target in a
+ * [class@Gtk.Constraint].
+ *
+ * Besides `GtkWidget`, it is also implemented by `GtkConstraintGuide`.
+ */
 export declare class ConstraintTarget {
     ptr: unknown;
     protected constructor(ptr: unknown);

package/dist/generated/gtk/constraint-target.js

@@ -1,3 +1,9 @@
+/**
+ * Makes it possible to use an object as source or target in a
+ * [class@Gtk.Constraint].
+ *
+ * Besides `GtkWidget`, it is also implemented by `GtkConstraintGuide`.
+ */
 export class ConstraintTarget {
     ptr;
     constructor(ptr) {

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

@@ -1,21 +1,104 @@
 import { ConstraintAttribute, ConstraintRelation } from "./enums.js";
 import { ConstraintTarget } from "./constraint-target.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Describes a constraint between attributes of two widgets,
+ * expressed as a linear equation.
+ *
+ * The typical equation for a constraint is:
+ *
+ * ```
+ * target.target_attr = source.source_attr × multiplier + constant
+ * ```
+ *
+ * Each `GtkConstraint` is part of a system that will be solved by a
+ * [class@Gtk.ConstraintLayout] in order to allocate and position each
+ * child widget or guide.
+ *
+ * The source and target, as well as their attributes, of a `GtkConstraint`
+ * instance are immutable after creation.
+ */
 export declare class Constraint extends GObject.GObject {
+    /**
+     * Creates a new constraint representing a relation between a layout
+     * attribute on a source and a layout attribute on a target.
+     * @param target - the target of the constraint
+     * @param targetAttribute - the attribute of `target` to be set
+     * @param relation - the relation equivalence between `target_attribute` and `source_attribute`
+     * @param source - the source of the constraint
+     * @param sourceAttribute - the attribute of `source` to be read
+     * @param multiplier - a multiplication factor to be applied to `source_attribute`
+     * @param constant - a constant factor to be added to `source_attribute`
+     * @param strength - the strength of the constraint
+     */
     constructor(targetAttribute: ConstraintAttribute, relation: ConstraintRelation, sourceAttribute: ConstraintAttribute, multiplier: number, constant: number, strength: number, target?: ConstraintTarget | null, source?: ConstraintTarget | null);
     constructor(...args: unknown[]);
+    /**
+     * Creates a new constraint representing a relation between a layout
+     * attribute on a target and a constant value.
+     * @param target - a the target of the constraint
+     * @param targetAttribute - the attribute of `target` to be set
+     * @param relation - the relation equivalence between `target_attribute` and `constant`
+     * @param constant - a constant factor to be set on `target_attribute`
+     * @param strength - the strength of the constraint
+     */
     static newConstant(targetAttribute: ConstraintAttribute, relation: ConstraintRelation, constant: number, strength: number, target?: ConstraintTarget | null): Constraint;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the constant factor added to the source attributes' value.
+     */
     getConstant(): number;
+    /**
+     * Retrieves the multiplication factor applied to the source
+     * attribute's value.
+     */
     getMultiplier(): number;
+    /**
+     * The order relation between the terms of the constraint.
+     */
     getRelation(): ConstraintRelation;
+    /**
+     * Retrieves the [iface@Gtk.ConstraintTarget] used as the source for the
+     * constraint.
+     *
+     * If the source is set to `NULL` at creation, the constraint will use
+     * the widget using the [class@Gtk.ConstraintLayout] as the source.
+     */
     getSource(): ConstraintTarget | null;
+    /**
+     * Retrieves the attribute of the source to be read by the constraint.
+     */
     getSourceAttribute(): ConstraintAttribute;
+    /**
+     * Retrieves the strength of the constraint.
+     */
     getStrength(): number;
+    /**
+     * Retrieves the [iface@Gtk.ConstraintTarget] used as the target for
+     * the constraint.
+     *
+     * If the targe is set to `NULL` at creation, the constraint will use
+     * the widget using the [class@Gtk.ConstraintLayout] as the target.
+     */
     getTarget(): ConstraintTarget | null;
+    /**
+     * Retrieves the attribute of the target to be set by the constraint.
+     */
     getTargetAttribute(): ConstraintAttribute;
+    /**
+     * Checks whether the constraint is attached to a [class@Gtk.ConstraintLayout],
+     * and it is contributing to the layout.
+     */
     isAttached(): boolean;
+    /**
+     * Checks whether the constraint describes a relation between an attribute
+     * on the [property@Gtk.Constraint:target] and a constant value.
+     */
     isConstant(): boolean;
+    /**
+     * Checks whether the constraint is a required relation for solving the
+     * constraint layout.
+     */
     isRequired(): boolean;
     connect(signal: "notify", handler: (self: Constraint, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/constraint.js

@@ -2,10 +2,36 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { ConstraintTarget } from "./constraint-target.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Describes a constraint between attributes of two widgets,
+ * expressed as a linear equation.
+ *
+ * The typical equation for a constraint is:
+ *
+ * ```
+ * target.target_attr = source.source_attr × multiplier + constant
+ * ```
+ *
+ * Each `GtkConstraint` is part of a system that will be solved by a
+ * [class@Gtk.ConstraintLayout] in order to allocate and position each
+ * child widget or guide.
+ *
+ * The source and target, as well as their attributes, of a `GtkConstraint`
+ * instance are immutable after creation.
+ */
 export class Constraint extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new constraint representing a relation between a layout
+     * attribute on a target and a constant value.
+     * @param target - a the target of the constraint
+     * @param targetAttribute - the attribute of `target` to be set
+     * @param relation - the relation equivalence between `target_attribute` and `constant`
+     * @param constant - a constant factor to be set on `target_attribute`
+     * @param strength - the strength of the constraint
+     */
     static newConstant(targetAttribute, relation, constant, strength, target) {
         const ptr = call("libgtk-4.so.1", "gtk_constraint_new_constant", [
             {
@@ -71,6 +97,9 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the constant factor added to the source attributes' value.
+     */
     getConstant() {
         return call("libgtk-4.so.1", "gtk_constraint_get_constant", [
             {
@@ -79,6 +108,10 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Retrieves the multiplication factor applied to the source
+     * attribute's value.
+     */
     getMultiplier() {
         return call("libgtk-4.so.1", "gtk_constraint_get_multiplier", [
             {
@@ -87,6 +120,9 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * The order relation between the terms of the constraint.
+     */
     getRelation() {
         return call("libgtk-4.so.1", "gtk_constraint_get_relation", [
             {
@@ -95,6 +131,13 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the [iface@Gtk.ConstraintTarget] used as the source for the
+     * constraint.
+     *
+     * If the source is set to `NULL` at creation, the constraint will use
+     * the widget using the [class@Gtk.ConstraintLayout] as the source.
+     */
     getSource() {
         const ptr = call("libgtk-4.so.1", "gtk_constraint_get_source", [
             {
@@ -106,6 +149,9 @@ export class Constraint extends GObject.GObject {
             return null;
         return getObject(ptr, ConstraintTarget);
     }
+    /**
+     * Retrieves the attribute of the source to be read by the constraint.
+     */
     getSourceAttribute() {
         return call("libgtk-4.so.1", "gtk_constraint_get_source_attribute", [
             {
@@ -114,6 +160,9 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the strength of the constraint.
+     */
     getStrength() {
         return call("libgtk-4.so.1", "gtk_constraint_get_strength", [
             {
@@ -122,6 +171,13 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the [iface@Gtk.ConstraintTarget] used as the target for
+     * the constraint.
+     *
+     * If the targe is set to `NULL` at creation, the constraint will use
+     * the widget using the [class@Gtk.ConstraintLayout] as the target.
+     */
     getTarget() {
         const ptr = call("libgtk-4.so.1", "gtk_constraint_get_target", [
             {
@@ -133,6 +189,9 @@ export class Constraint extends GObject.GObject {
             return null;
         return getObject(ptr, ConstraintTarget);
     }
+    /**
+     * Retrieves the attribute of the target to be set by the constraint.
+     */
     getTargetAttribute() {
         return call("libgtk-4.so.1", "gtk_constraint_get_target_attribute", [
             {
@@ -141,6 +200,10 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Checks whether the constraint is attached to a [class@Gtk.ConstraintLayout],
+     * and it is contributing to the layout.
+     */
     isAttached() {
         return call("libgtk-4.so.1", "gtk_constraint_is_attached", [
             {
@@ -149,6 +212,10 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the constraint describes a relation between an attribute
+     * on the [property@Gtk.Constraint:target] and a constant value.
+     */
     isConstant() {
         return call("libgtk-4.so.1", "gtk_constraint_is_constant", [
             {
@@ -157,6 +224,10 @@ export class Constraint extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the constraint is a required relation for solving the
+     * constraint layout.
+     */
     isRequired() {
         return call("libgtk-4.so.1", "gtk_constraint_is_required", [
             {