@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -1,33 +1,229 @@
+/**
+ * A set of unsigned integers.
+ *
+ * Another name for this data structure is “bitmap”.
+ *
+ * The current implementation is based on [roaring bitmaps](https://roaringbitmap.org/).
+ *
+ * A bitset allows adding a set of integers and provides support for set operations
+ * like unions, intersections and checks for equality or if a value is contained
+ * in the set. `GtkBitset` also contains various functions to query metadata about
+ * the bitset, such as the minimum or maximum values or its size.
+ *
+ * The fastest way to iterate values in a bitset is [struct@Gtk.BitsetIter].
+ *
+ * The main use case for `GtkBitset` is implementing complex selections for
+ * [iface@Gtk.SelectionModel].
+ */
 export declare class Bitset {
     ptr: unknown;
+    /**
+     * Creates a new empty bitset.
+     */
     constructor();
+    /**
+     * Creates a bitset with the given range set.
+     * @param start - first value to add
+     * @param nItems - number of consecutive values to add
+     */
     static newRange(start: number, nItems: number): Bitset;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Adds `value` to `self` if it wasn't part of it before.
+     * @param value - value to add
+     */
     add(value: number): boolean;
+    /**
+     * Adds all values from `start` (inclusive) to `start` + `n_items` (exclusive) in @self.
+     * @param start - first value to add
+     * @param nItems - number of consecutive values to add
+     */
     addRange(start: number, nItems: number): void;
+    /**
+     * Adds the closed range [@first, @last], so @first, `last` and all
+     * values in between. `first` must be smaller than @last.
+     * @param first - first value to add
+     * @param last - last value to add
+     */
     addRangeClosed(first: number, last: number): void;
+    /**
+     * Interprets the values as a 2-dimensional boolean grid with the given `stride` and inside that grid, adds a rectangle with the given `width` and @height.
+     * @param start - first value to add
+     * @param width - width of the rectangle
+     * @param height - height of the rectangle
+     * @param stride - row stride of the grid
+     */
     addRectangle(start: number, width: number, height: number, stride: number): void;
+    /**
+     * Checks if the given `value` has been added to @self
+     * @param value - the value to check
+     */
     contains(value: number): boolean;
+    /**
+     * Creates a copy of @self.
+     */
     copy(): Bitset;
+    /**
+     * Sets `self` to be the symmetric difference of `self` and @other.
+     *
+     * The symmetric difference is set `self` to contain all values that
+     * were either contained in `self` or in @other, but not in both.
+     * This operation is also called an XOR.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. The bitset
+     * will be emptied in that case.
+     * @param other - the `GtkBitset` to compute the difference from
+     */
     difference(other: Bitset): void;
+    /**
+     * Returns %TRUE if `self` and `other` contain the same values.
+     * @param other - another `GtkBitset`
+     */
     equals(other: Bitset): boolean;
+    /**
+     * Returns the largest value in @self.
+     *
+     * If `self` is empty, 0 is returned.
+     */
     getMaximum(): number;
+    /**
+     * Returns the smallest value in @self.
+     *
+     * If `self` is empty, `G_MAXUINT` is returned.
+     */
     getMinimum(): number;
+    /**
+     * Returns the value of the `nth` item in self.
+     *
+     * If `nth` is >= the size of @self, 0 is returned.
+     * @param nth - index of the item to get
+     */
     getNth(nth: number): number;
+    /**
+     * Gets the number of values that were added to the set.
+     *
+     * For example, if the set is empty, 0 is returned.
+     *
+     * Note that this function returns a `guint64`, because when all
+     * values are set, the return value is `G_MAXUINT + 1`. Unless you
+     * are sure this cannot happen (it can't with `GListModel`), be sure
+     * to use a 64bit type.
+     */
     getSize(): number;
+    /**
+     * Gets the number of values that are part of the set from `first` to `last` (inclusive).
+     *
+     * Note that this function returns a `guint64`, because when all values are
+     * set, the return value is `G_MAXUINT + 1`. Unless you are sure this cannot
+     * happen (it can't with `GListModel`), be sure to use a 64bit type.
+     * @param first - the first element to include
+     * @param last - the last element to include
+     */
     getSizeInRange(first: number, last: number): number;
+    /**
+     * Sets `self` to be the intersection of `self` and @other.
+     *
+     * In other words, remove all values from `self` that are not part of @other.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. Nothing will
+     * happen in that case.
+     * @param other - the `GtkBitset` to intersect with
+     */
     intersect(other: Bitset): void;
+    /**
+     * Check if no value is contained in bitset.
+     */
     isEmpty(): boolean;
+    /**
+     * Acquires a reference on the given `GtkBitset`.
+     */
     ref(): Bitset;
+    /**
+     * Removes `value` from `self` if it was part of it before.
+     * @param value - value to remove
+     */
     remove(value: number): boolean;
+    /**
+     * Removes all values from the bitset so that it is empty again.
+     */
     removeAll(): void;
+    /**
+     * Removes all values from `start` (inclusive) to `start` + `n_items` (exclusive)
+     * in @self.
+     * @param start - first value to remove
+     * @param nItems - number of consecutive values to remove
+     */
     removeRange(start: number, nItems: number): void;
+    /**
+     * Removes the closed range [@first, @last], so @first, `last` and all
+     * values in between. `first` must be smaller than @last.
+     * @param first - first value to remove
+     * @param last - last value to remove
+     */
     removeRangeClosed(first: number, last: number): void;
+    /**
+     * Interprets the values as a 2-dimensional boolean grid with the given `stride` and inside that grid, removes a rectangle with the given `width` and @height.
+     * @param start - first value to remove
+     * @param width - width of the rectangle
+     * @param height - height of the rectangle
+     * @param stride - row stride of the grid
+     */
     removeRectangle(start: number, width: number, height: number, stride: number): void;
+    /**
+     * Shifts all values in `self` to the left by @amount.
+     *
+     * Values smaller than `amount` are discarded.
+     * @param amount - amount to shift all values to the left
+     */
     shiftLeft(amount: number): void;
+    /**
+     * Shifts all values in `self` to the right by @amount.
+     *
+     * Values that end up too large to be held in a #guint are discarded.
+     * @param amount - amount to shift all values to the right
+     */
     shiftRight(amount: number): void;
+    /**
+     * This is a support function for `GListModel` handling, by mirroring
+     * the `GlistModel::items-changed` signal.
+     *
+     * First, it "cuts" the values from `position` to `removed` from
+     * the bitset. That is, it removes all those values and shifts
+     * all larger values to the left by `removed` places.
+     *
+     * Then, it "pastes" new room into the bitset by shifting all values
+     * larger than `position` by `added` spaces to the right. This frees
+     * up space that can then be filled.
+     * @param position - position at which to slice
+     * @param removed - number of values to remove
+     * @param added - number of values to add
+     */
     splice(position: number, removed: number, added: number): void;
+    /**
+     * Sets `self` to be the subtraction of `other` from @self.
+     *
+     * In other words, remove all values from `self` that are part of @other.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. The bitset
+     * will be emptied in that case.
+     * @param other - the `GtkBitset` to subtract
+     */
     subtract(other: Bitset): void;
+    /**
+     * Sets `self` to be the union of `self` and @other.
+     *
+     * That is, add all values from `other` into `self` that weren't part of it.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. Nothing will
+     * happen in that case.
+     * @param other - the `GtkBitset` to union with
+     */
     union(other: Bitset): void;
+    /**
+     * Releases a reference on the given `GtkBitset`.
+     *
+     * If the reference was the last, the resources associated to the `self` are
+     * freed.
+     */
     unref(): void;
 }

package/dist/generated/gtk/bitset.js

@@ -1,10 +1,35 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A set of unsigned integers.
+ *
+ * Another name for this data structure is “bitmap”.
+ *
+ * The current implementation is based on [roaring bitmaps](https://roaringbitmap.org/).
+ *
+ * A bitset allows adding a set of integers and provides support for set operations
+ * like unions, intersections and checks for equality or if a value is contained
+ * in the set. `GtkBitset` also contains various functions to query metadata about
+ * the bitset, such as the minimum or maximum values or its size.
+ *
+ * The fastest way to iterate values in a bitset is [struct@Gtk.BitsetIter].
+ *
+ * The main use case for `GtkBitset` is implementing complex selections for
+ * [iface@Gtk.SelectionModel].
+ */
 export class Bitset {
     ptr;
+    /**
+     * Creates a new empty bitset.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
+    /**
+     * Creates a bitset with the given range set.
+     * @param start - first value to add
+     * @param nItems - number of consecutive values to add
+     */
     static newRange(start, nItems) {
         const ptr = call("libgtk-4.so.1", "gtk_bitset_new_range", [
             {
@@ -25,6 +50,10 @@ export class Bitset {
             innerType: "GtkBitset",
         });
     }
+    /**
+     * Adds `value` to `self` if it wasn't part of it before.
+     * @param value - value to add
+     */
     add(value) {
         return call("libgtk-4.so.1", "gtk_bitset_add", [
             {
@@ -37,6 +66,11 @@ export class Bitset {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Adds all values from `start` (inclusive) to `start` + `n_items` (exclusive) in @self.
+     * @param start - first value to add
+     * @param nItems - number of consecutive values to add
+     */
     addRange(start, nItems) {
         call("libgtk-4.so.1", "gtk_bitset_add_range", [
             {
@@ -53,6 +87,12 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds the closed range [@first, @last], so @first, `last` and all
+     * values in between. `first` must be smaller than @last.
+     * @param first - first value to add
+     * @param last - last value to add
+     */
     addRangeClosed(first, last) {
         call("libgtk-4.so.1", "gtk_bitset_add_range_closed", [
             {
@@ -69,6 +109,13 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Interprets the values as a 2-dimensional boolean grid with the given `stride` and inside that grid, adds a rectangle with the given `width` and @height.
+     * @param start - first value to add
+     * @param width - width of the rectangle
+     * @param height - height of the rectangle
+     * @param stride - row stride of the grid
+     */
     addRectangle(start, width, height, stride) {
         call("libgtk-4.so.1", "gtk_bitset_add_rectangle", [
             {
@@ -93,6 +140,10 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks if the given `value` has been added to @self
+     * @param value - the value to check
+     */
     contains(value) {
         return call("libgtk-4.so.1", "gtk_bitset_contains", [
             {
@@ -105,6 +156,9 @@ export class Bitset {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates a copy of @self.
+     */
     copy() {
         const ptr = call("libgtk-4.so.1", "gtk_bitset_copy", [
             {
@@ -119,6 +173,17 @@ export class Bitset {
         });
         return getObject(ptr, Bitset);
     }
+    /**
+     * Sets `self` to be the symmetric difference of `self` and @other.
+     *
+     * The symmetric difference is set `self` to contain all values that
+     * were either contained in `self` or in @other, but not in both.
+     * This operation is also called an XOR.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. The bitset
+     * will be emptied in that case.
+     * @param other - the `GtkBitset` to compute the difference from
+     */
     difference(other) {
         call("libgtk-4.so.1", "gtk_bitset_difference", [
             {
@@ -136,6 +201,10 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns %TRUE if `self` and `other` contain the same values.
+     * @param other - another `GtkBitset`
+     */
     equals(other) {
         return call("libgtk-4.so.1", "gtk_bitset_equals", [
             {
@@ -153,6 +222,11 @@ export class Bitset {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the largest value in @self.
+     *
+     * If `self` is empty, 0 is returned.
+     */
     getMaximum() {
         return call("libgtk-4.so.1", "gtk_bitset_get_maximum", [
             {
@@ -161,6 +235,11 @@ export class Bitset {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Returns the smallest value in @self.
+     *
+     * If `self` is empty, `G_MAXUINT` is returned.
+     */
     getMinimum() {
         return call("libgtk-4.so.1", "gtk_bitset_get_minimum", [
             {
@@ -169,6 +248,12 @@ export class Bitset {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Returns the value of the `nth` item in self.
+     *
+     * If `nth` is >= the size of @self, 0 is returned.
+     * @param nth - index of the item to get
+     */
     getNth(nth) {
         return call("libgtk-4.so.1", "gtk_bitset_get_nth", [
             {
@@ -181,6 +266,16 @@ export class Bitset {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the number of values that were added to the set.
+     *
+     * For example, if the set is empty, 0 is returned.
+     *
+     * Note that this function returns a `guint64`, because when all
+     * values are set, the return value is `G_MAXUINT + 1`. Unless you
+     * are sure this cannot happen (it can't with `GListModel`), be sure
+     * to use a 64bit type.
+     */
     getSize() {
         return call("libgtk-4.so.1", "gtk_bitset_get_size", [
             {
@@ -189,6 +284,15 @@ export class Bitset {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the number of values that are part of the set from `first` to `last` (inclusive).
+     *
+     * Note that this function returns a `guint64`, because when all values are
+     * set, the return value is `G_MAXUINT + 1`. Unless you are sure this cannot
+     * happen (it can't with `GListModel`), be sure to use a 64bit type.
+     * @param first - the first element to include
+     * @param last - the last element to include
+     */
     getSizeInRange(first, last) {
         return call("libgtk-4.so.1", "gtk_bitset_get_size_in_range", [
             {
@@ -205,6 +309,15 @@ export class Bitset {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Sets `self` to be the intersection of `self` and @other.
+     *
+     * In other words, remove all values from `self` that are not part of @other.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. Nothing will
+     * happen in that case.
+     * @param other - the `GtkBitset` to intersect with
+     */
     intersect(other) {
         call("libgtk-4.so.1", "gtk_bitset_intersect", [
             {
@@ -222,6 +335,9 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Check if no value is contained in bitset.
+     */
     isEmpty() {
         return call("libgtk-4.so.1", "gtk_bitset_is_empty", [
             {
@@ -230,6 +346,9 @@ export class Bitset {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Acquires a reference on the given `GtkBitset`.
+     */
     ref() {
         const ptr = call("libgtk-4.so.1", "gtk_bitset_ref", [
             {
@@ -244,6 +363,10 @@ export class Bitset {
         });
         return getObject(ptr, Bitset);
     }
+    /**
+     * Removes `value` from `self` if it was part of it before.
+     * @param value - value to remove
+     */
     remove(value) {
         return call("libgtk-4.so.1", "gtk_bitset_remove", [
             {
@@ -256,6 +379,9 @@ export class Bitset {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Removes all values from the bitset so that it is empty again.
+     */
     removeAll() {
         call("libgtk-4.so.1", "gtk_bitset_remove_all", [
             {
@@ -264,6 +390,12 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes all values from `start` (inclusive) to `start` + `n_items` (exclusive)
+     * in @self.
+     * @param start - first value to remove
+     * @param nItems - number of consecutive values to remove
+     */
     removeRange(start, nItems) {
         call("libgtk-4.so.1", "gtk_bitset_remove_range", [
             {
@@ -280,6 +412,12 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes the closed range [@first, @last], so @first, `last` and all
+     * values in between. `first` must be smaller than @last.
+     * @param first - first value to remove
+     * @param last - last value to remove
+     */
     removeRangeClosed(first, last) {
         call("libgtk-4.so.1", "gtk_bitset_remove_range_closed", [
             {
@@ -296,6 +434,13 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Interprets the values as a 2-dimensional boolean grid with the given `stride` and inside that grid, removes a rectangle with the given `width` and @height.
+     * @param start - first value to remove
+     * @param width - width of the rectangle
+     * @param height - height of the rectangle
+     * @param stride - row stride of the grid
+     */
     removeRectangle(start, width, height, stride) {
         call("libgtk-4.so.1", "gtk_bitset_remove_rectangle", [
             {
@@ -320,6 +465,12 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Shifts all values in `self` to the left by @amount.
+     *
+     * Values smaller than `amount` are discarded.
+     * @param amount - amount to shift all values to the left
+     */
     shiftLeft(amount) {
         call("libgtk-4.so.1", "gtk_bitset_shift_left", [
             {
@@ -332,6 +483,12 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Shifts all values in `self` to the right by @amount.
+     *
+     * Values that end up too large to be held in a #guint are discarded.
+     * @param amount - amount to shift all values to the right
+     */
     shiftRight(amount) {
         call("libgtk-4.so.1", "gtk_bitset_shift_right", [
             {
@@ -344,6 +501,21 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * This is a support function for `GListModel` handling, by mirroring
+     * the `GlistModel::items-changed` signal.
+     *
+     * First, it "cuts" the values from `position` to `removed` from
+     * the bitset. That is, it removes all those values and shifts
+     * all larger values to the left by `removed` places.
+     *
+     * Then, it "pastes" new room into the bitset by shifting all values
+     * larger than `position` by `added` spaces to the right. This frees
+     * up space that can then be filled.
+     * @param position - position at which to slice
+     * @param removed - number of values to remove
+     * @param added - number of values to add
+     */
     splice(position, removed, added) {
         call("libgtk-4.so.1", "gtk_bitset_splice", [
             {
@@ -364,6 +536,15 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `self` to be the subtraction of `other` from @self.
+     *
+     * In other words, remove all values from `self` that are part of @other.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. The bitset
+     * will be emptied in that case.
+     * @param other - the `GtkBitset` to subtract
+     */
     subtract(other) {
         call("libgtk-4.so.1", "gtk_bitset_subtract", [
             {
@@ -381,6 +562,15 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `self` to be the union of `self` and @other.
+     *
+     * That is, add all values from `other` into `self` that weren't part of it.
+     *
+     * It is allowed for `self` and `other` to be the same bitset. Nothing will
+     * happen in that case.
+     * @param other - the `GtkBitset` to union with
+     */
     union(other) {
         call("libgtk-4.so.1", "gtk_bitset_union", [
             {
@@ -398,6 +588,12 @@ export class Bitset {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Releases a reference on the given `GtkBitset`.
+     *
+     * If the reference was the last, the resources associated to the `self` are
+     * freed.
+     */
     unref() {
         call("libgtk-4.so.1", "gtk_bitset_unref", [
             {

package/dist/generated/gtk/bookmark-list.d.ts

@@ -1,13 +1,58 @@
 import * as GObject from "../gobject/index.js";
+/**
+ * A list model that wraps `GBookmarkFile`.
+ *
+ * It presents a `GListModel` and fills it asynchronously with the
+ * `GFileInfo`s returned from that function.
+ *
+ * The `GFileInfo`s in the list have some attributes in the recent
+ * namespace added: `recent::private` (boolean) and `recent:applications`
+ * (stringv).
+ */
 export declare class BookmarkList extends GObject.GObject {
+    /**
+     * Creates a new `GtkBookmarkList` with the given @attributes.
+     * @param filename - The bookmark file to load
+     * @param attributes - The attributes to query
+     */
     constructor(filename?: string | null, attributes?: string | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the attributes queried on the children.
+     */
     getAttributes(): string | null;
+    /**
+     * Returns the filename of the bookmark file that
+     * this list is loading.
+     */
     getFilename(): string;
+    /**
+     * Gets the IO priority to use while loading file.
+     */
     getIoPriority(): number;
+    /**
+     * Returns %TRUE if the files are currently being loaded.
+     *
+     * Files will be added to `self` from time to time while loading is
+     * going on. The order in which are added is undefined and may change
+     * in between runs.
+     */
     isLoading(): boolean;
+    /**
+     * Sets the `attributes` to be enumerated and starts the enumeration.
+     *
+     * If `attributes` is %NULL, no attributes will be queried, but a list
+     * of `GFileInfo`s will still be created.
+     * @param attributes - the attributes to enumerate
+     */
     setAttributes(attributes?: string | null): void;
+    /**
+     * Sets the IO priority to use while loading files.
+     *
+     * The default IO priority is %G_PRIORITY_DEFAULT.
+     * @param ioPriority - IO priority to use
+     */
     setIoPriority(ioPriority: number): void;
     connect(signal: "notify", handler: (self: BookmarkList, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;