@gtkx/ffi 0.5.2 → 0.6.1

package/dist/generated/adw/leaflet.js

@@ -0,0 +1,738 @@
+import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import * as Gtk from "../gtk/index.js";
+/**
+ * An adaptive container acting like a box or a stack.
+ *
+ *
+ *
+ *
+ * The `AdwLeaflet` widget can display its children like a [class@Gtk.Box] does
+ * or like a [class@Gtk.Stack] does, adapting to size changes by switching
+ * between the two modes.
+ *
+ * When there is enough space the children are displayed side by side, otherwise
+ * only one is displayed and the leaflet is said to be “folded”.
+ * The threshold is dictated by the preferred minimum sizes of the children.
+ * When a leaflet is folded, the children can be navigated using swipe gestures.
+ *
+ * The “over” and “under” transition types stack the children one on top of the
+ * other, while the “slide” transition puts the children side by side. While
+ * navigating to a child on the side or below can be performed by swiping the
+ * current child away, navigating to an upper child requires dragging it from
+ * the edge where it resides. This doesn't affect non-dragging swipes.
+ *
+ * ## CSS nodes
+ *
+ * `AdwLeaflet` has a single CSS node with name `leaflet`. The node will get the
+ * style classes `.folded` when it is folded, `.unfolded` when it's not, or none
+ * if it hasn't computed its fold yet.
+ */
+export class Leaflet extends Gtk.Widget {
+    static glibTypeName = "AdwLeaflet";
+    /**
+     * Creates a new `AdwLeaflet`.
+     */
+    constructor() {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            this.id = call("libadwaita-1.so.0", "adw_leaflet_new", [], {
+                type: "gobject",
+                borrowed: true,
+            });
+        }
+        else {
+            // @ts-ignore
+            super();
+        }
+    }
+    /**
+     * Adds a child to @self.
+     * @param child - the widget to add
+     */
+    append(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_append", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Finds the previous or next navigatable child.
+     *
+     * This will be the same child [method@Leaflet.navigate] or swipe gestures will
+     * navigate to.
+     *
+     * If there's no child to navigate to, `NULL` will be returned instead.
+     *
+     * See [property@LeafletPage:navigatable].
+     * @param direction - the direction
+     */
+    getAdjacentChild(direction) {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_adjacent_child", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: direction,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets whether gestures and shortcuts for navigating backward are enabled.
+     */
+    getCanNavigateBack() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_can_navigate_back", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets whether gestures and shortcuts for navigating forward are enabled.
+     */
+    getCanNavigateForward() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_can_navigate_forward", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets whether `self` can unfold.
+     */
+    getCanUnfold() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_can_unfold", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Finds the child of `self` with @name.
+     *
+     * Returns `NULL` if there is no child with this name.
+     *
+     * See [property@LeafletPage:name].
+     * @param name - the name of the child to find
+     */
+    getChildByName(name) {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_child_by_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: name,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets the child transition spring parameters for @self.
+     */
+    getChildTransitionParams() {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_child_transition_params", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "AdwSpringParams",
+            lib: "libadwaita-1.so.0",
+        });
+        return getObject(ptr);
+    }
+    /**
+     * Gets whether a child transition is currently running for @self.
+     */
+    getChildTransitionRunning() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_child_transition_running", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets the fold threshold policy for @self.
+     */
+    getFoldThresholdPolicy() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_fold_threshold_policy", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets whether `self` is folded.
+     *
+     * The leaflet will be folded if the size allocated to it is smaller than the
+     * sum of the minimum or natural sizes of the children (see
+     * [property@Leaflet:fold-threshold-policy]), it will be unfolded otherwise.
+     */
+    getFolded() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_folded", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets whether `self` is homogeneous.
+     */
+    getHomogeneous() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_homogeneous", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets the mode transition animation duration for @self.
+     */
+    getModeTransitionDuration() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_mode_transition_duration", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: true });
+    }
+    /**
+     * Returns the [class@LeafletPage] object for @child.
+     * @param child - a child of @self
+     */
+    getPage(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Returns a [iface@Gio.ListModel] that contains the pages of the leaflet.
+     *
+     * This can be used to keep an up-to-date view. The model also implements
+     * [iface@Gtk.SelectionModel] and can be used to track and change the visible
+     * page.
+     */
+    getPages() {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_pages", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Gets the type of animation used for transitions between modes and children.
+     */
+    getTransitionType() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_transition_type", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets the widget currently visible when the leaflet is folded.
+     */
+    getVisibleChild() {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_visible_child", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets the name of the currently visible child widget.
+     */
+    getVisibleChildName() {
+        return call("libadwaita-1.so.0", "adw_leaflet_get_visible_child_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Inserts `child` in the position after `sibling` in the list of children.
+     *
+     * If `sibling` is `NULL`, inserts `child` at the first position.
+     * @param child - the widget to insert
+     * @param sibling - the sibling after which to insert @child
+     */
+    insertChildAfter(child, sibling) {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_insert_child_after", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: sibling?.id ?? sibling,
+                optional: true,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Navigates to the previous or next child.
+     *
+     * The child must have the [property@LeafletPage:navigatable] property set to
+     * `TRUE`, otherwise it will be skipped.
+     *
+     * This will be the same child as returned by
+     * [method@Leaflet.get_adjacent_child] or navigated to via swipe gestures.
+     * @param direction - the direction
+     */
+    navigate(direction) {
+        return call("libadwaita-1.so.0", "adw_leaflet_navigate", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: direction,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Inserts `child` at the first position in @self.
+     * @param child - the widget to prepend
+     */
+    prepend(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_leaflet_prepend", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Removes a child widget from @self.
+     * @param child - the child to remove
+     */
+    remove(child) {
+        call("libadwaita-1.so.0", "adw_leaflet_remove", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Moves `child` to the position after `sibling` in the list of children.
+     *
+     * If `sibling` is `NULL`, moves `child` to the first position.
+     * @param child - the widget to move, must be a child of @self
+     * @param sibling - the sibling to move `child` after
+     */
+    reorderChildAfter(child, sibling) {
+        call("libadwaita-1.so.0", "adw_leaflet_reorder_child_after", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: sibling?.id ?? sibling,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets whether gestures and shortcuts for navigating backward are enabled.
+     *
+     * The supported gestures are:
+     *
+     * - One-finger swipe on touchscreens
+     * - Horizontal scrolling on touchpads (usually two-finger swipe)
+     * - Back/forward mouse buttons
+     *
+     * The keyboard back/forward keys are also supported, as well as the
+     * `Alt`+`←` shortcut for horizontal orientation, or
+     * `Alt`+`↑` for vertical orientation.
+     *
+     * If the orientation is horizontal, for right-to-left locales, gestures and
+     * shortcuts are reversed.
+     *
+     * Only children that have [property@LeafletPage:navigatable] set to `TRUE` can
+     * be navigated to.
+     * @param canNavigateBack - the new value
+     */
+    setCanNavigateBack(canNavigateBack) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_can_navigate_back", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: canNavigateBack,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets whether gestures and shortcuts for navigating forward are enabled.
+     *
+     * The supported gestures are:
+     *
+     * - One-finger swipe on touchscreens
+     * - Horizontal scrolling on touchpads (usually two-finger swipe)
+     * - Back/forward mouse buttons
+     *
+     * The keyboard back/forward keys are also supported, as well as the
+     * `Alt`+`→` shortcut for horizontal orientation, or
+     * `Alt`+`↓` for vertical orientation.
+     *
+     * If the orientation is horizontal, for right-to-left locales, gestures and
+     * shortcuts are reversed.
+     *
+     * Only children that have [property@LeafletPage:navigatable] set to `TRUE` can
+     * be navigated to.
+     * @param canNavigateForward - the new value
+     */
+    setCanNavigateForward(canNavigateForward) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_can_navigate_forward", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: canNavigateForward,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets whether `self` can unfold.
+     * @param canUnfold - whether `self` can unfold
+     */
+    setCanUnfold(canUnfold) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_can_unfold", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: canUnfold,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the child transition spring parameters for @self.
+     *
+     * The default value is equivalent to:
+     *
+     * ```c
+     * adw_spring_params_new (1, 0.5, 500)
+     * ```
+     * @param params - the new parameters
+     */
+    setChildTransitionParams(params) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_child_transition_params", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "AdwSpringParams",
+                    lib: "libadwaita-1.so.0",
+                },
+                value: params?.id ?? params,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the fold threshold policy for @self.
+     *
+     * If set to `ADW_FOLD_THRESHOLD_POLICY_MINIMUM`, it will only fold when the
+     * children cannot fit anymore. With `ADW_FOLD_THRESHOLD_POLICY_NATURAL`, it
+     * will fold as soon as children don't get their natural size.
+     *
+     * This can be useful if you have a long ellipsizing label and want to let it
+     * ellipsize instead of immediately folding.
+     * @param policy - the policy to use
+     */
+    setFoldThresholdPolicy(policy) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_fold_threshold_policy", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: policy,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets `self` to be homogeneous or not.
+     *
+     * If set to `FALSE`, different children can have different size along the
+     * opposite orientation.
+     * @param homogeneous - whether to make `self` homogeneous
+     */
+    setHomogeneous(homogeneous) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_homogeneous", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: homogeneous,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the mode transition animation duration for @self.
+     * @param duration - the new duration, in milliseconds
+     */
+    setModeTransitionDuration(duration) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_mode_transition_duration", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: duration,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the type of animation used for transitions between modes and children.
+     *
+     * The transition type can be changed without problems at runtime, so it is
+     * possible to change the animation based on the mode or child that is about to
+     * become current.
+     * @param transition - the new transition type
+     */
+    setTransitionType(transition) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_transition_type", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: transition,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the widget currently visible when the leaflet is folded.
+     *
+     * The transition is determined by [property@Leaflet:transition-type] and
+     * [property@Leaflet:child-transition-params]. The transition can be cancelled
+     * by the user, in which case visible child will change back to the previously
+     * visible child.
+     * @param visibleChild - the new child
+     */
+    setVisibleChild(visibleChild) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_visible_child", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: visibleChild?.id ?? visibleChild,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Makes the child with the name `name` visible.
+     *
+     * See [property@Leaflet:visible-child].
+     * @param name - the name of a child
+     */
+    setVisibleChildName(name) {
+        call("libadwaita-1.so.0", "adw_leaflet_set_visible_child_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: name,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Gets the progress `self` will snap back to after the gesture is canceled.
+     */
+    getCancelProgress() {
+        return call("libadwaita-1.so.0", "adw_swipeable_get_cancel_progress", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "float", size: 64 });
+    }
+    /**
+     * Gets the swipe distance of @self.
+     *
+     * This corresponds to how many pixels 1 unit represents.
+     */
+    getDistance() {
+        return call("libadwaita-1.so.0", "adw_swipeable_get_distance", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "float", size: 64 });
+    }
+    /**
+     * Gets the current progress of @self.
+     */
+    getProgress() {
+        return call("libadwaita-1.so.0", "adw_swipeable_get_progress", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "float", size: 64 });
+    }
+    /**
+     * Gets the snap points of @self.
+     *
+     * Each snap point represents a progress value that is considered acceptable to
+     * end the swipe on.
+     * @param nSnapPoints - location to return the number of the snap points
+     */
+    getSnapPoints(nSnapPoints) {
+        return call("libadwaita-1.so.0", "adw_swipeable_get_snap_points", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: nSnapPoints,
+            },
+        ], { type: "array", itemType: { type: "float", size: 64 } });
+    }
+    /**
+     * Gets the area `self` can start a swipe from for the given direction and
+     * gesture type.
+     *
+     * This can be used to restrict swipes to only be possible from a certain area,
+     * for example, to only allow edge swipes, or to have a draggable element and
+     * ignore swipes elsewhere.
+     *
+     * If not implemented, the default implementation returns the allocation of
+     * @self, allowing swipes from anywhere.
+     * @param navigationDirection - the direction of the swipe
+     * @param isDrag - whether the swipe is caused by a dragging gesture
+     * @param rect - a pointer to a rectangle to store the swipe area
+     */
+    getSwipeArea(navigationDirection, isDrag, rect) {
+        call("libadwaita-1.so.0", "adw_swipeable_get_swipe_area", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: navigationDirection,
+            },
+            {
+                type: { type: "boolean" },
+                value: isDrag,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "GdkRectangle",
+                    lib: "libadwaita-1.so.0",
+                },
+                value: rect?.id ?? rect,
+            },
+        ], { type: "undefined" });
+    }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0]);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libadwaita-1.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.id },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
+}
+registerType(Leaflet);