@gtkx/ffi 0.1.44 → 0.1.46

package/dist/generated/gdk/popup-layout.d.ts

@@ -1,25 +1,151 @@
 import { Ref } from "@gtkx/native";
 import { AnchorHints, Gravity } from "./enums.js";
 import { Rectangle } from "./rectangle.js";
+/**
+ * Contains information that is necessary position a [iface@Gdk.Popup]
+ * relative to its parent.
+ *
+ * The positioning requires a negotiation with the windowing system,
+ * since it depends on external constraints, such as the position of
+ * the parent surface, and the screen dimensions.
+ *
+ * The basic ingredients are a rectangle on the parent surface,
+ * and the anchor on both that rectangle and the popup. The anchors
+ * specify a side or corner to place next to each other.
+ *
+ *
+ *
+ * For cases where placing the anchors next to each other would make
+ * the popup extend offscreen, the layout includes some hints for how
+ * to resolve this problem. The hints may suggest to flip the anchor
+ * position to the other side, or to 'slide' the popup along a side,
+ * or to resize it.
+ *
+ *
+ *
+ *
+ *
+ * These hints may be combined.
+ *
+ * Ultimatively, it is up to the windowing system to determine the position
+ * and size of the popup. You can learn about the result by calling
+ * [method@Gdk.Popup.get_position_x], [method@Gdk.Popup.get_position_y],
+ * [method@Gdk.Popup.get_rect_anchor] and [method@Gdk.Popup.get_surface_anchor]
+ * after the popup has been presented. This can be used to adjust the rendering.
+ * For example, GtkPopover changes its arrow position
+ * accordingly. But you have to be careful avoid changing the size of the popover,
+ * or it has to be presented again.
+ */
 export declare class PopupLayout {
     ptr: unknown;
+    /**
+     * Create a popup layout description.
+     *
+     * Used together with [method@Gdk.Popup.present] to describe how a popup
+     * surface should be placed and behave on-screen.
+     *
+     * `anchor_rect` is relative to the top-left corner of the surface's parent.
+     * `rect_anchor` and `surface_anchor` determine anchor points on `anchor_rect` and surface to pin together.
+     *
+     * The position of @anchor_rect's anchor point can optionally be offset using
+     * [method@Gdk.PopupLayout.set_offset], which is equivalent to offsetting the
+     * position of surface.
+     * @param anchorRect - the anchor rectangle to align `surface` with
+     * @param rectAnchor - the point on `anchor_rect` to align with @surface's anchor point
+     * @param surfaceAnchor - the point on `surface` to align with @rect's anchor point
+     */
     constructor(anchorRect: Rectangle, rectAnchor: Gravity, surfaceAnchor: Gravity);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Makes a copy of @layout.
+     */
     copy(): PopupLayout;
+    /**
+     * Check whether `layout` and `other` has identical layout properties.
+     * @param other - another popup layout
+     */
     equal(other: PopupLayout): boolean;
+    /**
+     * Get the anchor hints.
+     */
     getAnchorHints(): AnchorHints;
+    /**
+     * Get the anchor rectangle.
+     */
     getAnchorRect(): Rectangle;
+    /**
+     * Retrieves the offset for the anchor rectangle.
+     * @param dx - return location for the delta X coordinate
+     * @param dy - return location for the delta Y coordinate
+     */
     getOffset(dx: Ref<number>, dy: Ref<number>): void;
+    /**
+     * Returns the anchor position on the anchor rectangle.
+     */
     getRectAnchor(): Gravity;
+    /**
+     * Obtains the shadow widths of this layout.
+     * @param left - return location for the left shadow width
+     * @param right - return location for the right shadow width
+     * @param top - return location for the top shadow width
+     * @param bottom - return location for the bottom shadow width
+     */
     getShadowWidth(left: Ref<number>, right: Ref<number>, top: Ref<number>, bottom: Ref<number>): void;
+    /**
+     * Returns the anchor position on the popup surface.
+     */
     getSurfaceAnchor(): Gravity;
+    /**
+     * Increases the reference count of @value.
+     */
     ref(): PopupLayout;
+    /**
+     * Set new anchor hints.
+     *
+     * The set `anchor_hints` determines how `surface` will be moved
+     * if the anchor points cause it to move off-screen. For example,
+     * `GDK_ANCHOR_FLIP_X` will replace `GDK_GRAVITY_NORTH_WEST` with
+     * `GDK_GRAVITY_NORTH_EAST` and vice versa if `surface` extends
+     * beyond the left or right edges of the monitor.
+     * @param anchorHints - the new anchor hints
+     */
     setAnchorHints(anchorHints: AnchorHints): void;
+    /**
+     * Set the anchor rectangle.
+     * @param anchorRect - the new anchor rectangle
+     */
     setAnchorRect(anchorRect: Rectangle): void;
+    /**
+     * Offset the position of the anchor rectangle with the given delta.
+     * @param dx - x delta to offset the anchor rectangle with
+     * @param dy - y delta to offset the anchor rectangle with
+     */
     setOffset(dx: number, dy: number): void;
+    /**
+     * Set the anchor on the anchor rectangle.
+     * @param anchor - the new rect anchor
+     */
     setRectAnchor(anchor: Gravity): void;
+    /**
+     * Sets the shadow width of the popup.
+     *
+     * The shadow width corresponds to the part of the computed
+     * surface size that would consist of the shadow margin
+     * surrounding the window, would there be any.
+     * @param left - width of the left part of the shadow
+     * @param right - width of the right part of the shadow
+     * @param top - height of the top part of the shadow
+     * @param bottom - height of the bottom part of the shadow
+     */
     setShadowWidth(left: number, right: number, top: number, bottom: number): void;
+    /**
+     * Set the anchor on the popup surface.
+     * @param anchor - the new popup surface anchor
+     */
     setSurfaceAnchor(anchor: Gravity): void;
+    /**
+     * Decreases the reference count of @value.
+     */
     unref(): void;
 }

package/dist/generated/gdk/popup-layout.js

@@ -1,6 +1,41 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Rectangle } from "./rectangle.js";
+/**
+ * Contains information that is necessary position a [iface@Gdk.Popup]
+ * relative to its parent.
+ *
+ * The positioning requires a negotiation with the windowing system,
+ * since it depends on external constraints, such as the position of
+ * the parent surface, and the screen dimensions.
+ *
+ * The basic ingredients are a rectangle on the parent surface,
+ * and the anchor on both that rectangle and the popup. The anchors
+ * specify a side or corner to place next to each other.
+ *
+ *
+ *
+ * For cases where placing the anchors next to each other would make
+ * the popup extend offscreen, the layout includes some hints for how
+ * to resolve this problem. The hints may suggest to flip the anchor
+ * position to the other side, or to 'slide' the popup along a side,
+ * or to resize it.
+ *
+ *
+ *
+ *
+ *
+ * These hints may be combined.
+ *
+ * Ultimatively, it is up to the windowing system to determine the position
+ * and size of the popup. You can learn about the result by calling
+ * [method@Gdk.Popup.get_position_x], [method@Gdk.Popup.get_position_y],
+ * [method@Gdk.Popup.get_rect_anchor] and [method@Gdk.Popup.get_surface_anchor]
+ * after the popup has been presented. This can be used to adjust the rendering.
+ * For example, GtkPopover changes its arrow position
+ * accordingly. But you have to be careful avoid changing the size of the popover,
+ * or it has to be presented again.
+ */
 export class PopupLayout {
     ptr;
     constructor(...args) {
@@ -29,6 +64,9 @@ export class PopupLayout {
             },
         ], { type: "boxed", borrowed: true, innerType: "GdkPopupLayout" });
     }
+    /**
+     * Makes a copy of @layout.
+     */
     copy() {
         const ptr = call("libgtk-4.so.1", "gdk_popup_layout_copy", [
             {
@@ -43,6 +81,10 @@ export class PopupLayout {
         });
         return getObject(ptr, PopupLayout);
     }
+    /**
+     * Check whether `layout` and `other` has identical layout properties.
+     * @param other - another popup layout
+     */
     equal(other) {
         return call("libgtk-4.so.1", "gdk_popup_layout_equal", [
             {
@@ -60,6 +102,9 @@ export class PopupLayout {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Get the anchor hints.
+     */
     getAnchorHints() {
         return call("libgtk-4.so.1", "gdk_popup_layout_get_anchor_hints", [
             {
@@ -68,6 +113,9 @@ export class PopupLayout {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Get the anchor rectangle.
+     */
     getAnchorRect() {
         const ptr = call("libgtk-4.so.1", "gdk_popup_layout_get_anchor_rect", [
             {
@@ -82,6 +130,11 @@ export class PopupLayout {
         });
         return getObject(ptr, Rectangle);
     }
+    /**
+     * Retrieves the offset for the anchor rectangle.
+     * @param dx - return location for the delta X coordinate
+     * @param dy - return location for the delta Y coordinate
+     */
     getOffset(dx, dy) {
         call("libgtk-4.so.1", "gdk_popup_layout_get_offset", [
             {
@@ -104,6 +157,9 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the anchor position on the anchor rectangle.
+     */
     getRectAnchor() {
         return call("libgtk-4.so.1", "gdk_popup_layout_get_rect_anchor", [
             {
@@ -112,6 +168,13 @@ export class PopupLayout {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Obtains the shadow widths of this layout.
+     * @param left - return location for the left shadow width
+     * @param right - return location for the right shadow width
+     * @param top - return location for the top shadow width
+     * @param bottom - return location for the bottom shadow width
+     */
     getShadowWidth(left, right, top, bottom) {
         call("libgtk-4.so.1", "gdk_popup_layout_get_shadow_width", [
             {
@@ -148,6 +211,9 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the anchor position on the popup surface.
+     */
     getSurfaceAnchor() {
         return call("libgtk-4.so.1", "gdk_popup_layout_get_surface_anchor", [
             {
@@ -156,6 +222,9 @@ export class PopupLayout {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Increases the reference count of @value.
+     */
     ref() {
         const ptr = call("libgtk-4.so.1", "gdk_popup_layout_ref", [
             {
@@ -170,6 +239,16 @@ export class PopupLayout {
         });
         return getObject(ptr, PopupLayout);
     }
+    /**
+     * Set new anchor hints.
+     *
+     * The set `anchor_hints` determines how `surface` will be moved
+     * if the anchor points cause it to move off-screen. For example,
+     * `GDK_ANCHOR_FLIP_X` will replace `GDK_GRAVITY_NORTH_WEST` with
+     * `GDK_GRAVITY_NORTH_EAST` and vice versa if `surface` extends
+     * beyond the left or right edges of the monitor.
+     * @param anchorHints - the new anchor hints
+     */
     setAnchorHints(anchorHints) {
         call("libgtk-4.so.1", "gdk_popup_layout_set_anchor_hints", [
             {
@@ -182,6 +261,10 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the anchor rectangle.
+     * @param anchorRect - the new anchor rectangle
+     */
     setAnchorRect(anchorRect) {
         call("libgtk-4.so.1", "gdk_popup_layout_set_anchor_rect", [
             {
@@ -199,6 +282,11 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Offset the position of the anchor rectangle with the given delta.
+     * @param dx - x delta to offset the anchor rectangle with
+     * @param dy - y delta to offset the anchor rectangle with
+     */
     setOffset(dx, dy) {
         call("libgtk-4.so.1", "gdk_popup_layout_set_offset", [
             {
@@ -215,6 +303,10 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the anchor on the anchor rectangle.
+     * @param anchor - the new rect anchor
+     */
     setRectAnchor(anchor) {
         call("libgtk-4.so.1", "gdk_popup_layout_set_rect_anchor", [
             {
@@ -227,6 +319,17 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the shadow width of the popup.
+     *
+     * The shadow width corresponds to the part of the computed
+     * surface size that would consist of the shadow margin
+     * surrounding the window, would there be any.
+     * @param left - width of the left part of the shadow
+     * @param right - width of the right part of the shadow
+     * @param top - height of the top part of the shadow
+     * @param bottom - height of the bottom part of the shadow
+     */
     setShadowWidth(left, right, top, bottom) {
         call("libgtk-4.so.1", "gdk_popup_layout_set_shadow_width", [
             {
@@ -251,6 +354,10 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the anchor on the popup surface.
+     * @param anchor - the new popup surface anchor
+     */
     setSurfaceAnchor(anchor) {
         call("libgtk-4.so.1", "gdk_popup_layout_set_surface_anchor", [
             {
@@ -263,6 +370,9 @@ export class PopupLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decreases the reference count of @value.
+     */
     unref() {
         call("libgtk-4.so.1", "gdk_popup_layout_unref", [
             {

package/dist/generated/gdk/popup.d.ts

@@ -1,15 +1,68 @@
 import { Gravity } from "./enums.js";
 import { PopupLayout } from "./popup-layout.js";
 import { Surface } from "./surface.js";
+/**
+ * A surface that is attached to another surface.
+ *
+ * The `GdkPopup` is positioned relative to its parent surface.
+ *
+ * `GdkPopup`s are typically used to implement menus and similar popups.
+ * They can be modal, which is indicated by the [property@Gdk.Popup:autohide]
+ * property.
+ */
 export declare class Popup {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Popup;
+    /**
+     * Returns whether this popup is set to hide on outside clicks.
+     */
     getAutohide(): boolean;
+    /**
+     * Returns the parent surface of a popup.
+     */
     getParent(): Surface | null;
+    /**
+     * Obtains the position of the popup relative to its parent.
+     */
     getPositionX(): number;
+    /**
+     * Obtains the position of the popup relative to its parent.
+     */
     getPositionY(): number;
+    /**
+     * Gets the current popup rectangle anchor.
+     *
+     * The value returned may change after calling [method@Gdk.Popup.present],
+     * or after the [signal@Gdk.Surface::layout] signal is emitted.
+     */
     getRectAnchor(): Gravity;
+    /**
+     * Gets the current popup surface anchor.
+     *
+     * The value returned may change after calling [method@Gdk.Popup.present],
+     * or after the [signal@Gdk.Surface::layout] signal is emitted.
+     */
     getSurfaceAnchor(): Gravity;
+    /**
+     * Present `popup` after having processed the `GdkPopupLayout` rules.
+     *
+     * If the popup was previously not showing, it will be shown,
+     * otherwise it will change position according to @layout.
+     *
+     * After calling this function, the result should be handled in response
+     * to the [signal@Gdk.Surface::layout] signal being emitted. The resulting
+     * popup position can be queried using [method@Gdk.Popup.get_position_x],
+     * [method@Gdk.Popup.get_position_y], and the resulting size will be sent as
+     * parameters in the layout signal. Use [method@Gdk.Popup.get_rect_anchor]
+     * and [method@Gdk.Popup.get_surface_anchor] to get the resulting anchors.
+     *
+     * Presenting may fail, for example if the `popup` is set to autohide
+     * and is immediately hidden upon being presented. If presenting failed,
+     * the [signal@Gdk.Surface::layout] signal will not me emitted.
+     * @param width - the unconstrained popup width to layout
+     * @param height - the unconstrained popup height to layout
+     * @param layout - the `GdkPopupLayout` object used to layout
+     */
     present(width: number, height: number, layout: PopupLayout): boolean;
 }

package/dist/generated/gdk/popup.js

@@ -1,6 +1,15 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Surface } from "./surface.js";
+/**
+ * A surface that is attached to another surface.
+ *
+ * The `GdkPopup` is positioned relative to its parent surface.
+ *
+ * `GdkPopup`s are typically used to implement menus and similar popups.
+ * They can be modal, which is indicated by the [property@Gdk.Popup:autohide]
+ * property.
+ */
 export class Popup {
     ptr;
     constructor(ptr) {
@@ -9,6 +18,9 @@ export class Popup {
     static fromPtr(ptr) {
         return new Popup(ptr);
     }
+    /**
+     * Returns whether this popup is set to hide on outside clicks.
+     */
     getAutohide() {
         return call("libgtk-4.so.1", "gdk_popup_get_autohide", [
             {
@@ -17,6 +29,9 @@ export class Popup {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the parent surface of a popup.
+     */
     getParent() {
         const ptr = call("libgtk-4.so.1", "gdk_popup_get_parent", [
             {
@@ -28,6 +43,9 @@ export class Popup {
             return null;
         return getObject(ptr, Surface);
     }
+    /**
+     * Obtains the position of the popup relative to its parent.
+     */
     getPositionX() {
         return call("libgtk-4.so.1", "gdk_popup_get_position_x", [
             {
@@ -36,6 +54,9 @@ export class Popup {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Obtains the position of the popup relative to its parent.
+     */
     getPositionY() {
         return call("libgtk-4.so.1", "gdk_popup_get_position_y", [
             {
@@ -44,6 +65,12 @@ export class Popup {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the current popup rectangle anchor.
+     *
+     * The value returned may change after calling [method@Gdk.Popup.present],
+     * or after the [signal@Gdk.Surface::layout] signal is emitted.
+     */
     getRectAnchor() {
         return call("libgtk-4.so.1", "gdk_popup_get_rect_anchor", [
             {
@@ -52,6 +79,12 @@ export class Popup {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the current popup surface anchor.
+     *
+     * The value returned may change after calling [method@Gdk.Popup.present],
+     * or after the [signal@Gdk.Surface::layout] signal is emitted.
+     */
     getSurfaceAnchor() {
         return call("libgtk-4.so.1", "gdk_popup_get_surface_anchor", [
             {
@@ -60,6 +93,26 @@ export class Popup {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Present `popup` after having processed the `GdkPopupLayout` rules.
+     *
+     * If the popup was previously not showing, it will be shown,
+     * otherwise it will change position according to @layout.
+     *
+     * After calling this function, the result should be handled in response
+     * to the [signal@Gdk.Surface::layout] signal being emitted. The resulting
+     * popup position can be queried using [method@Gdk.Popup.get_position_x],
+     * [method@Gdk.Popup.get_position_y], and the resulting size will be sent as
+     * parameters in the layout signal. Use [method@Gdk.Popup.get_rect_anchor]
+     * and [method@Gdk.Popup.get_surface_anchor] to get the resulting anchors.
+     *
+     * Presenting may fail, for example if the `popup` is set to autohide
+     * and is immediately hidden upon being presented. If presenting failed,
+     * the [signal@Gdk.Surface::layout] signal will not me emitted.
+     * @param width - the unconstrained popup width to layout
+     * @param height - the unconstrained popup height to layout
+     * @param layout - the `GdkPopupLayout` object used to layout
+     */
     present(width, height, layout) {
         return call("libgtk-4.so.1", "gdk_popup_present", [
             {

package/dist/generated/gdk/proximity-event.d.ts

@@ -1,4 +1,5 @@
 import { Event } from "./event.js";
+/** An event related to the proximity of a tool to a device. */
 export declare class ProximityEvent extends Event {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;

package/dist/generated/gdk/proximity-event.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { Event } from "./event.js";
+/** An event related to the proximity of a tool to a device. */
 export class ProximityEvent extends Event {
     constructor(...args) {
         super(...args);

package/dist/generated/gdk/rectangle.d.ts

@@ -5,20 +5,73 @@ export interface RectangleInit {
     width?: number;
     height?: number;
 }
+/**
+ * Represents a rectangle.
+ *
+ * `GdkRectangle` is identical to `cairo_rectangle_t`. Together with Cairo’s
+ * `cairo_region_t` data type, these are the central types for representing
+ * sets of pixels.
+ *
+ * The intersection of two rectangles can be computed with
+ * [method@Gdk.Rectangle.intersect]; to find the union of two rectangles use
+ * [method@Gdk.Rectangle.union].
+ *
+ * The `cairo_region_t` type provided by Cairo is usually used for managing
+ * non-rectangular clipping of graphical operations.
+ *
+ * The Graphene library has a number of other data types for regions and
+ * volumes in 2D and 3D.
+ */
 export declare class Rectangle {
     ptr: unknown;
     constructor(init?: RectangleInit);
     protected createPtr(init: RectangleInit): unknown;
+    /**
+     * Returns %TRUE if `rect` contains the point described by `x` and @y.
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     */
     containsPoint(x: number, y: number): boolean;
+    /**
+     * Checks if the two given rectangles are equal.
+     * @param rect2 - a `GdkRectangle`
+     */
     equal(rect2: Rectangle): boolean;
+    /**
+     * Calculates the intersection of two rectangles.
+     *
+     * It is allowed for `dest` to be the same as either `src1` or @src2.
+     * If the rectangles do not intersect, @dest’s width and height is set
+     * to 0 and its x and y values are undefined. If you are only interested
+     * in whether the rectangles intersect, but not in the intersecting area
+     * itself, pass %NULL for @dest.
+     * @param src2 - a `GdkRectangle`
+     * @param dest - return location for the
+     */
     intersect(src2: Rectangle, dest?: Ref<Rectangle> | null): boolean;
+    /**
+     * Calculates the union of two rectangles.
+     *
+     * The union of rectangles `src1` and `src2` is the smallest rectangle which
+     * includes both `src1` and `src2` within it. It is allowed for `dest` to be
+     * the same as either `src1` or @src2.
+     *
+     * Note that this function does not ignore 'empty' rectangles (ie. with
+     * zero width or height).
+     * @param src2 - a `GdkRectangle`
+     * @param dest - return location for the union of `src1` and @src2
+     */
     union(src2: Rectangle, dest: Ref<Rectangle>): void;
+    /** the x coordinate of the top left corner */
     get x(): number;
     set x(value: number);
+    /** the y coordinate of the top left corner */
     get y(): number;
     set y(value: number);
+    /** the width of the rectangle */
     get width(): number;
     set width(value: number);
+    /** the height of the rectangle */
     get height(): number;
     set height(value: number);
 }