@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/scale-button.d.ts

@@ -4,21 +4,89 @@ import { Button } from "./button.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class ScaleButton extends Widget {
+    /**
+     * Creates a `GtkScaleButton`.
+     *
+     * The new scale button has a range between `min` and @max,
+     * with a stepping of @step.
+     * @param min - the minimum value of the scale (usually 0)
+     * @param max - the maximum value of the scale (usually 100)
+     * @param step - the stepping of value when a scroll-wheel event,
+     * @param icons - a %NULL-terminated
+     */
     constructor(min: number, max: number, step: number, icons?: string[] | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Queries a `GtkScaleButton` and returns its current state.
+     *
+     * Returns %TRUE if the scale button is pressed in and %FALSE
+     * if it is raised.
+     */
     getActive(): boolean;
+    /**
+     * Gets the `GtkAdjustment` associated with the `GtkScaleButton`’s scale.
+     *
+     * See [method@Gtk.Range.get_adjustment] for details.
+     */
     getAdjustment(): Adjustment;
+    /**
+     * Returns whether the button has a frame.
+     */
     getHasFrame(): boolean;
+    /**
+     * Retrieves the minus button of the `GtkScaleButton`.
+     */
     getMinusButton(): Button;
+    /**
+     * Retrieves the plus button of the `GtkScaleButton.`
+     */
     getPlusButton(): Button;
+    /**
+     * Retrieves the popup of the `GtkScaleButton`.
+     */
     getPopup(): Widget;
+    /**
+     * Gets the current value of the scale button.
+     */
     getValue(): number;
+    /**
+     * Sets the `GtkAdjustment` to be used as a model
+     * for the `GtkScaleButton`’s scale.
+     *
+     * See [method@Gtk.Range.set_adjustment] for details.
+     * @param adjustment - a `GtkAdjustment`
+     */
     setAdjustment(adjustment: Adjustment): void;
+    /**
+     * Sets the style of the button.
+     * @param hasFrame - whether the button should have a visible frame
+     */
     setHasFrame(hasFrame: boolean): void;
+    /**
+     * Sets the icons to be used by the scale button.
+     * @param icons - a %NULL-terminated array of icon names
+     */
     setIcons(icons: string[]): void;
+    /**
+     * Sets the current value of the scale.
+     *
+     * If the value is outside the minimum or maximum range values,
+     * it will be clamped to fit inside them.
+     *
+     * The scale button emits the [signal@Gtk.ScaleButton::value-changed]
+     * signal if the value changes.
+     * @param value - new value of the scale button
+     */
     setValue(value: number): void;
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation(): Orientation;
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation: Orientation): void;
     connect(signal: "popdown", handler: (self: ScaleButton) => void, after?: boolean): number;
     connect(signal: "popup", handler: (self: ScaleButton) => void, after?: boolean): number;

package/dist/generated/gtk/scale-button.js

@@ -3,6 +3,30 @@ import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { Button } from "./button.js";
 import { Widget } from "./widget.js";
+/**
+ * Provides a button which pops up a scale widget.
+ *
+ * This kind of widget is commonly used for volume controls in multimedia
+ * applications, and GTK provides a [class@Gtk.VolumeButton] subclass that
+ * is tailored for this use case.
+ *
+ * # Shortcuts and Gestures
+ *
+ * The following signals have default keybindings:
+ *
+ * - [signal@Gtk.ScaleButton::popup]
+ *
+ * # CSS nodes
+ *
+ * ```
+ * scalebutton.scale
+ * ╰── button.toggle
+ * ╰── <icon>
+ * ```
+ *
+ * `GtkScaleButton` has a single CSS node with name scalebutton and `.scale`
+ * style class, and contains a `button` node with a `.toggle` style class.
+ */
 const SIGNAL_META = {
     popdown: { params: [], returnType: { type: "undefined" } },
     popup: { params: [], returnType: { type: "undefined" } },
@@ -37,6 +61,12 @@ export class ScaleButton extends Widget {
             },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Queries a `GtkScaleButton` and returns its current state.
+     *
+     * Returns %TRUE if the scale button is pressed in and %FALSE
+     * if it is raised.
+     */
     getActive() {
         return call("libgtk-4.so.1", "gtk_scale_button_get_active", [
             {
@@ -45,6 +75,11 @@ export class ScaleButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the `GtkAdjustment` associated with the `GtkScaleButton`’s scale.
+     *
+     * See [method@Gtk.Range.get_adjustment] for details.
+     */
     getAdjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scale_button_get_adjustment", [
             {
@@ -54,6 +89,9 @@ export class ScaleButton extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Returns whether the button has a frame.
+     */
     getHasFrame() {
         return call("libgtk-4.so.1", "gtk_scale_button_get_has_frame", [
             {
@@ -62,6 +100,9 @@ export class ScaleButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the minus button of the `GtkScaleButton`.
+     */
     getMinusButton() {
         const ptr = call("libgtk-4.so.1", "gtk_scale_button_get_minus_button", [
             {
@@ -71,6 +112,9 @@ export class ScaleButton extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Button);
     }
+    /**
+     * Retrieves the plus button of the `GtkScaleButton.`
+     */
     getPlusButton() {
         const ptr = call("libgtk-4.so.1", "gtk_scale_button_get_plus_button", [
             {
@@ -80,6 +124,9 @@ export class ScaleButton extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Button);
     }
+    /**
+     * Retrieves the popup of the `GtkScaleButton`.
+     */
     getPopup() {
         const ptr = call("libgtk-4.so.1", "gtk_scale_button_get_popup", [
             {
@@ -89,6 +136,9 @@ export class ScaleButton extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets the current value of the scale button.
+     */
     getValue() {
         return call("libgtk-4.so.1", "gtk_scale_button_get_value", [
             {
@@ -97,6 +147,13 @@ export class ScaleButton extends Widget {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Sets the `GtkAdjustment` to be used as a model
+     * for the `GtkScaleButton`’s scale.
+     *
+     * See [method@Gtk.Range.set_adjustment] for details.
+     * @param adjustment - a `GtkAdjustment`
+     */
     setAdjustment(adjustment) {
         call("libgtk-4.so.1", "gtk_scale_button_set_adjustment", [
             {
@@ -109,6 +166,10 @@ export class ScaleButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the style of the button.
+     * @param hasFrame - whether the button should have a visible frame
+     */
     setHasFrame(hasFrame) {
         call("libgtk-4.so.1", "gtk_scale_button_set_has_frame", [
             {
@@ -121,6 +182,10 @@ export class ScaleButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the icons to be used by the scale button.
+     * @param icons - a %NULL-terminated array of icon names
+     */
     setIcons(icons) {
         call("libgtk-4.so.1", "gtk_scale_button_set_icons", [
             {
@@ -133,6 +198,16 @@ export class ScaleButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the current value of the scale.
+     *
+     * If the value is outside the minimum or maximum range values,
+     * it will be clamped to fit inside them.
+     *
+     * The scale button emits the [signal@Gtk.ScaleButton::value-changed]
+     * signal if the value changes.
+     * @param value - new value of the scale button
+     */
     setValue(value) {
         call("libgtk-4.so.1", "gtk_scale_button_set_value", [
             {
@@ -145,6 +220,9 @@ export class ScaleButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_orientable_get_orientation", [
             {
@@ -153,6 +231,10 @@ export class ScaleButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation) {
         call("libgtk-4.so.1", "gtk_orientable_set_orientation", [
             {

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

@@ -5,22 +5,137 @@ import * as GObject from "../gobject/index.js";
 import * as Pango from "../pango/index.js";
 import { Range } from "./range.js";
 export declare class Scale extends Range {
+    /**
+     * Creates a new `GtkScale`.
+     * @param orientation - the scale’s orientation.
+     * @param adjustment - the [class@Gtk.Adjustment] which sets
+     */
     constructor(orientation: Orientation, adjustment?: Adjustment | null);
     constructor(...args: unknown[]);
+    /**
+     * Creates a new scale widget with a range from `min` to @max.
+     *
+     * The returns scale will have the given orientation and will let the
+     * user input a number between `min` and `max` (including `min` and @max)
+     * with the increment @step. `step` must be nonzero; it’s the distance
+     * the slider moves when using the arrow keys to adjust the scale
+     * value.
+     *
+     * Note that the way in which the precision is derived works best if
+     * `step` is a power of ten. If the resulting precision is not suitable
+     * for your needs, use [method@Gtk.Scale.set_digits] to correct it.
+     * @param orientation - the scale’s orientation.
+     * @param min - minimum value
+     * @param max - maximum value
+     * @param step - step increment (tick size) used with keyboard shortcuts
+     */
     static newWithRange(orientation: Orientation, min: number, max: number, step: number): Scale;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Adds a mark at @value.
+     *
+     * A mark is indicated visually by drawing a tick mark next to the scale,
+     * and GTK makes it easy for the user to position the scale exactly at the
+     * marks value.
+     *
+     * If `markup` is not %NULL, text is shown next to the tick mark.
+     *
+     * To remove marks from a scale, use [method@Gtk.Scale.clear_marks].
+     * @param value - the value at which the mark is placed, must be between
+     * @param position - where to draw the mark. For a horizontal scale, %GTK_POS_TOP
+     * @param markup - Text to be shown at the mark, using Pango markup
+     */
     addMark(value: number, position: PositionType, markup?: string | null): void;
+    /**
+     * Removes any marks that have been added.
+     */
     clearMarks(): void;
+    /**
+     * Gets the number of decimal places that are displayed in the value.
+     */
     getDigits(): number;
+    /**
+     * Returns whether the current value is displayed as a string
+     * next to the slider.
+     */
     getDrawValue(): boolean;
+    /**
+     * Returns whether the scale has an origin.
+     */
     getHasOrigin(): boolean;
+    /**
+     * Gets the `PangoLayout` used to display the scale.
+     *
+     * The returned object is owned by the scale so does not need
+     * to be freed by the caller.
+     */
     getLayout(): Pango.Layout | null;
+    /**
+     * Obtains the coordinates where the scale will draw the
+     * `PangoLayout` representing the text in the scale.
+     *
+     * Remember when using the `PangoLayout` function you need to
+     * convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
+     *
+     * If the [property@Gtk.Scale:draw-value] property is %FALSE, the return
+     * values are undefined.
+     * @param x - location to store X offset of layout
+     * @param y - location to store Y offset of layout
+     */
     getLayoutOffsets(x?: Ref<number> | null, y?: Ref<number> | null): void;
+    /**
+     * Gets the position in which the current value is displayed.
+     */
     getValuePos(): PositionType;
+    /**
+     * Sets the number of decimal places that are displayed in the value.
+     *
+     * Also causes the value of the adjustment to be rounded to this number
+     * of digits, so the retrieved value matches the displayed one, if
+     * [property@Gtk.Scale:draw-value] is %TRUE when the value changes. If
+     * you want to enforce rounding the value when [property@Gtk.Scale:draw-value]
+     * is %FALSE, you can set [property@Gtk.Range:round-digits] instead.
+     *
+     * Note that rounding to a small number of digits can interfere with
+     * the smooth autoscrolling that is built into `GtkScale`. As an alternative,
+     * you can use [method@Gtk.Scale.set_format_value_func] to format the displayed
+     * value yourself.
+     * @param digits - the number of decimal places to display,
+     */
     setDigits(digits: number): void;
+    /**
+     * Specifies whether the current value is displayed as a string next
+     * to the slider.
+     * @param drawValue - %TRUE to draw the value
+     */
     setDrawValue(drawValue: boolean): void;
+    /**
+     * `func` allows you to change how the scale value is displayed.
+     *
+     * The given function will return an allocated string representing
+     * @value. That string will then be used to display the scale's value.
+     *
+     * If #NULL is passed as @func, the value will be displayed on
+     * its own, rounded according to the value of the
+     * [property@Gtk.Scale:digits] property.
+     * @param func - function
+     * @param userData - user data to pass to @func
+     * @param destroyNotify - destroy function for @user_data
+     */
     setFormatValueFunc(func?: (...args: unknown[]) => unknown | null, userData?: number | null, destroyNotify?: () => void | null): void;
+    /**
+     * Sets whether the scale has an origin.
+     *
+     * If [property@Gtk.Scale:has-origin] is set to %TRUE (the default),
+     * the scale will highlight the part of the trough between the origin
+     * (bottom or left side) and the current value.
+     * @param hasOrigin - %TRUE if the scale has an origin
+     */
     setHasOrigin(hasOrigin: boolean): void;
+    /**
+     * Sets the position in which the current value is displayed.
+     * @param pos - the position in which the current value is displayed
+     */
     setValuePos(pos: PositionType): void;
     connect(signal: "adjust-bounds", handler: (self: Scale, value: number) => void, after?: boolean): number;
     connect(signal: "change-value", handler: (self: Scale, scroll: ScrollType, value: number) => boolean, after?: boolean): number;

package/dist/generated/gtk/scale.js

@@ -2,6 +2,97 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Pango from "../pango/index.js";
 import { Range } from "./range.js";
+/**
+ * Allows to select a numeric value with a slider control.
+ *
+ *
+ *
+ * To use it, you’ll probably want to investigate the methods on its base
+ * class, [class@Gtk.Range], in addition to the methods for `GtkScale` itself.
+ * To set the value of a scale, you would normally use [method@Gtk.Range.set_value].
+ * To detect changes to the value, you would normally use the
+ * [signal@Gtk.Range::value-changed] signal.
+ *
+ * Note that using the same upper and lower bounds for the `GtkScale` (through
+ * the `GtkRange` methods) will hide the slider itself. This is useful for
+ * applications that want to show an undeterminate value on the scale, without
+ * changing the layout of the application (such as movie or music players).
+ *
+ * # GtkScale as GtkBuildable
+ *
+ * `GtkScale` supports a custom `<marks>` element, which can contain multiple
+ * `<mark\>` elements. The “value” and “position” attributes have the same
+ * meaning as [method@Gtk.Scale.add_mark] parameters of the same name. If
+ * the element is not empty, its content is taken as the markup to show at
+ * the mark. It can be translated with the usual ”translatable” and
+ * “context” attributes.
+ *
+ * # Shortcuts and Gestures
+ *
+ * `GtkPopoverMenu` supports the following keyboard shortcuts:
+ *
+ * - Arrow keys, `+` and `-` will increment or decrement
+ * by step, or by page when combined with `Ctrl`.
+ * - `PgUp` and `PgDn` will increment or decrement by page.
+ * - `Home` and `End` will set the minimum or maximum value.
+ *
+ * # CSS nodes
+ *
+ * ```
+ * scale[.fine-tune][.marks-before][.marks-after]
+ * ├── [value][.top][.right][.bottom][.left]
+ * ├── marks.top
+ * │   ├── mark
+ * │   ┊    ├── [label]
+ * │   ┊    ╰── indicator
+ * ┊   ┊
+ * │   ╰── mark
+ * ├── marks.bottom
+ * │   ├── mark
+ * │   ┊    ├── indicator
+ * │   ┊    ╰── [label]
+ * ┊   ┊
+ * │   ╰── mark
+ * ╰── trough
+ * ├── [fill]
+ * ├── [highlight]
+ * ╰── slider
+ * ```
+ *
+ * `GtkScale` has a main CSS node with name scale and a subnode for its contents,
+ * with subnodes named trough and slider.
+ *
+ * The main node gets the style class .fine-tune added when the scale is in
+ * 'fine-tuning' mode.
+ *
+ * If the scale has an origin (see [method@Gtk.Scale.set_has_origin]), there is
+ * a subnode with name highlight below the trough node that is used for rendering
+ * the highlighted part of the trough.
+ *
+ * If the scale is showing a fill level (see [method@Gtk.Range.set_show_fill_level]),
+ * there is a subnode with name fill below the trough node that is used for
+ * rendering the filled in part of the trough.
+ *
+ * If marks are present, there is a marks subnode before or after the trough
+ * node, below which each mark gets a node with name mark. The marks nodes get
+ * either the .top or .bottom style class.
+ *
+ * The mark node has a subnode named indicator. If the mark has text, it also
+ * has a subnode named label. When the mark is either above or left of the
+ * scale, the label subnode is the first when present. Otherwise, the indicator
+ * subnode is the first.
+ *
+ * The main CSS node gets the 'marks-before' and/or 'marks-after' style classes
+ * added depending on what marks are present.
+ *
+ * If the scale is displaying the value (see [property@Gtk.Scale:draw-value]),
+ * there is subnode with name value. This node will get the .top or .bottom style
+ * classes similar to the marks node.
+ *
+ * # Accessibility
+ *
+ * `GtkScale` uses the [enum@Gtk.AccessibleRole.slider] role.
+ */
 const SIGNAL_META = {
     "adjust-bounds": {
         params: [{ type: { type: "float", size: 64 } }],
@@ -24,6 +115,23 @@ export class Scale extends Range {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new scale widget with a range from `min` to @max.
+     *
+     * The returns scale will have the given orientation and will let the
+     * user input a number between `min` and `max` (including `min` and @max)
+     * with the increment @step. `step` must be nonzero; it’s the distance
+     * the slider moves when using the arrow keys to adjust the scale
+     * value.
+     *
+     * Note that the way in which the precision is derived works best if
+     * `step` is a power of ten. If the resulting precision is not suitable
+     * for your needs, use [method@Gtk.Scale.set_digits] to correct it.
+     * @param orientation - the scale’s orientation.
+     * @param min - minimum value
+     * @param max - maximum value
+     * @param step - step increment (tick size) used with keyboard shortcuts
+     */
     static newWithRange(orientation, min, max, step) {
         const ptr = call("libgtk-4.so.1", "gtk_scale_new_with_range", [
             {
@@ -59,6 +167,20 @@ export class Scale extends Range {
             },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Adds a mark at @value.
+     *
+     * A mark is indicated visually by drawing a tick mark next to the scale,
+     * and GTK makes it easy for the user to position the scale exactly at the
+     * marks value.
+     *
+     * If `markup` is not %NULL, text is shown next to the tick mark.
+     *
+     * To remove marks from a scale, use [method@Gtk.Scale.clear_marks].
+     * @param value - the value at which the mark is placed, must be between
+     * @param position - where to draw the mark. For a horizontal scale, %GTK_POS_TOP
+     * @param markup - Text to be shown at the mark, using Pango markup
+     */
     addMark(value, position, markup) {
         call("libgtk-4.so.1", "gtk_scale_add_mark", [
             {
@@ -80,6 +202,9 @@ export class Scale extends Range {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes any marks that have been added.
+     */
     clearMarks() {
         call("libgtk-4.so.1", "gtk_scale_clear_marks", [
             {
@@ -88,6 +213,9 @@ export class Scale extends Range {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the number of decimal places that are displayed in the value.
+     */
     getDigits() {
         return call("libgtk-4.so.1", "gtk_scale_get_digits", [
             {
@@ -96,6 +224,10 @@ export class Scale extends Range {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns whether the current value is displayed as a string
+     * next to the slider.
+     */
     getDrawValue() {
         return call("libgtk-4.so.1", "gtk_scale_get_draw_value", [
             {
@@ -104,6 +236,9 @@ export class Scale extends Range {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the scale has an origin.
+     */
     getHasOrigin() {
         return call("libgtk-4.so.1", "gtk_scale_get_has_origin", [
             {
@@ -112,6 +247,12 @@ export class Scale extends Range {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the `PangoLayout` used to display the scale.
+     *
+     * The returned object is owned by the scale so does not need
+     * to be freed by the caller.
+     */
     getLayout() {
         const ptr = call("libgtk-4.so.1", "gtk_scale_get_layout", [
             {
@@ -123,6 +264,18 @@ export class Scale extends Range {
             return null;
         return getObject(ptr, Pango.Layout);
     }
+    /**
+     * Obtains the coordinates where the scale will draw the
+     * `PangoLayout` representing the text in the scale.
+     *
+     * Remember when using the `PangoLayout` function you need to
+     * convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
+     *
+     * If the [property@Gtk.Scale:draw-value] property is %FALSE, the return
+     * values are undefined.
+     * @param x - location to store X offset of layout
+     * @param y - location to store Y offset of layout
+     */
     getLayoutOffsets(x, y) {
         call("libgtk-4.so.1", "gtk_scale_get_layout_offsets", [
             {
@@ -147,6 +300,9 @@ export class Scale extends Range {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the position in which the current value is displayed.
+     */
     getValuePos() {
         return call("libgtk-4.so.1", "gtk_scale_get_value_pos", [
             {
@@ -155,6 +311,21 @@ export class Scale extends Range {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the number of decimal places that are displayed in the value.
+     *
+     * Also causes the value of the adjustment to be rounded to this number
+     * of digits, so the retrieved value matches the displayed one, if
+     * [property@Gtk.Scale:draw-value] is %TRUE when the value changes. If
+     * you want to enforce rounding the value when [property@Gtk.Scale:draw-value]
+     * is %FALSE, you can set [property@Gtk.Range:round-digits] instead.
+     *
+     * Note that rounding to a small number of digits can interfere with
+     * the smooth autoscrolling that is built into `GtkScale`. As an alternative,
+     * you can use [method@Gtk.Scale.set_format_value_func] to format the displayed
+     * value yourself.
+     * @param digits - the number of decimal places to display,
+     */
     setDigits(digits) {
         call("libgtk-4.so.1", "gtk_scale_set_digits", [
             {
@@ -167,6 +338,11 @@ export class Scale extends Range {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Specifies whether the current value is displayed as a string next
+     * to the slider.
+     * @param drawValue - %TRUE to draw the value
+     */
     setDrawValue(drawValue) {
         call("libgtk-4.so.1", "gtk_scale_set_draw_value", [
             {
@@ -179,6 +355,19 @@ export class Scale extends Range {
             },
         ], { type: "undefined" });
     }
+    /**
+     * `func` allows you to change how the scale value is displayed.
+     *
+     * The given function will return an allocated string representing
+     * @value. That string will then be used to display the scale's value.
+     *
+     * If #NULL is passed as @func, the value will be displayed on
+     * its own, rounded according to the value of the
+     * [property@Gtk.Scale:digits] property.
+     * @param func - function
+     * @param userData - user data to pass to @func
+     * @param destroyNotify - destroy function for @user_data
+     */
     setFormatValueFunc(func, userData, destroyNotify) {
         call("libgtk-4.so.1", "gtk_scale_set_format_value_func", [
             {
@@ -202,6 +391,14 @@ export class Scale extends Range {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the scale has an origin.
+     *
+     * If [property@Gtk.Scale:has-origin] is set to %TRUE (the default),
+     * the scale will highlight the part of the trough between the origin
+     * (bottom or left side) and the current value.
+     * @param hasOrigin - %TRUE if the scale has an origin
+     */
     setHasOrigin(hasOrigin) {
         call("libgtk-4.so.1", "gtk_scale_set_has_origin", [
             {
@@ -214,6 +411,10 @@ export class Scale extends Range {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the position in which the current value is displayed.
+     * @param pos - the position in which the current value is displayed
+     */
     setValuePos(pos) {
         call("libgtk-4.so.1", "gtk_scale_set_value_pos", [
             {