@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/gesture-click.d.ts

@@ -3,6 +3,10 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureClick extends GestureSingle {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes
+     * single and multiple presses.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "pressed", handler: (self: GestureClick, nPress: number, x: number, y: number) => void, after?: boolean): number;

package/dist/generated/gtk/gesture-click.js

@@ -1,6 +1,15 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { GestureSingle } from "./gesture-single.js";
+/**
+ * Recognizes click gestures.
+ *
+ * It is able to recognize multiple clicks on a nearby zone, which
+ * can be listened for through the [signal@Gtk.GestureClick::pressed]
+ * signal. Whenever time or distance between clicks exceed the GTK
+ * defaults, [signal@Gtk.GestureClick::stopped] is emitted, and the
+ * click counter is reset.
+ */
 const SIGNAL_META = {
     pressed: {
         params: [
@@ -73,6 +82,10 @@ const SIGNAL_META = {
     },
 };
 export class GestureClick extends GestureSingle {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes
+     * single and multiple presses.
+     */
     constructor(...args) {
         super(...args);
     }

package/dist/generated/gtk/gesture-drag.d.ts

@@ -4,9 +4,30 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureDrag extends GestureSingle {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes drags.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the offset from the start point.
+     *
+     * If the `gesture` is active, this function returns %TRUE and
+     * fills in `x` and `y` with the coordinates of the current point,
+     * as an offset to the starting drag point.
+     * @param x - X offset for the current point
+     * @param y - Y offset for the current point
+     */
     getOffset(x?: Ref<number> | null, y?: Ref<number> | null): boolean;
+    /**
+     * Gets the point where the drag started.
+     *
+     * If the `gesture` is active, this function returns %TRUE
+     * and fills in `x` and `y` with the drag start coordinates,
+     * in widget-relative coordinates.
+     * @param x - X coordinate for the drag start point
+     * @param y - Y coordinate for the drag start point
+     */
     getStartPoint(x?: Ref<number> | null, y?: Ref<number> | null): boolean;
     connect(signal: "drag-begin", handler: (self: GestureDrag, startX: number, startY: number) => void, after?: boolean): number;
     connect(signal: "drag-end", handler: (self: GestureDrag, offsetX: number, offsetY: number) => void, after?: boolean): number;

package/dist/generated/gtk/gesture-drag.js

@@ -1,6 +1,17 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { GestureSingle } from "./gesture-single.js";
+/**
+ * Recognizes drag gestures.
+ *
+ * The drag operation itself can be tracked throughout the
+ * [signal@Gtk.GestureDrag::drag-begin],
+ * [signal@Gtk.GestureDrag::drag-update] and
+ * [signal@Gtk.GestureDrag::drag-end] signals, and the relevant
+ * coordinates can be extracted through
+ * [method@Gtk.GestureDrag.get_offset] and
+ * [method@Gtk.GestureDrag.get_start_point].
+ */
 const SIGNAL_META = {
     "drag-begin": {
         params: [
@@ -66,6 +77,9 @@ const SIGNAL_META = {
     },
 };
 export class GestureDrag extends GestureSingle {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes drags.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -75,6 +89,15 @@ export class GestureDrag extends GestureSingle {
             borrowed: false,
         });
     }
+    /**
+     * Gets the offset from the start point.
+     *
+     * If the `gesture` is active, this function returns %TRUE and
+     * fills in `x` and `y` with the coordinates of the current point,
+     * as an offset to the starting drag point.
+     * @param x - X offset for the current point
+     * @param y - Y offset for the current point
+     */
     getOffset(x, y) {
         return call("libgtk-4.so.1", "gtk_gesture_drag_get_offset", [
             {
@@ -93,6 +116,15 @@ export class GestureDrag extends GestureSingle {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the point where the drag started.
+     *
+     * If the `gesture` is active, this function returns %TRUE
+     * and fills in `x` and `y` with the drag start coordinates,
+     * in widget-relative coordinates.
+     * @param x - X coordinate for the drag start point
+     * @param y - Y coordinate for the drag start point
+     */
     getStartPoint(x, y) {
         return call("libgtk-4.so.1", "gtk_gesture_drag_get_start_point", [
             {

package/dist/generated/gtk/gesture-long-press.d.ts

@@ -3,9 +3,22 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureLongPress extends GestureSingle {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes long presses.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns the delay factor.
+     */
     getDelayFactor(): number;
+    /**
+     * Applies the given delay factor.
+     *
+     * The default long press time will be multiplied by this value.
+     * Valid values are in the range [0.5..2.0].
+     * @param delayFactor - The delay factor to apply
+     */
     setDelayFactor(delayFactor: number): void;
     connect(signal: "cancelled", handler: (self: GestureLongPress) => void, after?: boolean): number;
     connect(signal: "pressed", handler: (self: GestureLongPress, x: number, y: number) => void, after?: boolean): number;

package/dist/generated/gtk/gesture-long-press.js

@@ -1,6 +1,23 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { GestureSingle } from "./gesture-single.js";
+/**
+ * Recognizes long press gestures.
+ *
+ * This gesture is also known as “Press and Hold”.
+ *
+ * When the timeout is exceeded, the gesture is triggering the
+ * [signal@Gtk.GestureLongPress::pressed] signal.
+ *
+ * If the touchpoint is lifted before the timeout passes, or if
+ * it drifts too far of the initial press point, the
+ * [signal@Gtk.GestureLongPress::cancelled] signal will be emitted.
+ *
+ * How long the timeout is before the ::pressed signal gets emitted is
+ * determined by the [property@Gtk.Settings:gtk-long-press-time] setting.
+ * It can be modified by the [property@Gtk.GestureLongPress:delay-factor]
+ * property.
+ */
 const SIGNAL_META = {
     cancelled: { params: [], returnType: { type: "undefined" } },
     pressed: {
@@ -53,6 +70,9 @@ const SIGNAL_META = {
     },
 };
 export class GestureLongPress extends GestureSingle {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes long presses.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -62,6 +82,9 @@ export class GestureLongPress extends GestureSingle {
             borrowed: false,
         });
     }
+    /**
+     * Returns the delay factor.
+     */
     getDelayFactor() {
         return call("libgtk-4.so.1", "gtk_gesture_long_press_get_delay_factor", [
             {
@@ -70,6 +93,13 @@ export class GestureLongPress extends GestureSingle {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Applies the given delay factor.
+     *
+     * The default long press time will be multiplied by this value.
+     * Valid values are in the range [0.5..2.0].
+     * @param delayFactor - The delay factor to apply
+     */
     setDelayFactor(delayFactor) {
         call("libgtk-4.so.1", "gtk_gesture_long_press_set_delay_factor", [
             {

package/dist/generated/gtk/gesture-pan.d.ts

@@ -3,10 +3,21 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { GestureDrag } from "./gesture-drag.js";
 export declare class GesturePan extends GestureDrag {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes pan gestures.
+     * @param orientation - expected orientation
+     */
     constructor(orientation: Orientation);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Returns the orientation of the pan gestures that this `gesture` expects.
+     */
     getOrientation(): Orientation;
+    /**
+     * Sets the orientation to be expected on pan gestures.
+     * @param orientation - expected orientation
+     */
     setOrientation(orientation: Orientation): void;
     connect(signal: "pan", handler: (self: GesturePan, direction: PanDirection, offset: number) => void, after?: boolean): number;
     connect(signal: "drag-begin", handler: (self: GesturePan, startX: number, startY: number) => void, after?: boolean): number;

package/dist/generated/gtk/gesture-pan.js

@@ -1,6 +1,22 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { GestureDrag } from "./gesture-drag.js";
+/**
+ * Recognizes pan gestures.
+ *
+ * These are drags that are locked to happen along one axis. The axis
+ * that a `GtkGesturePan` handles is defined at construct time, and
+ * can be changed through [method@Gtk.GesturePan.set_orientation].
+ *
+ * When the gesture starts to be recognized, `GtkGesturePan` will
+ * attempt to determine as early as possible whether the sequence
+ * is moving in the expected direction, and denying the sequence if
+ * this does not happen.
+ *
+ * Once a panning gesture along the expected axis is recognized,
+ * the [signal@Gtk.GesturePan::pan] signal will be emitted as input
+ * events are received, containing the offset in the given axis.
+ */
 const SIGNAL_META = {
     pan: {
         params: [
@@ -85,6 +101,9 @@ export class GesturePan extends GestureDrag {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Returns the orientation of the pan gestures that this `gesture` expects.
+     */
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_gesture_pan_get_orientation", [
             {
@@ -93,6 +112,10 @@ export class GesturePan extends GestureDrag {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the orientation to be expected on pan gestures.
+     * @param orientation - expected orientation
+     */
     setOrientation(orientation) {
         call("libgtk-4.so.1", "gtk_gesture_pan_set_orientation", [
             {

package/dist/generated/gtk/gesture-rotate.d.ts

@@ -3,8 +3,19 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Gesture } from "./gesture.js";
 export declare class GestureRotate extends Gesture {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes 2-touch
+     * rotation gestures.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the angle delta in radians.
+     *
+     * If `gesture` is active, this function returns the angle difference
+     * in radians since the gesture was first recognized. If `gesture` is
+     * not active, 0 is returned.
+     */
     getAngleDelta(): number;
     connect(signal: "angle-changed", handler: (self: GestureRotate, angle: number, angleDelta: number) => void, after?: boolean): number;
     connect(signal: "begin", handler: (self: GestureRotate, sequence: Gdk.EventSequence) => void, after?: boolean): number;

package/dist/generated/gtk/gesture-rotate.js

@@ -1,6 +1,12 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Gesture } from "./gesture.js";
+/**
+ * Recognizes 2-finger rotation gestures.
+ *
+ * Whenever the angle between both handled sequences changes, the
+ * [signal@Gtk.GestureRotate::angle-changed] signal is emitted.
+ */
 const SIGNAL_META = {
     "angle-changed": {
         params: [
@@ -52,6 +58,10 @@ const SIGNAL_META = {
     },
 };
 export class GestureRotate extends Gesture {
+    /**
+     * Returns a newly created `GtkGesture` that recognizes 2-touch
+     * rotation gestures.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -61,6 +71,13 @@ export class GestureRotate extends Gesture {
             borrowed: false,
         });
     }
+    /**
+     * Gets the angle delta in radians.
+     *
+     * If `gesture` is active, this function returns the angle difference
+     * in radians since the gesture was first recognized. If `gesture` is
+     * not active, 0 is returned.
+     */
     getAngleDelta() {
         return call("libgtk-4.so.1", "gtk_gesture_rotate_get_angle_delta", [
             {

package/dist/generated/gtk/gesture-single.d.ts

@@ -5,13 +5,60 @@ import { Gesture } from "./gesture.js";
 export declare class GestureSingle extends Gesture {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns the button number `gesture` listens for.
+     *
+     * If this is 0, the gesture reacts to any button press.
+     */
     getButton(): number;
+    /**
+     * Returns the button number currently interacting
+     * with @gesture, or 0 if there is none.
+     */
     getCurrentButton(): number;
+    /**
+     * Returns the event sequence currently interacting with @gesture.
+     *
+     * This is only meaningful if [method@Gtk.Gesture.is_active]
+     * returns %TRUE.
+     */
     getCurrentSequence(): Gdk.EventSequence | null;
+    /**
+     * Gets whether a gesture is exclusive.
+     *
+     * For more information, see [method@Gtk.GestureSingle.set_exclusive].
+     */
     getExclusive(): boolean;
+    /**
+     * Returns %TRUE if the gesture is only triggered by touch events.
+     */
     getTouchOnly(): boolean;
+    /**
+     * Sets the button number `gesture` listens to.
+     *
+     * If non-0, every button press from a different button
+     * number will be ignored. Touch events implicitly match
+     * with button 1.
+     * @param button - button number to listen to, or 0 for any button
+     */
     setButton(button: number): void;
+    /**
+     * Sets whether `gesture` is exclusive.
+     *
+     * An exclusive gesture will only handle pointer and "pointer emulated"
+     * touch events, so at any given time, there is only one sequence able
+     * to interact with those.
+     * @param exclusive - %TRUE to make `gesture` exclusive
+     */
     setExclusive(exclusive: boolean): void;
+    /**
+     * Sets whether to handle only touch events.
+     *
+     * If `touch_only` is %TRUE, `gesture` will only handle events of type
+     * %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE or %GDK_TOUCH_END. If %FALSE,
+     * mouse events will be handled too.
+     * @param touchOnly - whether `gesture` handles only touch events
+     */
     setTouchOnly(touchOnly: boolean): void;
     connect(signal: "begin", handler: (self: GestureSingle, sequence: Gdk.EventSequence) => void, after?: boolean): number;
     connect(signal: "cancel", handler: (self: GestureSingle, sequence: Gdk.EventSequence) => void, after?: boolean): number;

package/dist/generated/gtk/gesture-single.js

@@ -2,6 +2,21 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Gdk from "../gdk/index.js";
 import { Gesture } from "./gesture.js";
+/**
+ * A `GtkGesture` subclass optimized for singe-touch and mouse gestures.
+ *
+ * Under interaction, these gestures stick to the first interacting sequence,
+ * which is accessible through [method@Gtk.GestureSingle.get_current_sequence]
+ * while the gesture is being interacted with.
+ *
+ * By default gestures react to both %GDK_BUTTON_PRIMARY and touch events.
+ * [method@Gtk.GestureSingle.set_touch_only] can be used to change the
+ * touch behavior. Callers may also specify a different mouse button number
+ * to interact with through [method@Gtk.GestureSingle.set_button], or react
+ * to any mouse button by setting it to 0. While the gesture is active, the
+ * button being currently pressed can be known through
+ * [method@Gtk.GestureSingle.get_current_button].
+ */
 const SIGNAL_META = {
     begin: {
         params: [
@@ -60,6 +75,11 @@ export class GestureSingle extends Gesture {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Returns the button number `gesture` listens for.
+     *
+     * If this is 0, the gesture reacts to any button press.
+     */
     getButton() {
         return call("libgtk-4.so.1", "gtk_gesture_single_get_button", [
             {
@@ -68,6 +88,10 @@ export class GestureSingle extends Gesture {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Returns the button number currently interacting
+     * with @gesture, or 0 if there is none.
+     */
     getCurrentButton() {
         return call("libgtk-4.so.1", "gtk_gesture_single_get_current_button", [
             {
@@ -76,6 +100,12 @@ export class GestureSingle extends Gesture {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Returns the event sequence currently interacting with @gesture.
+     *
+     * This is only meaningful if [method@Gtk.Gesture.is_active]
+     * returns %TRUE.
+     */
     getCurrentSequence() {
         const ptr = call("libgtk-4.so.1", "gtk_gesture_single_get_current_sequence", [
             {
@@ -92,6 +122,11 @@ export class GestureSingle extends Gesture {
             return null;
         return getObject(ptr, Gdk.EventSequence);
     }
+    /**
+     * Gets whether a gesture is exclusive.
+     *
+     * For more information, see [method@Gtk.GestureSingle.set_exclusive].
+     */
     getExclusive() {
         return call("libgtk-4.so.1", "gtk_gesture_single_get_exclusive", [
             {
@@ -100,6 +135,9 @@ export class GestureSingle extends Gesture {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if the gesture is only triggered by touch events.
+     */
     getTouchOnly() {
         return call("libgtk-4.so.1", "gtk_gesture_single_get_touch_only", [
             {
@@ -108,6 +146,14 @@ export class GestureSingle extends Gesture {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets the button number `gesture` listens to.
+     *
+     * If non-0, every button press from a different button
+     * number will be ignored. Touch events implicitly match
+     * with button 1.
+     * @param button - button number to listen to, or 0 for any button
+     */
     setButton(button) {
         call("libgtk-4.so.1", "gtk_gesture_single_set_button", [
             {
@@ -120,6 +166,14 @@ export class GestureSingle extends Gesture {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether `gesture` is exclusive.
+     *
+     * An exclusive gesture will only handle pointer and "pointer emulated"
+     * touch events, so at any given time, there is only one sequence able
+     * to interact with those.
+     * @param exclusive - %TRUE to make `gesture` exclusive
+     */
     setExclusive(exclusive) {
         call("libgtk-4.so.1", "gtk_gesture_single_set_exclusive", [
             {
@@ -132,6 +186,14 @@ export class GestureSingle extends Gesture {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to handle only touch events.
+     *
+     * If `touch_only` is %TRUE, `gesture` will only handle events of type
+     * %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE or %GDK_TOUCH_END. If %FALSE,
+     * mouse events will be handled too.
+     * @param touchOnly - whether `gesture` handles only touch events
+     */
     setTouchOnly(touchOnly) {
         call("libgtk-4.so.1", "gtk_gesture_single_set_touch_only", [
             {

package/dist/generated/gtk/gesture-stylus.d.ts

@@ -4,13 +4,74 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureStylus extends GestureSingle {
+    /**
+     * Creates a new `GtkGestureStylus`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns the current values for the requested @axes.
+     *
+     * This function must be called from the handler of one of the
+     * [signal@Gtk.GestureStylus::down], [signal@Gtk.GestureStylus::motion],
+     * [signal@Gtk.GestureStylus::up] or [signal@Gtk.GestureStylus::proximity]
+     * signals.
+     * @param axes - array of requested axes, terminated with %GDK_AXIS_IGNORE
+     * @param values - return location for the axis values
+     */
     getAxes(axes: Gdk.AxisUse[], values: Ref<number[]>): boolean;
+    /**
+     * Returns the current value for the requested @axis.
+     *
+     * This function must be called from the handler of one of the
+     * [signal@Gtk.GestureStylus::down], [signal@Gtk.GestureStylus::motion],
+     * [signal@Gtk.GestureStylus::up] or [signal@Gtk.GestureStylus::proximity]
+     * signals.
+     * @param axis - requested device axis
+     * @param value - return location for the axis value
+     */
     getAxis(axis: Gdk.AxisUse, value: Ref<number>): boolean;
+    /**
+     * Returns the accumulated backlog of tracking information.
+     *
+     * By default, GTK will limit rate of input events. On stylus input
+     * where accuracy of strokes is paramount, this function returns the
+     * accumulated coordinate/timing state before the emission of the
+     * current [Gtk.GestureStylus::motion] signal.
+     *
+     * This function may only be called within a [signal@Gtk.GestureStylus::motion]
+     * signal handler, the state given in this signal and obtainable through
+     * [method@Gtk.GestureStylus.get_axis] express the latest (most up-to-date)
+     * state in motion history.
+     *
+     * The `backlog` is provided in chronological order.
+     * @param backlog - coordinates and times for the backlog events
+     * @param nElems - return location for the number of elements
+     */
     getBacklog(backlog: Ref<number[]>, nElems: Ref<number>): boolean;
+    /**
+     * Returns the `GdkDeviceTool` currently driving input through this gesture.
+     *
+     * This function must be called from the handler of one of the
+     * [signal@Gtk.GestureStylus::down], [signal@Gtk.GestureStylus::motion],
+     * [signal@Gtk.GestureStylus::up] or [signal@Gtk.GestureStylus::proximity]
+     * signals.
+     */
     getDeviceTool(): Gdk.DeviceTool | null;
+    /**
+     * Checks whether the gesture is for styluses only.
+     *
+     * Stylus-only gestures will signal events exclusively from stylus
+     * input devices.
+     */
     getStylusOnly(): boolean;
+    /**
+     * Sets the state of stylus-only
+     *
+     * If true, the gesture will exclusively handle events from stylus input devices,
+     * otherwise it'll handle events from any pointing device.
+     * @param stylusOnly - whether the gesture is used exclusively for stylus events
+     */
     setStylusOnly(stylusOnly: boolean): void;
     connect(signal: "down", handler: (self: GestureStylus, x: number, y: number) => void, after?: boolean): number;
     connect(signal: "motion", handler: (self: GestureStylus, x: number, y: number) => void, after?: boolean): number;