@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gio/list-store.d.ts

@@ -1,22 +1,192 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GListStore` is a simple implementation of [iface@Gio.ListModel] that stores
+ * all items in memory.
+ *
+ * It provides insertions, deletions, and lookups in logarithmic time
+ * with a fast path for the common case of iterating the list linearly.
+ */
 export declare class ListStore extends GObject.GObject {
+    /**
+     * Creates a new #GListStore with items of type @item_type. `item_type` must be a subclass of #GObject.
+     * @param itemType - the #GType of items in the list
+     */
     constructor(itemType: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Appends `item` to @store. `item` must be of type #GListStore:item-type.
+     *
+     * This function takes a ref on @item.
+     *
+     * Use g_list_store_splice() to append multiple items at the same time
+     * efficiently.
+     * @param item - the new item
+     */
     append(item: GObject.GObject): void;
+    /**
+     * Looks up the given `item` in the list store by looping over the items until
+     * the first occurrence of @item. If `item` was not found, then `position` will
+     * not be set, and this method will return %FALSE.
+     *
+     * If you need to compare the two items with a custom comparison function, use
+     * g_list_store_find_with_equal_func() with a custom #GEqualFunc instead.
+     * @param item - an item
+     * @param position - the first position of @item, if it was found.
+     */
     find(item: GObject.GObject, position?: Ref<number> | null): boolean;
+    /**
+     * Looks up the given `item` in the list store by looping over the items and
+     * comparing them with `equal_func` until the first occurrence of `item` which
+     * matches. If `item` was not found, then `position` will not be set, and this
+     * method will return %FALSE.
+     *
+     * `item` is always passed as second parameter to @equal_func.
+     *
+     * Since GLib 2.76 it is possible to pass `NULL` for @item.
+     * @param item - an item
+     * @param equalFunc - A custom equality check function
+     * @param position - the first position of @item, if it was found.
+     */
     findWithEqualFunc(equalFunc: (...args: unknown[]) => unknown, item?: GObject.GObject | null, position?: Ref<number> | null): boolean;
+    /**
+     * Like g_list_store_find_with_equal_func() but with an additional `user_data` that is passed to @equal_func.
+     *
+     * `item` is always passed as second parameter to @equal_func.
+     *
+     * Since GLib 2.76 it is possible to pass `NULL` for @item.
+     * @param item - an item
+     * @param equalFunc - A custom equality check function
+     * @param userData - user data for @equal_func
+     * @param position - the first position of @item, if it was found.
+     */
     findWithEqualFuncFull(equalFunc: (...args: unknown[]) => unknown, item?: GObject.GObject | null, userData?: number | null, position?: Ref<number> | null): boolean;
+    /**
+     * Inserts `item` into `store` at @position. `item` must be of type
+     * #GListStore:item-type or derived from it. `position` must be smaller
+     * than the length of the list, or equal to it to append.
+     *
+     * This function takes a ref on @item.
+     *
+     * Use g_list_store_splice() to insert multiple items at the same time
+     * efficiently.
+     * @param position - the position at which to insert the new item
+     * @param item - the new item
+     */
     insert(position: number, item: GObject.GObject): void;
+    /**
+     * Inserts `item` into `store` at a position to be determined by the
+     * @compare_func.
+     *
+     * The list must already be sorted before calling this function or the
+     * result is undefined.  Usually you would approach this by only ever
+     * inserting items by way of this function.
+     *
+     * This function takes a ref on @item.
+     * @param item - the new item
+     * @param compareFunc - pairwise comparison function for sorting
+     * @param userData - user data for @compare_func
+     */
     insertSorted(item: GObject.GObject, compareFunc: (...args: unknown[]) => unknown, userData?: number | null): number;
+    /**
+     * Removes the item from `store` that is at @position. `position` must be
+     * smaller than the current length of the list.
+     *
+     * Use g_list_store_splice() to remove multiple items at the same time
+     * efficiently.
+     * @param position - the position of the item that is to be removed
+     */
     remove(position: number): void;
+    /**
+     * Removes all items from @store.
+     */
     removeAll(): void;
+    /**
+     * Sort the items in `store` according to @compare_func.
+     * @param compareFunc - pairwise comparison function for sorting
+     * @param userData - user data for @compare_func
+     */
     sort(compareFunc: (...args: unknown[]) => unknown, userData?: number | null): void;
+    /**
+     * Changes `store` by removing `n_removals` items and adding `n_additions` items to it. `additions` must contain `n_additions` items of type
+     * #GListStore:item-type.  %NULL is not permitted.
+     *
+     * This function is more efficient than g_list_store_insert() and
+     * g_list_store_remove(), because it only emits
+     * #GListModel::items-changed once for the change.
+     *
+     * This function takes a ref on each item in @additions.
+     *
+     * The parameters `position` and `n_removals` must be correct (ie:
+     * `position` + `n_removals` must be less than or equal to the length of
+     * the list at the time this function is called).
+     * @param position - the position at which to make the change
+     * @param nRemovals - the number of items to remove
+     * @param additions - the items to add
+     * @param nAdditions - the number of items to add
+     */
     splice(position: number, nRemovals: number, additions: GObject.GObject[], nAdditions: number): void;
+    /**
+     * Gets the type of the items in @list.
+     *
+     * All items returned from g_list_model_get_item() are of the type
+     * returned by this function, or a subtype, or if the type is an
+     * interface, they are an implementation of that interface.
+     *
+     * The item type of a #GListModel can not change during the life of the
+     * model.
+     */
     getItemType(): number;
+    /**
+     * Gets the number of items in @list.
+     *
+     * Depending on the model implementation, calling this function may be
+     * less efficient than iterating the list with increasing values for
+     * `position` until g_list_model_get_item() returns %NULL.
+     */
     getNItems(): number;
+    /**
+     * Get the item at @position.
+     *
+     * If `position` is greater than the number of items in @list, %NULL is
+     * returned.
+     *
+     * %NULL is never returned for an index that is smaller than the length
+     * of the list.
+     *
+     * This function is meant to be used by language bindings in place
+     * of g_list_model_get_item().
+     *
+     * See also: g_list_model_get_n_items()
+     * @param position - the position of the item to fetch
+     */
     getObject(position: number): GObject.GObject | null;
+    /**
+     * Emits the #GListModel::items-changed signal on @list.
+     *
+     * This function should only be called by classes implementing
+     * #GListModel. It has to be called after the internal representation
+     * of `list` has been updated, because handlers connected to this signal
+     * might query the new state of the list.
+     *
+     * Implementations must only make changes to the model (as visible to
+     * its consumer) in places that will not cause problems for that
+     * consumer.  For models that are driven directly by a write API (such
+     * as #GListStore), changes can be reported in response to uses of that
+     * API.  For models that represent remote data, changes should only be
+     * made from a fresh mainloop dispatch.  It is particularly not
+     * permitted to make changes in response to a call to the #GListModel
+     * consumer API.
+     *
+     * Stated another way: in general, it is assumed that code making a
+     * series of accesses to the model via the API, without returning to the
+     * mainloop, and without calling other code, will continue to view the
+     * same contents of the model.
+     * @param position - the position at which `list` changed
+     * @param removed - the number of items removed
+     * @param added - the number of items added
+     */
     itemsChanged(position: number, removed: number, added: number): void;
     connect(signal: "notify", handler: (self: ListStore, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/list-store.js

@@ -1,6 +1,13 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GListStore` is a simple implementation of [iface@Gio.ListModel] that stores
+ * all items in memory.
+ *
+ * It provides insertions, deletions, and lookups in logarithmic time
+ * with a fast path for the common case of iterating the list linearly.
+ */
 export class ListStore extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -14,6 +21,15 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Appends `item` to @store. `item` must be of type #GListStore:item-type.
+     *
+     * This function takes a ref on @item.
+     *
+     * Use g_list_store_splice() to append multiple items at the same time
+     * efficiently.
+     * @param item - the new item
+     */
     append(item) {
         call("libgio-2.0.so.0", "g_list_store_append", [
             {
@@ -26,6 +42,16 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Looks up the given `item` in the list store by looping over the items until
+     * the first occurrence of @item. If `item` was not found, then `position` will
+     * not be set, and this method will return %FALSE.
+     *
+     * If you need to compare the two items with a custom comparison function, use
+     * g_list_store_find_with_equal_func() with a custom #GEqualFunc instead.
+     * @param item - an item
+     * @param position - the first position of @item, if it was found.
+     */
     find(item, position) {
         return call("libgio-2.0.so.0", "g_list_store_find", [
             {
@@ -46,6 +72,19 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Looks up the given `item` in the list store by looping over the items and
+     * comparing them with `equal_func` until the first occurrence of `item` which
+     * matches. If `item` was not found, then `position` will not be set, and this
+     * method will return %FALSE.
+     *
+     * `item` is always passed as second parameter to @equal_func.
+     *
+     * Since GLib 2.76 it is possible to pass `NULL` for @item.
+     * @param item - an item
+     * @param equalFunc - A custom equality check function
+     * @param position - the first position of @item, if it was found.
+     */
     findWithEqualFunc(equalFunc, item, position) {
         return call("libgio-2.0.so.0", "g_list_store_find_with_equal_func", [
             {
@@ -71,6 +110,17 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Like g_list_store_find_with_equal_func() but with an additional `user_data` that is passed to @equal_func.
+     *
+     * `item` is always passed as second parameter to @equal_func.
+     *
+     * Since GLib 2.76 it is possible to pass `NULL` for @item.
+     * @param item - an item
+     * @param equalFunc - A custom equality check function
+     * @param userData - user data for @equal_func
+     * @param position - the first position of @item, if it was found.
+     */
     findWithEqualFuncFull(equalFunc, item, userData, position) {
         return call("libgio-2.0.so.0", "g_list_store_find_with_equal_func_full", [
             {
@@ -101,6 +151,18 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Inserts `item` into `store` at @position. `item` must be of type
+     * #GListStore:item-type or derived from it. `position` must be smaller
+     * than the length of the list, or equal to it to append.
+     *
+     * This function takes a ref on @item.
+     *
+     * Use g_list_store_splice() to insert multiple items at the same time
+     * efficiently.
+     * @param position - the position at which to insert the new item
+     * @param item - the new item
+     */
     insert(position, item) {
         call("libgio-2.0.so.0", "g_list_store_insert", [
             {
@@ -117,6 +179,19 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Inserts `item` into `store` at a position to be determined by the
+     * @compare_func.
+     *
+     * The list must already be sorted before calling this function or the
+     * result is undefined.  Usually you would approach this by only ever
+     * inserting items by way of this function.
+     *
+     * This function takes a ref on @item.
+     * @param item - the new item
+     * @param compareFunc - pairwise comparison function for sorting
+     * @param userData - user data for @compare_func
+     */
     insertSorted(item, compareFunc, userData) {
         return call("libgio-2.0.so.0", "g_list_store_insert_sorted", [
             {
@@ -138,6 +213,14 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Removes the item from `store` that is at @position. `position` must be
+     * smaller than the current length of the list.
+     *
+     * Use g_list_store_splice() to remove multiple items at the same time
+     * efficiently.
+     * @param position - the position of the item that is to be removed
+     */
     remove(position) {
         call("libgio-2.0.so.0", "g_list_store_remove", [
             {
@@ -150,6 +233,9 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes all items from @store.
+     */
     removeAll() {
         call("libgio-2.0.so.0", "g_list_store_remove_all", [
             {
@@ -158,6 +244,11 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sort the items in `store` according to @compare_func.
+     * @param compareFunc - pairwise comparison function for sorting
+     * @param userData - user data for @compare_func
+     */
     sort(compareFunc, userData) {
         call("libgio-2.0.so.0", "g_list_store_sort", [
             {
@@ -175,6 +266,24 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes `store` by removing `n_removals` items and adding `n_additions` items to it. `additions` must contain `n_additions` items of type
+     * #GListStore:item-type.  %NULL is not permitted.
+     *
+     * This function is more efficient than g_list_store_insert() and
+     * g_list_store_remove(), because it only emits
+     * #GListModel::items-changed once for the change.
+     *
+     * This function takes a ref on each item in @additions.
+     *
+     * The parameters `position` and `n_removals` must be correct (ie:
+     * `position` + `n_removals` must be less than or equal to the length of
+     * the list at the time this function is called).
+     * @param position - the position at which to make the change
+     * @param nRemovals - the number of items to remove
+     * @param additions - the items to add
+     * @param nAdditions - the number of items to add
+     */
     splice(position, nRemovals, additions, nAdditions) {
         call("libgio-2.0.so.0", "g_list_store_splice", [
             {
@@ -199,6 +308,16 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the type of the items in @list.
+     *
+     * All items returned from g_list_model_get_item() are of the type
+     * returned by this function, or a subtype, or if the type is an
+     * interface, they are an implementation of that interface.
+     *
+     * The item type of a #GListModel can not change during the life of the
+     * model.
+     */
     getItemType() {
         return call("libgio-2.0.so.0", "g_list_model_get_item_type", [
             {
@@ -207,6 +326,13 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the number of items in @list.
+     *
+     * Depending on the model implementation, calling this function may be
+     * less efficient than iterating the list with increasing values for
+     * `position` until g_list_model_get_item() returns %NULL.
+     */
     getNItems() {
         return call("libgio-2.0.so.0", "g_list_model_get_n_items", [
             {
@@ -215,6 +341,21 @@ export class ListStore extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Get the item at @position.
+     *
+     * If `position` is greater than the number of items in @list, %NULL is
+     * returned.
+     *
+     * %NULL is never returned for an index that is smaller than the length
+     * of the list.
+     *
+     * This function is meant to be used by language bindings in place
+     * of g_list_model_get_item().
+     *
+     * See also: g_list_model_get_n_items()
+     * @param position - the position of the item to fetch
+     */
     getObject(position) {
         const ptr = call("libgio-2.0.so.0", "g_list_model_get_object", [
             {
@@ -230,6 +371,31 @@ export class ListStore extends GObject.GObject {
             return null;
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Emits the #GListModel::items-changed signal on @list.
+     *
+     * This function should only be called by classes implementing
+     * #GListModel. It has to be called after the internal representation
+     * of `list` has been updated, because handlers connected to this signal
+     * might query the new state of the list.
+     *
+     * Implementations must only make changes to the model (as visible to
+     * its consumer) in places that will not cause problems for that
+     * consumer.  For models that are driven directly by a write API (such
+     * as #GListStore), changes can be reported in response to uses of that
+     * API.  For models that represent remote data, changes should only be
+     * made from a fresh mainloop dispatch.  It is particularly not
+     * permitted to make changes in response to a call to the #GListModel
+     * consumer API.
+     *
+     * Stated another way: in general, it is assumed that code making a
+     * series of accesses to the model via the API, without returning to the
+     * mainloop, and without calling other code, will continue to view the
+     * same contents of the model.
+     * @param position - the position at which `list` changed
+     * @param removed - the number of items removed
+     * @param added - the number of items added
+     */
     itemsChanged(position, removed, added) {
         call("libgio-2.0.so.0", "g_list_model_items_changed", [
             {

package/dist/generated/gio/loadable-icon.d.ts

@@ -2,11 +2,36 @@ import { Ref } from "@gtkx/native";
 import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { InputStream } from "./input-stream.js";
+/**
+ * `GLoadableIcon` extends the [iface@Gio.Icon] interface and adds the ability
+ * to load icons from streams.
+ */
 export declare class LoadableIcon {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): LoadableIcon;
+    /**
+     * Loads a loadable icon. For the asynchronous version of this function,
+     * see g_loadable_icon_load_async().
+     * @param size - an integer.
+     * @param type - a location to store the type of the loaded
+     * @param cancellable - optional #GCancellable object, %NULL to
+     */
     load(size: number, type?: Ref<string> | null, cancellable?: Cancellable | null): InputStream;
+    /**
+     * Loads an icon asynchronously. To finish this function, see
+     * g_loadable_icon_load_finish(). For the synchronous, blocking
+     * version of this function, see g_loadable_icon_load().
+     * @param size - an integer.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     loadAsync(size: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+     * @param res - a #GAsyncResult.
+     * @param type - a location to store the type of the loaded
+     */
     loadFinish(res: AsyncResult, type?: Ref<string> | null): InputStream;
 }

package/dist/generated/gio/loadable-icon.js

@@ -1,6 +1,10 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { InputStream } from "./input-stream.js";
+/**
+ * `GLoadableIcon` extends the [iface@Gio.Icon] interface and adds the ability
+ * to load icons from streams.
+ */
 export class LoadableIcon {
     ptr;
     constructor(ptr) {
@@ -9,6 +13,13 @@ export class LoadableIcon {
     static fromPtr(ptr) {
         return new LoadableIcon(ptr);
     }
+    /**
+     * Loads a loadable icon. For the asynchronous version of this function,
+     * see g_loadable_icon_load_async().
+     * @param size - an integer.
+     * @param type - a location to store the type of the loaded
+     * @param cancellable - optional #GCancellable object, %NULL to
+     */
     load(size, type, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_loadable_icon_load", [
@@ -47,6 +58,15 @@ export class LoadableIcon {
         }
         return getObject(ptr, InputStream);
     }
+    /**
+     * Loads an icon asynchronously. To finish this function, see
+     * g_loadable_icon_load_finish(). For the synchronous, blocking
+     * version of this function, see g_loadable_icon_load().
+     * @param size - an integer.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     loadAsync(size, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_loadable_icon_load_async", [
             {
@@ -74,6 +94,11 @@ export class LoadableIcon {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+     * @param res - a #GAsyncResult.
+     * @param type - a location to store the type of the loaded
+     */
     loadFinish(res, type) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_loadable_icon_load_finish", [