@gtkx/ffi 0.9.4 → 0.10.1

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

@@ -0,0 +1,350 @@
+import { call } from "../../batch.js";
+import { getNativeObject } from "../../native/object.js";
+import { isInstantiating, setInstantiating } from "../../native/base.js";
+import { registerNativeClass } from "../../registry.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. */
+const SIGNAL_META = {
+    "items-changed": {
+        params: [
+            { type: "int", size: 32, unsigned: true },
+            { type: "int", size: 32, unsigned: true },
+            { type: "int", size: 32, unsigned: true },
+        ],
+        returnType: { type: "undefined" },
+    },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
+export class TreeListModel extends GObject.GObject {
+    static glibTypeName = "GtkTreeListModel";
+    static objectType = "gobject";
+    /**
+     * 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, passthrough, autoexpand, createFunc) {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            const _wrapped_createFunc = (...args) => {
+                const callbackArgs = args;
+                const types = [{ type: "gobject", borrowed: true }];
+                const wrapped = callbackArgs.map((arg, i) => {
+                    const t = types[i];
+                    if (t?.type === "gobject" && callbackArgs[i] != null) {
+                        return getNativeObject(arg);
+                    }
+                    return arg;
+                });
+                const result = createFunc(wrapped[0]);
+                return result != null ? (result.id ?? result) : null;
+            };
+            this.id = call("libgtk-4.so.1", "gtk_tree_list_model_new", [
+                {
+                    type: { type: "gobject" },
+                    value: root?.id ?? root,
+                },
+                {
+                    type: { type: "boolean" },
+                    value: passthrough,
+                },
+                {
+                    type: { type: "boolean" },
+                    value: autoexpand,
+                },
+                {
+                    type: {
+                        type: "callback",
+                        trampoline: "treeListModelCreateFunc",
+                        argTypes: [{ type: "gobject", borrowed: true }],
+                    },
+                    value: _wrapped_createFunc,
+                },
+            ], { type: "gobject", borrowed: false });
+        }
+        else {
+            // @ts-ignore
+            super();
+        }
+    }
+    /**
+     * 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 {@link Gtk.TreeListRow.set_expanded}.
+     */
+    getAutoexpand() {
+        return call("libgtk-4.so.1", "gtk_tree_list_model_get_autoexpand", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "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 {@link Gtk.TreeListModel.get_row}.
+     * @param position - position of the child to get
+     */
+    getChildRow(position) {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_list_model_get_child_row", [
+            {
+                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 getNativeObject(ptr);
+    }
+    /**
+     * Gets the root model that `self` was created with.
+     */
+    getModel() {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_list_model_get_model", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getNativeObject(ptr, 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
+     * {@link 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 {@link Gtk.TreeListModel.get_row}
+     * to get the custom `GtkTreeListRow`s.
+     */
+    getPassthrough() {
+        return call("libgtk-4.so.1", "gtk_tree_list_model_get_passthrough", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "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 {@link Gtk.TreeListModel.get_child_row}.
+     * @param position - the position of the row to fetch
+     */
+    getRow(position) {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_list_model_get_row", [
+            {
+                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 getNativeObject(ptr);
+    }
+    /**
+     * 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 {@link Gtk.TreeListRow.set_expanded}.
+     * @param autoexpand - %TRUE to make the model autoexpand its rows
+     */
+    setAutoexpand(autoexpand) {
+        call("libgtk-4.so.1", "gtk_tree_list_model_set_autoexpand", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "boolean" },
+                value: autoexpand,
+            },
+        ], { 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 getNativeObject(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" });
+    }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
+        const wrappedHandler = (...args) => {
+            const self = getNativeObject(args[0]);
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
+        };
+        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 });
+    }
+}
+registerNativeClass(TreeListModel);

package/dist/generated/gtk/tree-list-row-sorter.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
 /**
  * Applies a gives sorter to the levels in a tree.
@@ -22,6 +23,10 @@ const SIGNAL_META = {
         params: [{ type: "int", size: 32, unsigned: false }],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class TreeListRowSorter extends Sorter {
     static glibTypeName = "GtkTreeListRowSorter";
@@ -46,7 +51,7 @@ export class TreeListRowSorter extends Sorter {
                     value: sorter?.id ?? sorter,
                     optional: true,
                 },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -94,16 +99,20 @@ export class TreeListRowSorter extends Sorter {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -1,18 +1,5 @@
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
-/**
- * The type of item used by `GtkTreeListModel`.
- *
- * It allows navigating the model as a tree and modify the state of rows.
- *
- * `GtkTreeListRow` instances are created by a `GtkTreeListModel` only
- * when the {@link Gtk.TreeListModel.passthrough} property is not set.
- *
- * There are various support objects that can make use of `GtkTreeListRow`
- * objects, such as the {@link Gtk.TreeExpander} widget that allows displaying
- * an icon to expand or collapse a row or {@link Gtk.TreeListRowSorter} that
- * makes it possible to sort trees properly.
- */
 export declare class TreeListRow extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/tree-list-row.js

@@ -17,6 +17,12 @@ import * as Gio from "../gio/index.js";
  * an icon to expand or collapse a row or {@link Gtk.TreeListRowSorter} that
  * makes it possible to sort trees properly.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TreeListRow extends GObject.GObject {
     static glibTypeName = "GtkTreeListRow";
     static objectType = "gobject";
@@ -34,7 +40,7 @@ export class TreeListRow extends GObject.GObject {
             this.id = call("libgobject-2.0.so.0", "g_object_new", [
                 { type: { type: "int", size: 64, unsigned: true }, value: gtype },
                 { type: { type: "null" }, value: null },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -200,12 +206,26 @@ export class TreeListRow extends GObject.GObject {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -4,75 +4,6 @@ import { TreePath } from "./tree-path.js";
 import { TreeModel } from "./tree-model.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
-/**
- * A `GtkTreeModel` which hides parts of an underlying tree model
- *
- * A `GtkTreeModelFilter` is a tree model which wraps another tree model,
- * and can do the following things:
- *
- * - Filter specific rows, based on data from a “visible column”, a column
- * storing booleans indicating whether the row should be filtered or not,
- * or based on the return value of a “visible function”, which gets a
- * model, iter and user_data and returns a boolean indicating whether the
- * row should be filtered or not.
- *
- * - Modify the “appearance” of the model, using a modify function.
- * This is extremely powerful and allows for just changing some
- * values and also for creating a completely different model based
- * on the given child model.
- *
- * - Set a different root node, also known as a “virtual root”. You can pass
- * in a `GtkTreePath` indicating the root node for the filter at construction
- * time.
- *
- * The basic API is similar to `GtkTreeModelSort`. For an example on its usage,
- * see the section on `GtkTreeModelSort`.
- *
- * When using `GtkTreeModelFilter`, it is important to realize that
- * `GtkTreeModelFilter` maintains an internal cache of all nodes which are
- * visible in its clients. The cache is likely to be a subtree of the tree
- * exposed by the child model. `GtkTreeModelFilter` will not cache the entire
- * child model when unnecessary to not compromise the caching mechanism
- * that is exposed by the reference counting scheme. If the child model
- * implements reference counting, unnecessary signals may not be emitted
- * because of reference counting rule 3, see the `GtkTreeModel`
- * documentation. (Note that e.g. `GtkTreeStore` does not implement
- * reference counting and will always emit all signals, even when
- * the receiving node is not visible).
- *
- * Because of this, limitations for possible visible functions do apply.
- * In general, visible functions should only use data or properties from
- * the node for which the visibility state must be determined, its siblings
- * or its parents. Usually, having a dependency on the state of any child
- * node is not possible, unless references are taken on these explicitly.
- * When no such reference exists, no signals may be received for these child
- * nodes (see reference counting rule number 3 in the `GtkTreeModel` section).
- *
- * Determining the visibility state of a given node based on the state
- * of its child nodes is a frequently occurring use case. Therefore,
- * `GtkTreeModelFilter` explicitly supports this. For example, when a node
- * does not have any children, you might not want the node to be visible.
- * As soon as the first row is added to the node’s child level (or the
- * last row removed), the node’s visibility should be updated.
- *
- * This introduces a dependency from the node on its child nodes. In order
- * to accommodate this, `GtkTreeModelFilter` must make sure the necessary
- * signals are received from the child model. This is achieved by building,
- * for all nodes which are exposed as visible nodes to `GtkTreeModelFilter`'s
- * clients, the child level (if any) and take a reference on the first node
- * in this level. Furthermore, for every row-inserted, row-changed or
- * row-deleted signal (also these which were not handled because the node
- * was not cached), `GtkTreeModelFilter` will check if the visibility state
- * of any parent node has changed.
- *
- * Beware, however, that this explicit support is limited to these two
- * cases. For example, if you want a node to be visible only if two nodes
- * in a child’s child level (2 levels deeper) are visible, you are on your
- * own. In this case, either rely on `GtkTreeStore` to emit all signals
- * because it does not implement reference counting, or for models that
- * do implement reference counting, obtain references on these child levels
- * yourself.
- */
 export declare class TreeModelFilter extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -392,6 +323,11 @@ export declare class TreeModelFilter extends GObject.GObject {
      * @param iter - the `GtkTreeIter`
      */
     unrefNode(iter: TreeIter): void;
+    connect(signal: "row-changed", handler: (self: TreeModelFilter, path: TreePath, iter: TreeIter) => void, after?: boolean): number;
+    connect(signal: "row-deleted", handler: (self: TreeModelFilter, path: TreePath) => void, after?: boolean): number;
+    connect(signal: "row-has-child-toggled", handler: (self: TreeModelFilter, path: TreePath, iter: TreeIter) => void, after?: boolean): number;
+    connect(signal: "row-inserted", handler: (self: TreeModelFilter, path: TreePath, iter: TreeIter) => void, after?: boolean): number;
+    connect(signal: "rows-reordered", handler: (self: TreeModelFilter, path: TreePath, iter: TreeIter, newOrder: number) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: TreeModelFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }