@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/scrolled-window.d.ts

@@ -4,38 +4,218 @@ import { Adjustment } from "./adjustment.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class ScrolledWindow extends Widget {
+    /**
+     * Creates a new scrolled window.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the child widget of @scrolled_window.
+     *
+     * If the scrolled window automatically added a [class@Gtk.Viewport], this
+     * function will return the viewport widget, and you can retrieve its child
+     * using [method@Gtk.Viewport.get_child].
+     */
     getChild(): Widget | null;
+    /**
+     * Returns the horizontal scrollbar’s adjustment.
+     *
+     * This is the adjustment used to connect the horizontal scrollbar
+     * to the child widget’s horizontal scroll functionality.
+     */
     getHadjustment(): Adjustment;
+    /**
+     * Gets whether the scrolled window draws a frame.
+     */
     getHasFrame(): boolean;
+    /**
+     * Returns the horizontal scrollbar of @scrolled_window.
+     */
     getHscrollbar(): Widget;
+    /**
+     * Returns the specified kinetic scrolling behavior.
+     */
     getKineticScrolling(): boolean;
+    /**
+     * Returns the maximum content height set.
+     */
     getMaxContentHeight(): number;
+    /**
+     * Returns the maximum content width set.
+     */
     getMaxContentWidth(): number;
+    /**
+     * Gets the minimal content height of @scrolled_window.
+     */
     getMinContentHeight(): number;
+    /**
+     * Gets the minimum content width of @scrolled_window.
+     */
     getMinContentWidth(): number;
+    /**
+     * Returns whether overlay scrolling is enabled for this scrolled window.
+     */
     getOverlayScrolling(): boolean;
+    /**
+     * Gets the placement of the contents with respect to the scrollbars.
+     */
     getPlacement(): CornerType;
+    /**
+     * Retrieves the current policy values for the horizontal and vertical
+     * scrollbars.
+     *
+     * See [method@Gtk.ScrolledWindow.set_policy].
+     * @param hscrollbarPolicy - location to store the policy
+     * @param vscrollbarPolicy - location to store the policy
+     */
     getPolicy(hscrollbarPolicy?: Ref<PolicyType> | null, vscrollbarPolicy?: Ref<PolicyType> | null): void;
+    /**
+     * Reports whether the natural height of the child will be calculated
+     * and propagated through the scrolled window’s requested natural height.
+     */
     getPropagateNaturalHeight(): boolean;
+    /**
+     * Reports whether the natural width of the child will be calculated
+     * and propagated through the scrolled window’s requested natural width.
+     */
     getPropagateNaturalWidth(): boolean;
+    /**
+     * Returns the vertical scrollbar’s adjustment.
+     *
+     * This is the adjustment used to connect the vertical
+     * scrollbar to the child widget’s vertical scroll functionality.
+     */
     getVadjustment(): Adjustment;
+    /**
+     * Returns the vertical scrollbar of @scrolled_window.
+     */
     getVscrollbar(): Widget;
+    /**
+     * Sets the child widget of @scrolled_window.
+     *
+     * If `child` does not implement the [iface@Gtk.Scrollable] interface,
+     * the scrolled window will add `child` to a [class@Gtk.Viewport] instance
+     * and then add the viewport as its child widget.
+     * @param child - the child widget
+     */
     setChild(child?: Widget | null): void;
+    /**
+     * Sets the `GtkAdjustment` for the horizontal scrollbar.
+     * @param hadjustment - the `GtkAdjustment` to use, or %NULL to create a new one
+     */
     setHadjustment(hadjustment?: Adjustment | null): void;
+    /**
+     * Changes the frame drawn around the contents of @scrolled_window.
+     * @param hasFrame - whether to draw a frame around scrolled window contents
+     */
     setHasFrame(hasFrame: boolean): void;
+    /**
+     * Turns kinetic scrolling on or off.
+     *
+     * Kinetic scrolling only applies to devices with source
+     * %GDK_SOURCE_TOUCHSCREEN.
+     * @param kineticScrolling - %TRUE to enable kinetic scrolling
+     */
     setKineticScrolling(kineticScrolling: boolean): void;
+    /**
+     * Sets the maximum height that `scrolled_window` should keep visible.
+     *
+     * The `scrolled_window` will grow up to this height before it starts
+     * scrolling the content.
+     *
+     * It is a programming error to set the maximum content height to a value
+     * smaller than [property@Gtk.ScrolledWindow:min-content-height].
+     * @param height - the maximum content height
+     */
     setMaxContentHeight(height: number): void;
+    /**
+     * Sets the maximum width that `scrolled_window` should keep visible.
+     *
+     * The `scrolled_window` will grow up to this width before it starts
+     * scrolling the content.
+     *
+     * It is a programming error to set the maximum content width to a
+     * value smaller than [property@Gtk.ScrolledWindow:min-content-width].
+     * @param width - the maximum content width
+     */
     setMaxContentWidth(width: number): void;
+    /**
+     * Sets the minimum height that `scrolled_window` should keep visible.
+     *
+     * Note that this can and (usually will) be smaller than the minimum
+     * size of the content.
+     *
+     * It is a programming error to set the minimum content height to a
+     * value greater than [property@Gtk.ScrolledWindow:max-content-height].
+     * @param height - the minimal content height
+     */
     setMinContentHeight(height: number): void;
+    /**
+     * Sets the minimum width that `scrolled_window` should keep visible.
+     *
+     * Note that this can and (usually will) be smaller than the minimum
+     * size of the content.
+     *
+     * It is a programming error to set the minimum content width to a
+     * value greater than [property@Gtk.ScrolledWindow:max-content-width].
+     * @param width - the minimal content width
+     */
     setMinContentWidth(width: number): void;
+    /**
+     * Enables or disables overlay scrolling for this scrolled window.
+     * @param overlayScrolling - whether to enable overlay scrolling
+     */
     setOverlayScrolling(overlayScrolling: boolean): void;
+    /**
+     * Sets the placement of the contents with respect to the scrollbars
+     * for the scrolled window.
+     *
+     * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
+     * in the top left, with the scrollbars underneath and to the right.
+     * Other values in [enum@Gtk.CornerType] are %GTK_CORNER_TOP_RIGHT,
+     * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
+     *
+     * See also [method@Gtk.ScrolledWindow.get_placement] and
+     * [method@Gtk.ScrolledWindow.unset_placement].
+     * @param windowPlacement - position of the child window
+     */
     setPlacement(windowPlacement: CornerType): void;
+    /**
+     * Sets the scrollbar policy for the horizontal and vertical scrollbars.
+     *
+     * The policy determines when the scrollbar should appear; it is a value
+     * from the [enum@Gtk.PolicyType] enumeration. If %GTK_POLICY_ALWAYS, the
+     * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
+     * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
+     * if needed (that is, if the slider part of the bar would be smaller
+     * than the trough — the display is larger than the page size).
+     * @param hscrollbarPolicy - policy for horizontal bar
+     * @param vscrollbarPolicy - policy for vertical bar
+     */
     setPolicy(hscrollbarPolicy: PolicyType, vscrollbarPolicy: PolicyType): void;
+    /**
+     * Sets whether the natural height of the child should be calculated
+     * and propagated through the scrolled window’s requested natural height.
+     * @param propagate - whether to propagate natural height
+     */
     setPropagateNaturalHeight(propagate: boolean): void;
+    /**
+     * Sets whether the natural width of the child should be calculated
+     * and propagated through the scrolled window’s requested natural width.
+     * @param propagate - whether to propagate natural width
+     */
     setPropagateNaturalWidth(propagate: boolean): void;
+    /**
+     * Sets the `GtkAdjustment` for the vertical scrollbar.
+     * @param vadjustment - the `GtkAdjustment` to use, or %NULL to create a new one
+     */
     setVadjustment(vadjustment?: Adjustment | null): void;
+    /**
+     * Unsets the placement of the contents with respect to the scrollbars.
+     *
+     * If no window placement is set for a scrolled window,
+     * it defaults to %GTK_CORNER_TOP_LEFT.
+     */
     unsetPlacement(): void;
     connect(signal: "edge-overshot", handler: (self: ScrolledWindow, pos: PositionType) => void, after?: boolean): number;
     connect(signal: "edge-reached", handler: (self: ScrolledWindow, pos: PositionType) => void, after?: boolean): number;

package/dist/generated/gtk/scrolled-window.js

@@ -2,6 +2,85 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { Widget } from "./widget.js";
+/**
+ * Makes its child scrollable.
+ *
+ *
+ *
+ * It does so using either internally added scrollbars or externally
+ * associated adjustments, and optionally draws a frame around the child.
+ *
+ * Widgets with native scrolling support, i.e. those whose classes implement
+ * the [iface@Gtk.Scrollable] interface, are added directly. For other types
+ * of widget, the class [class@Gtk.Viewport] acts as an adaptor, giving
+ * scrollability to other widgets. [method@Gtk.ScrolledWindow.set_child]
+ * intelligently accounts for whether or not the added child is a `GtkScrollable`.
+ * If it isn’t, then it wraps the child in a `GtkViewport`. Therefore, you can
+ * just add any child widget and not worry about the details.
+ *
+ * If [method@Gtk.ScrolledWindow.set_child] has added a `GtkViewport` for you,
+ * it will be automatically removed when you unset the child.
+ * Unless [property@Gtk.ScrolledWindow:hscrollbar-policy] and
+ * [property@Gtk.ScrolledWindow:vscrollbar-policy] are %GTK_POLICY_NEVER or
+ * %GTK_POLICY_EXTERNAL, `GtkScrolledWindow` adds internal `GtkScrollbar` widgets
+ * around its child. The scroll position of the child, and if applicable the
+ * scrollbars, is controlled by the [property@Gtk.ScrolledWindow:hadjustment]
+ * and [property@Gtk.ScrolledWindow:vadjustment] that are associated with the
+ * `GtkScrolledWindow`. See the docs on [class@Gtk.Scrollbar] for the details,
+ * but note that the “step_increment” and “page_increment” fields are only
+ * effective if the policy causes scrollbars to be present.
+ *
+ * If a `GtkScrolledWindow` doesn’t behave quite as you would like, or
+ * doesn’t have exactly the right layout, it’s very possible to set up
+ * your own scrolling with `GtkScrollbar` and for example a `GtkGrid`.
+ *
+ * # Touch support
+ *
+ * `GtkScrolledWindow` has built-in support for touch devices. When a
+ * touchscreen is used, swiping will move the scrolled window, and will
+ * expose 'kinetic' behavior. This can be turned off with the
+ * [property@Gtk.ScrolledWindow:kinetic-scrolling] property if it is undesired.
+ *
+ * `GtkScrolledWindow` also displays visual 'overshoot' indication when
+ * the content is pulled beyond the end, and this situation can be
+ * captured with the [signal@Gtk.ScrolledWindow::edge-overshot] signal.
+ *
+ * If no mouse device is present, the scrollbars will overlaid as
+ * narrow, auto-hiding indicators over the content. If traditional
+ * scrollbars are desired although no mouse is present, this behaviour
+ * can be turned off with the [property@Gtk.ScrolledWindow:overlay-scrolling]
+ * property.
+ *
+ * # Shortcuts and Gestures
+ *
+ * The following signals have default keybindings:
+ *
+ * - [signal@Gtk.ScrolledWindow::scroll-child]
+ *
+ * # CSS nodes
+ *
+ * `GtkScrolledWindow` has a main CSS node with name scrolledwindow.
+ * It gets a .frame style class added when [property@Gtk.ScrolledWindow:has-frame]
+ * is %TRUE.
+ *
+ * It uses subnodes with names overshoot and undershoot to draw the overflow
+ * and underflow indications. These nodes get the .left, .right, .top or .bottom
+ * style class added depending on where the indication is drawn.
+ *
+ * `GtkScrolledWindow` also sets the positional style classes (.left, .right,
+ * .top, .bottom) and style classes related to overlay scrolling
+ * (.overlay-indicator, .dragging, .hovering) on its scrollbars.
+ *
+ * If both scrollbars are visible, the area where they meet is drawn
+ * with a subnode named junction.
+ *
+ * # Accessibility
+ *
+ * Until GTK 4.10, `GtkScrolledWindow` used the [enum@Gtk.AccessibleRole.group] role.
+ *
+ * Starting from GTK 4.12, `GtkScrolledWindow` uses the [enum@Gtk.AccessibleRole.generic]
+ * role.
+ */
 const SIGNAL_META = {
     "edge-overshot": {
         params: [{ type: { type: "int", size: 32, unsigned: false } }],
@@ -24,6 +103,9 @@ const SIGNAL_META = {
     },
 };
 export class ScrolledWindow extends Widget {
+    /**
+     * Creates a new scrolled window.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -33,6 +115,13 @@ export class ScrolledWindow extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Gets the child widget of @scrolled_window.
+     *
+     * If the scrolled window automatically added a [class@Gtk.Viewport], this
+     * function will return the viewport widget, and you can retrieve its child
+     * using [method@Gtk.Viewport.get_child].
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_scrolled_window_get_child", [
             {
@@ -44,6 +133,12 @@ export class ScrolledWindow extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns the horizontal scrollbar’s adjustment.
+     *
+     * This is the adjustment used to connect the horizontal scrollbar
+     * to the child widget’s horizontal scroll functionality.
+     */
     getHadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrolled_window_get_hadjustment", [
             {
@@ -53,6 +148,9 @@ export class ScrolledWindow extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Gets whether the scrolled window draws a frame.
+     */
     getHasFrame() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_has_frame", [
             {
@@ -61,6 +159,9 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the horizontal scrollbar of @scrolled_window.
+     */
     getHscrollbar() {
         const ptr = call("libgtk-4.so.1", "gtk_scrolled_window_get_hscrollbar", [
             {
@@ -70,6 +171,9 @@ export class ScrolledWindow extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns the specified kinetic scrolling behavior.
+     */
     getKineticScrolling() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_kinetic_scrolling", [
             {
@@ -78,6 +182,9 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the maximum content height set.
+     */
     getMaxContentHeight() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_max_content_height", [
             {
@@ -86,6 +193,9 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the maximum content width set.
+     */
     getMaxContentWidth() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_max_content_width", [
             {
@@ -94,6 +204,9 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the minimal content height of @scrolled_window.
+     */
     getMinContentHeight() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_min_content_height", [
             {
@@ -102,6 +215,9 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the minimum content width of @scrolled_window.
+     */
     getMinContentWidth() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_min_content_width", [
             {
@@ -110,6 +226,9 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns whether overlay scrolling is enabled for this scrolled window.
+     */
     getOverlayScrolling() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_overlay_scrolling", [
             {
@@ -118,6 +237,9 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the placement of the contents with respect to the scrollbars.
+     */
     getPlacement() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_placement", [
             {
@@ -126,6 +248,14 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the current policy values for the horizontal and vertical
+     * scrollbars.
+     *
+     * See [method@Gtk.ScrolledWindow.set_policy].
+     * @param hscrollbarPolicy - location to store the policy
+     * @param vscrollbarPolicy - location to store the policy
+     */
     getPolicy(hscrollbarPolicy, vscrollbarPolicy) {
         call("libgtk-4.so.1", "gtk_scrolled_window_get_policy", [
             {
@@ -150,6 +280,10 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Reports whether the natural height of the child will be calculated
+     * and propagated through the scrolled window’s requested natural height.
+     */
     getPropagateNaturalHeight() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_propagate_natural_height", [
             {
@@ -158,6 +292,10 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Reports whether the natural width of the child will be calculated
+     * and propagated through the scrolled window’s requested natural width.
+     */
     getPropagateNaturalWidth() {
         return call("libgtk-4.so.1", "gtk_scrolled_window_get_propagate_natural_width", [
             {
@@ -166,6 +304,12 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the vertical scrollbar’s adjustment.
+     *
+     * This is the adjustment used to connect the vertical
+     * scrollbar to the child widget’s vertical scroll functionality.
+     */
     getVadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrolled_window_get_vadjustment", [
             {
@@ -175,6 +319,9 @@ export class ScrolledWindow extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Returns the vertical scrollbar of @scrolled_window.
+     */
     getVscrollbar() {
         const ptr = call("libgtk-4.so.1", "gtk_scrolled_window_get_vscrollbar", [
             {
@@ -184,6 +331,14 @@ export class ScrolledWindow extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Widget);
     }
+    /**
+     * Sets the child widget of @scrolled_window.
+     *
+     * If `child` does not implement the [iface@Gtk.Scrollable] interface,
+     * the scrolled window will add `child` to a [class@Gtk.Viewport] instance
+     * and then add the viewport as its child widget.
+     * @param child - the child widget
+     */
     setChild(child) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_child", [
             {
@@ -197,6 +352,10 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkAdjustment` for the horizontal scrollbar.
+     * @param hadjustment - the `GtkAdjustment` to use, or %NULL to create a new one
+     */
     setHadjustment(hadjustment) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_hadjustment", [
             {
@@ -210,6 +369,10 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes the frame drawn around the contents of @scrolled_window.
+     * @param hasFrame - whether to draw a frame around scrolled window contents
+     */
     setHasFrame(hasFrame) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_has_frame", [
             {
@@ -222,6 +385,13 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Turns kinetic scrolling on or off.
+     *
+     * Kinetic scrolling only applies to devices with source
+     * %GDK_SOURCE_TOUCHSCREEN.
+     * @param kineticScrolling - %TRUE to enable kinetic scrolling
+     */
     setKineticScrolling(kineticScrolling) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_kinetic_scrolling", [
             {
@@ -234,6 +404,16 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the maximum height that `scrolled_window` should keep visible.
+     *
+     * The `scrolled_window` will grow up to this height before it starts
+     * scrolling the content.
+     *
+     * It is a programming error to set the maximum content height to a value
+     * smaller than [property@Gtk.ScrolledWindow:min-content-height].
+     * @param height - the maximum content height
+     */
     setMaxContentHeight(height) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_max_content_height", [
             {
@@ -246,6 +426,16 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the maximum width that `scrolled_window` should keep visible.
+     *
+     * The `scrolled_window` will grow up to this width before it starts
+     * scrolling the content.
+     *
+     * It is a programming error to set the maximum content width to a
+     * value smaller than [property@Gtk.ScrolledWindow:min-content-width].
+     * @param width - the maximum content width
+     */
     setMaxContentWidth(width) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_max_content_width", [
             {
@@ -258,6 +448,16 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the minimum height that `scrolled_window` should keep visible.
+     *
+     * Note that this can and (usually will) be smaller than the minimum
+     * size of the content.
+     *
+     * It is a programming error to set the minimum content height to a
+     * value greater than [property@Gtk.ScrolledWindow:max-content-height].
+     * @param height - the minimal content height
+     */
     setMinContentHeight(height) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_min_content_height", [
             {
@@ -270,6 +470,16 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the minimum width that `scrolled_window` should keep visible.
+     *
+     * Note that this can and (usually will) be smaller than the minimum
+     * size of the content.
+     *
+     * It is a programming error to set the minimum content width to a
+     * value greater than [property@Gtk.ScrolledWindow:max-content-width].
+     * @param width - the minimal content width
+     */
     setMinContentWidth(width) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_min_content_width", [
             {
@@ -282,6 +492,10 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Enables or disables overlay scrolling for this scrolled window.
+     * @param overlayScrolling - whether to enable overlay scrolling
+     */
     setOverlayScrolling(overlayScrolling) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_overlay_scrolling", [
             {
@@ -294,6 +508,19 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the placement of the contents with respect to the scrollbars
+     * for the scrolled window.
+     *
+     * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
+     * in the top left, with the scrollbars underneath and to the right.
+     * Other values in [enum@Gtk.CornerType] are %GTK_CORNER_TOP_RIGHT,
+     * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
+     *
+     * See also [method@Gtk.ScrolledWindow.get_placement] and
+     * [method@Gtk.ScrolledWindow.unset_placement].
+     * @param windowPlacement - position of the child window
+     */
     setPlacement(windowPlacement) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_placement", [
             {
@@ -306,6 +533,18 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the scrollbar policy for the horizontal and vertical scrollbars.
+     *
+     * The policy determines when the scrollbar should appear; it is a value
+     * from the [enum@Gtk.PolicyType] enumeration. If %GTK_POLICY_ALWAYS, the
+     * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
+     * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
+     * if needed (that is, if the slider part of the bar would be smaller
+     * than the trough — the display is larger than the page size).
+     * @param hscrollbarPolicy - policy for horizontal bar
+     * @param vscrollbarPolicy - policy for vertical bar
+     */
     setPolicy(hscrollbarPolicy, vscrollbarPolicy) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_policy", [
             {
@@ -322,6 +561,11 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the natural height of the child should be calculated
+     * and propagated through the scrolled window’s requested natural height.
+     * @param propagate - whether to propagate natural height
+     */
     setPropagateNaturalHeight(propagate) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_propagate_natural_height", [
             {
@@ -334,6 +578,11 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the natural width of the child should be calculated
+     * and propagated through the scrolled window’s requested natural width.
+     * @param propagate - whether to propagate natural width
+     */
     setPropagateNaturalWidth(propagate) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_propagate_natural_width", [
             {
@@ -346,6 +595,10 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkAdjustment` for the vertical scrollbar.
+     * @param vadjustment - the `GtkAdjustment` to use, or %NULL to create a new one
+     */
     setVadjustment(vadjustment) {
         call("libgtk-4.so.1", "gtk_scrolled_window_set_vadjustment", [
             {
@@ -359,6 +612,12 @@ export class ScrolledWindow extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unsets the placement of the contents with respect to the scrollbars.
+     *
+     * If no window placement is set for a scrolled window,
+     * it defaults to %GTK_CORNER_TOP_LEFT.
+     */
     unsetPlacement() {
         call("libgtk-4.so.1", "gtk_scrolled_window_unset_placement", [
             {