@gtkx/ffi 0.8.0 → 0.9.0

package/dist/generated/gtk/map-list-model.js

@@ -1,361 +0,0 @@
-import { call } from "../../batch.js";
-import { getObject, getInterface, isInstantiating, setInstantiating, } from "../../native.js";
-import { registerType } from "../../registry.js";
-import * as GObject from "../gobject/index.js";
-import * as Gio from "../gio/index.js";
-/**
- * A list model that maps the items in another model to different items.
- *
- * `GtkMapListModel` uses a [callback@Gtk.MapListModelMapFunc].
- *
- * Example: Create a list of `GtkEventControllers`
- * ```c
- * static gpointer
- * map_to_controllers (gpointer widget,
- * gpointer data)
- * {
- * gpointer result = gtk_widget_observe_controllers (widget);
- * g_object_unref (widget);
- * return result;
- * }
- *
- * widgets = gtk_widget_observe_children (widget);
- *
- * controllers = gtk_map_list_model_new (widgets,
- * map_to_controllers,
- * NULL, NULL);
- *
- * model = gtk_flatten_list_model_new (GTK_TYPE_EVENT_CONTROLLER,
- * controllers);
- * ```
- *
- * `GtkMapListModel` will attempt to discard the mapped objects as soon as
- * they are no longer needed and recreate them if necessary.
- *
- * `GtkMapListModel` passes through sections from the underlying model.
- */
-export class MapListModel extends GObject.GObject {
-    static glibTypeName = "GtkMapListModel";
-    /**
-     * Creates a new `GtkMapListModel` for the given arguments.
-     * @param model - The model to map
-     * @param mapFunc - map function
-     * @param userData - user data passed to @map_func
-     * @param userDestroy - destroy notifier for @user_data
-     */
-    constructor(userDestroy, model, mapFunc, userData) {
-        if (!isInstantiating) {
-            setInstantiating(true);
-            // @ts-ignore
-            super();
-            setInstantiating(false);
-            this.id = call("libgtk-4.so.1", "gtk_map_list_model_new", [
-                {
-                    type: { type: "gobject" },
-                    value: model?.id ?? model,
-                    optional: true,
-                },
-                {
-                    type: { type: "callback" },
-                    value: mapFunc,
-                    optional: true,
-                },
-                {
-                    type: { type: "int", size: 64, unsigned: true },
-                    value: userData,
-                    optional: true,
-                },
-                {
-                    type: { type: "callback", trampoline: "destroy" },
-                    value: userDestroy,
-                },
-            ], { type: "gobject", borrowed: true });
-        }
-        else {
-            // @ts-ignore
-            super();
-        }
-    }
-    /**
-     * Gets the model that is currently being mapped or %NULL if none.
-     */
-    getModel() {
-        const ptr = call("libgtk-4.so.1", "gtk_map_list_model_get_model", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-        ], { type: "gobject", borrowed: true });
-        if (ptr === null)
-            return null;
-        return getInterface(ptr, Gio.ListModel);
-    }
-    /**
-     * Checks if a map function is currently set on @self.
-     */
-    hasMap() {
-        return call("libgtk-4.so.1", "gtk_map_list_model_has_map", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-        ], { type: "boolean" });
-    }
-    /**
-     * Sets the function used to map items.
-     *
-     * The function will be called whenever an item needs to be mapped
-     * and must return the item to use for the given input item.
-     *
-     * Note that `GtkMapListModel` may call this function multiple times
-     * on the same item, because it may delete items it doesn't need anymore.
-     *
-     * GTK makes no effort to ensure that `map_func` conforms to the item type
-     * of @self. It assumes that the caller knows what they are doing and the map
-     * function returns items of the appropriate type.
-     * @param mapFunc - map function
-     * @param userData - user data passed to @map_func
-     * @param userDestroy - destroy notifier for @user_data
-     */
-    setMapFunc(userDestroy, mapFunc, userData) {
-        call("libgtk-4.so.1", "gtk_map_list_model_set_map_func", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: mapFunc,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: userDestroy,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * Sets the model to be mapped.
-     *
-     * GTK makes no effort to ensure that `model` conforms to the item type
-     * expected by the map function. It assumes that the caller knows what
-     * they are doing and have set up an appropriate map function.
-     * @param model - The model to be mapped
-     */
-    setModel(model) {
-        call("libgtk-4.so.1", "gtk_map_list_model_set_model", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: model?.id ?? model,
-                optional: true,
-            },
-        ], { 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("libgtk-4.so.1", "g_list_model_get_item_type", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-        ], { 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("libgtk-4.so.1", "g_list_model_get_n_items", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-        ], { 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("libgtk-4.so.1", "g_list_model_get_object", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: position,
-            },
-        ], { type: "gobject", borrowed: true });
-        if (ptr === null)
-            return null;
-        return getObject(ptr);
-    }
-    /**
-     * 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("libgtk-4.so.1", "g_list_model_items_changed", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: position,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: removed,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: added,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * Query the section that covers the given position. The number of
-     * items in the section can be computed by `out_end - out_start`.
-     *
-     * If the position is larger than the number of items, a single
-     * range from n_items to G_MAXUINT will be returned.
-     * @param position - the position of the item to query
-     * @param outStart - the position of the first item in the section
-     * @param outEnd - the position of the first item not part of the section
-     */
-    getSection(position, outStart, outEnd) {
-        call("libgtk-4.so.1", "gtk_section_model_get_section", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: position,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: true },
-                },
-                value: outStart,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: true },
-                },
-                value: outEnd,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * This function emits the [signal@Gtk.SectionModel::sections-changed]
-     * signal to notify about changes to sections.
-     *
-     * It must cover all positions that used to be a section start or that
-     * are now a section start. It does not have to cover all positions for
-     * which the section has changed.
-     *
-     * The [signal@Gio.ListModel::items-changed] implies the effect of the
-     * [signal@Gtk.SectionModel::sections-changed] signal for all the items
-     * it covers.
-     *
-     * It is recommended that when changes to the items cause section changes
-     * in a larger range, that the larger range is included in the emission
-     * of the [signal@Gio.ListModel::items-changed] instead of emitting
-     * two signals.
-     * @param position - the first changed item
-     * @param nItems - the number of changed items
-     */
-    sectionsChanged(position, nItems) {
-        call("libgtk-4.so.1", "gtk_section_model_sections_changed", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: position,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: nItems,
-            },
-        ], { type: "undefined" });
-    }
-    connect(signal, handler, after = false) {
-        const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
-        const wrappedHandler = (...args) => {
-            const self = getObject(args[0]);
-            return handler(self, ...args.slice(1));
-        };
-        return call("libgtk-4.so.1", "g_signal_connect_closure", [
-            { type: { type: "gobject" }, value: this.id },
-            { type: { type: "string" }, value: signal },
-            {
-                type: { type: "callback", argTypes, returnType },
-                value: wrappedHandler,
-            },
-            { type: { type: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
-    }
-}
-registerType(MapListModel);

package/dist/generated/gtk/tree-list-model.d.ts

@@ -1,145 +0,0 @@
-import { TreeListRow } from "./tree-list-row.js";
-import * as GObject from "../gobject/index.js";
-import * as Gio from "../gio/index.js";
-/** A list model that can create child models on demand. */
-export declare class TreeListModel extends GObject.GObject {
-    static readonly glibTypeName: string;
-    /**
-     * Creates a new empty `GtkTreeListModel` displaying `root` with all rows collapsed.
-     * @param root - The `GListModel` to use as root
-     * @param passthrough - %TRUE to pass through items from the models
-     * @param autoexpand - %TRUE to set the autoexpand property and expand the `root` model
-     * @param createFunc - function to
-     * @param userData - Data to pass to @create_func
-     * @param userDestroy - Function to call to free @user_data
-     */
-    constructor(root: Gio.ListModel, passthrough: boolean, autoexpand: boolean, createFunc: (...args: unknown[]) => unknown, userDestroy: () => void, userData?: number | null);
-    /**
-     * Gets whether the model is set to automatically expand new rows
-     * that get added.
-     *
-     * This can be either rows added by changes to the underlying
-     * models or via [method@Gtk.TreeListRow.set_expanded].
-     */
-    getAutoexpand(): boolean;
-    /**
-     * Gets the row item corresponding to the child at index `position` for
-     * @self's root model.
-     *
-     * If `position` is greater than the number of children in the root model,
-     * %NULL is returned.
-     *
-     * Do not confuse this function with [method@Gtk.TreeListModel.get_row].
-     * @param position - position of the child to get
-     */
-    getChildRow(position: number): TreeListRow | null;
-    /**
-     * Gets the root model that `self` was created with.
-     */
-    getModel(): Gio.ListModel;
-    /**
-     * Gets whether the model is passing through original row items.
-     *
-     * If this function returns %FALSE, the `GListModel` functions for `self` return custom `GtkTreeListRow` objects. You need to call
-     * [method@Gtk.TreeListRow.get_item] on these objects to get the original
-     * item.
-     *
-     * If %TRUE, the values of the child models are passed through in their
-     * original state. You then need to call [method@Gtk.TreeListModel.get_row]
-     * to get the custom `GtkTreeListRow`s.
-     */
-    getPassthrough(): boolean;
-    /**
-     * Gets the row object for the given row.
-     *
-     * If `position` is greater than the number of items in @self,
-     * %NULL is returned.
-     *
-     * The row object can be used to expand and collapse rows as
-     * well as to inspect its position in the tree. See its
-     * documentation for details.
-     *
-     * This row object is persistent and will refer to the current
-     * item as long as the row is present in @self, independent of
-     * other rows being added or removed.
-     *
-     * If `self` is set to not be passthrough, this function is
-     * equivalent to calling g_list_model_get_item().
-     *
-     * Do not confuse this function with [method@Gtk.TreeListModel.get_child_row].
-     * @param position - the position of the row to fetch
-     */
-    getRow(position: number): TreeListRow | null;
-    /**
-     * Sets whether the model should autoexpand.
-     *
-     * If set to %TRUE, the model will recursively expand all rows that
-     * get added to the model. This can be either rows added by changes
-     * to the underlying models or via [method@Gtk.TreeListRow.set_expanded].
-     * @param autoexpand - %TRUE to make the model autoexpand its rows
-     */
-    setAutoexpand(autoexpand: boolean): 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: TreeListModel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
-    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
-}