@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -4,6 +4,104 @@ 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 makes an underlying tree model sortable
+ *
+ * The `GtkTreeModelSort` is a model which implements the `GtkTreeSortable`
+ * interface.  It does not hold any data itself, but rather is created with
+ * a child model and proxies its data.  It has identical column types to
+ * this child model, and the changes in the child are propagated.  The
+ * primary purpose of this model is to provide a way to sort a different
+ * model without modifying it. Note that the sort function used by
+ * `GtkTreeModelSort` is not guaranteed to be stable.
+ *
+ * The use of this is best demonstrated through an example.  In the
+ * following sample code we create two `GtkTreeView` widgets each with a
+ * view of the same data.  As the model is wrapped here by a
+ * `GtkTreeModelSort`, the two `GtkTreeView`s can each sort their
+ * view of the data without affecting the other.  By contrast, if we
+ * simply put the same model in each widget, then sorting the first would
+ * sort the second.
+ *
+ * ## Using a `GtkTreeModelSort`
+ *
+ * ```c
+ * {
+ * GtkTreeView *tree_view1;
+ * GtkTreeView *tree_view2;
+ * GtkTreeModel *sort_model1;
+ * GtkTreeModel *sort_model2;
+ * GtkTreeModel *child_model;
+ *
+ * // get the child model
+ * child_model = get_my_model ();
+ *
+ * // Create the first tree
+ * sort_model1 = gtk_tree_model_sort_new_with_model (child_model);
+ * tree_view1 = gtk_tree_view_new_with_model (sort_model1);
+ *
+ * // Create the second tree
+ * sort_model2 = gtk_tree_model_sort_new_with_model (child_model);
+ * tree_view2 = gtk_tree_view_new_with_model (sort_model2);
+ *
+ * // Now we can sort the two models independently
+ * gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model1),
+ * COLUMN_1, GTK_SORT_ASCENDING);
+ * gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model2),
+ * COLUMN_1, GTK_SORT_DESCENDING);
+ * }
+ * ```
+ *
+ * To demonstrate how to access the underlying child model from the sort
+ * model, the next example will be a callback for the `GtkTreeSelection`
+ * `GtkTreeSelection::changed` signal.  In this callback, we get a string
+ * from COLUMN_1 of the model.  We then modify the string, find the same
+ * selected row on the child model, and change the row there.
+ *
+ * ## Accessing the child model of in a selection changed callback
+ *
+ * ```c
+ * void
+ * selection_changed (GtkTreeSelection *selection, gpointer data)
+ * {
+ * GtkTreeModel *sort_model = NULL;
+ * GtkTreeModel *child_model;
+ * GtkTreeIter sort_iter;
+ * GtkTreeIter child_iter;
+ * char *some_data = NULL;
+ * char *modified_data;
+ *
+ * // Get the current selected row and the model.
+ * if (! gtk_tree_selection_get_selected (selection,
+ * &sort_model,
+ * &sort_iter))
+ * return;
+ *
+ * // Look up the current value on the selected row and get
+ * // a new value to change it to.
+ * gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &sort_iter,
+ * COLUMN_1, &some_data,
+ * -1);
+ *
+ * modified_data = change_the_data (some_data);
+ * g_free (some_data);
+ *
+ * // Get an iterator on the child model, instead of the sort model.
+ * gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sort_model),
+ * &child_iter,
+ * &sort_iter);
+ *
+ * // Get the child model and change the value of the row. In this
+ * // example, the child model is a GtkListStore. It could be any other
+ * // type of model, though.
+ * child_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model));
+ * gtk_list_store_set (GTK_LIST_STORE (child_model), &child_iter,
+ * COLUMN_1, &modified_data,
+ * -1);
+ * g_free (modified_data);
+ * }
+ * ```
+ */
 export class TreeModelSort extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -17,6 +115,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * This function should almost never be called.  It clears the `tree_model_sort` of any cached iterators that haven’t been reffed with
+     * gtk_tree_model_ref_node().  This might be useful if the child model being
+     * sorted is static (and doesn’t change often) and there has been a lot of
+     * unreffed access to nodes.  As a side effect of this function, all unreffed
+     * iters will be invalid.
+     */
     clearCache() {
         call("libgtk-4.so.1", "gtk_tree_model_sort_clear_cache", [
             {
@@ -25,6 +130,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `sort_iter` to point to the row in `tree_model_sort` that corresponds to
+     * the row pointed at by @child_iter.  If `sort_iter` was not set, %FALSE
+     * is returned.  Note: a boolean is only returned since 2.14.
+     * @param sortIter - An uninitialized `GtkTreeIter`
+     * @param childIter - A valid `GtkTreeIter` pointing to a row on the child model
+     */
     convertChildIterToIter(sortIter, childIter) {
         return call("libgtk-4.so.1", "gtk_tree_model_sort_convert_child_iter_to_iter", [
             {
@@ -53,6 +165,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Converts `child_path` to a path relative to @tree_model_sort.  That is,
+     * `child_path` points to a path in the child model.  The returned path will
+     * point to the same row in the sorted model.  If `child_path` isn’t a valid
+     * path on the child model, then %NULL is returned.
+     * @param childPath - A `GtkTreePath` to convert
+     */
     convertChildPathToPath(childPath) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_sort_convert_child_path_to_path", [
             {
@@ -78,6 +197,11 @@ export class TreeModelSort extends GObject.GObject {
             return null;
         return getObject(ptr, TreePath);
     }
+    /**
+     * Sets `child_iter` to point to the row pointed to by @sorted_iter.
+     * @param childIter - An uninitialized `GtkTreeIter`
+     * @param sortedIter - A valid `GtkTreeIter` pointing to a row on @tree_model_sort.
+     */
     convertIterToChildIter(childIter, sortedIter) {
         call("libgtk-4.so.1", "gtk_tree_model_sort_convert_iter_to_child_iter", [
             {
@@ -106,6 +230,14 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts `sorted_path` to a path on the child model of @tree_model_sort.
+     * That is, `sorted_path` points to a location in @tree_model_sort.  The
+     * returned path will point to the same location in the model not being
+     * sorted.  If `sorted_path` does not point to a location in the child model,
+     * %NULL is returned.
+     * @param sortedPath - A `GtkTreePath` to convert
+     */
     convertPathToChildPath(sortedPath) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_sort_convert_path_to_child_path", [
             {
@@ -131,6 +263,9 @@ export class TreeModelSort extends GObject.GObject {
             return null;
         return getObject(ptr, TreePath);
     }
+    /**
+     * Returns the model the `GtkTreeModelSort` is sorting.
+     */
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_sort_get_model", [
             {
@@ -140,6 +275,13 @@ export class TreeModelSort extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, TreeModel);
     }
+    /**
+     * > This function is slow. Only use it for debugging and/or testing
+     * > purposes.
+     *
+     * Checks if the given iter is a valid iter for this `GtkTreeModelSort`.
+     * @param iter - A `GtkTreeIter`
+     */
     iterIsValid(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_sort_iter_is_valid", [
             {
@@ -157,6 +299,12 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * This resets the default sort function to be in the “unsorted” state.  That
+     * is, it is in the same order as the child model. It will re-sort the model
+     * to be in the same order as the child model only if the `GtkTreeModelSort`
+     * is in “unsorted” state.
+     */
     resetDefaultSortFunc() {
         call("libgtk-4.so.1", "gtk_tree_model_sort_reset_default_sort_func", [
             {
@@ -165,6 +313,14 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asks the `GtkTreeDragSource` to delete the row at @path, because
+     * it was moved somewhere else via drag-and-drop. Returns %FALSE
+     * if the deletion fails because `path` no longer exists, or for
+     * some model-specific reason. Should robustly handle a `path` no
+     * longer found in the model!
+     * @param path - row that was being dragged
+     */
     dragDataDelete(path) {
         return call("libgtk-4.so.1", "gtk_tree_drag_source_drag_data_delete", [
             {
@@ -182,6 +338,12 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+     * the row at @path. Should robustly handle a `path` no
+     * longer found in the model!
+     * @param path - row that was dragged
+     */
     dragDataGet(path) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_drag_source_drag_data_get", [
             {
@@ -202,6 +364,12 @@ export class TreeModelSort extends GObject.GObject {
             return null;
         return getObject(ptr, Gdk.ContentProvider);
     }
+    /**
+     * Asks the `GtkTreeDragSource` whether a particular row can be used as
+     * the source of a DND operation. If the source doesn’t implement
+     * this interface, the row is assumed draggable.
+     * @param path - row on which user is initiating a drag
+     */
     rowDraggable(path) {
         return call("libgtk-4.so.1", "gtk_tree_drag_source_row_draggable", [
             {
@@ -219,6 +387,11 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates a new `GtkTreeModel`, with `child_model` as the child_model
+     * and `root` as the virtual root.
+     * @param root - A `GtkTreePath`
+     */
     filterNew(root) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_filter_new", [
             {
@@ -238,6 +411,14 @@ export class TreeModelSort extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, TreeModel);
     }
+    /**
+     * Calls `func` on each node in model in a depth-first fashion.
+     *
+     * If `func` returns %TRUE, then the tree ceases to be walked,
+     * and gtk_tree_model_foreach() returns.
+     * @param func - a function to be called on each row
+     * @param userData - user data to passed to @func
+     */
     foreach(func, userData) {
         call("libgtk-4.so.1", "gtk_tree_model_foreach", [
             {
@@ -255,6 +436,10 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the type of the column.
+     * @param index_ - the column index
+     */
     getColumnType(index_) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_column_type", [
             {
@@ -267,6 +452,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Returns a set of flags supported by this interface.
+     *
+     * The flags are a bitwise combination of `GtkTreeModel`Flags.
+     * The flags supported should not change during the lifetime
+     * of the @tree_model.
+     */
     getFlags() {
         return call("libgtk-4.so.1", "gtk_tree_model_get_flags", [
             {
@@ -275,6 +467,14 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets `iter` to a valid iterator pointing to @path.
+     *
+     * If `path` does not exist, `iter` is set to an invalid
+     * iterator and %FALSE is returned.
+     * @param iter - the uninitialized `GtkTreeIter`
+     * @param path - the `GtkTreePath`
+     */
     getIter(iter, path) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_iter", [
             {
@@ -303,6 +503,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Initializes `iter` with the first iterator in the tree
+     * (the one at the path "0").
+     *
+     * Returns %FALSE if the tree is empty, %TRUE otherwise.
+     * @param iter - the uninitialized `GtkTreeIter`
+     */
     getIterFirst(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_iter_first", [
             {
@@ -322,6 +529,14 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets `iter` to a valid iterator pointing to @path_string, if it
+     * exists.
+     *
+     * Otherwise, `iter` is left invalid and %FALSE is returned.
+     * @param iter - an uninitialized `GtkTreeIter`
+     * @param pathString - a string representation of a `GtkTreePath`
+     */
     getIterFromString(iter, pathString) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_iter_from_string", [
             {
@@ -345,6 +560,9 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the number of columns supported by @tree_model.
+     */
     getNColumns() {
         return call("libgtk-4.so.1", "gtk_tree_model_get_n_columns", [
             {
@@ -353,6 +571,12 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns a newly-created `GtkTreePath` referenced by @iter.
+     *
+     * This path should be freed with gtk_tree_path_free().
+     * @param iter - the `GtkTreeIter`
+     */
     getPath(iter) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_get_path", [
             {
@@ -376,6 +600,14 @@ export class TreeModelSort extends GObject.GObject {
         });
         return getObject(ptr, TreePath);
     }
+    /**
+     * Generates a string representation of the iter.
+     *
+     * This string is a “:” separated list of numbers.
+     * For example, “4:10:0:3” would be an acceptable
+     * return value for this string.
+     * @param iter - a `GtkTreeIter`
+     */
     getStringFromIter(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_string_from_iter", [
             {
@@ -393,6 +625,15 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "string" });
     }
+    /**
+     * Initializes and sets `value` to that at @column.
+     *
+     * When done with @value, g_value_unset() needs to be called
+     * to free any allocated memory.
+     * @param iter - the `GtkTreeIter`
+     * @param column - the column to lookup the value at
+     * @param value - an empty `GValue` to set
+     */
     getValue(iter, column, value) {
         call("libgtk-4.so.1", "gtk_tree_model_get_value", [
             {
@@ -425,6 +666,18 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `iter` to point to the first child of @parent.
+     *
+     * If `parent` has no children, %FALSE is returned and `iter` is
+     * set to be invalid. `parent` will remain a valid node after this
+     * function has been called.
+     *
+     * If `parent` is %NULL returns the first node, equivalent to
+     * `gtk_tree_model_get_iter_first (tree_model, iter);`
+     * @param iter - the new `GtkTreeIter` to be set to the child
+     * @param parent - the `GtkTreeIter`
+     */
     iterChildren(iter, parent) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_children", [
             {
@@ -454,6 +707,10 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if `iter` has children, %FALSE otherwise.
+     * @param iter - the `GtkTreeIter` to test for children
+     */
     iterHasChild(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_has_child", [
             {
@@ -471,6 +728,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the number of children that `iter` has.
+     *
+     * As a special case, if `iter` is %NULL, then the number
+     * of toplevel nodes is returned.
+     * @param iter - the `GtkTreeIter`
+     */
     iterNChildren(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_n_children", [
             {
@@ -489,6 +753,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets `iter` to point to the node following it at the current level.
+     *
+     * If there is no next @iter, %FALSE is returned and `iter` is set
+     * to be invalid.
+     * @param iter - the `GtkTreeIter`
+     */
     iterNext(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_next", [
             {
@@ -506,6 +777,17 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets `iter` to be the child of @parent, using the given index.
+     *
+     * The first index is 0. If `n` is too big, or `parent` has no children,
+     * `iter` is set to an invalid iterator and %FALSE is returned. `parent` will remain a valid node after this function has been called. As a
+     * special case, if `parent` is %NULL, then the @n-th root node
+     * is set.
+     * @param iter - the `GtkTreeIter` to set to the nth child
+     * @param parent - the `GtkTreeIter` to get the child from
+     * @param n - the index of the desired child
+     */
     iterNthChild(iter, n, parent) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_nth_child", [
             {
@@ -539,6 +821,18 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets `iter` to be the parent of @child.
+     *
+     * If `child` is at the toplevel, and doesn’t have a parent, then
+     * `iter` is set to an invalid iterator and %FALSE is returned.
+     * `child` will remain a valid node after this function has been
+     * called.
+     *
+     * `iter` will be initialized before the lookup is performed, so `child` and `iter` cannot point to the same memory location.
+     * @param iter - the new `GtkTreeIter` to set to the parent
+     * @param child - the `GtkTreeIter`
+     */
     iterParent(iter, child) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_parent", [
             {
@@ -567,6 +861,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets `iter` to point to the previous node at the current level.
+     *
+     * If there is no previous @iter, %FALSE is returned and `iter` is
+     * set to be invalid.
+     * @param iter - the `GtkTreeIter`
+     */
     iterPrevious(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_previous", [
             {
@@ -584,6 +885,26 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Lets the tree ref the node.
+     *
+     * This is an optional method for models to implement.
+     * To be more specific, models may ignore this call as it exists
+     * primarily for performance reasons.
+     *
+     * This function is primarily meant as a way for views to let
+     * caching models know when nodes are being displayed (and hence,
+     * whether or not to cache that node). Being displayed means a node
+     * is in an expanded branch, regardless of whether the node is currently
+     * visible in the viewport. For example, a file-system based model
+     * would not want to keep the entire file-hierarchy in memory,
+     * just the sections that are currently being displayed by
+     * every current view.
+     *
+     * A model should be expected to be able to get an iter independent
+     * of its reffed state.
+     * @param iter - the `GtkTreeIter`
+     */
     refNode(iter) {
         call("libgtk-4.so.1", "gtk_tree_model_ref_node", [
             {
@@ -601,6 +922,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the ::row-changed signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-changed].
+     * @param path - a `GtkTreePath` pointing to the changed row
+     * @param iter - a valid `GtkTreeIter` pointing to the changed row
+     */
     rowChanged(path, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_row_changed", [
             {
@@ -627,6 +955,19 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the ::row-deleted signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-deleted].
+     *
+     * This should be called by models after a row has been removed.
+     * The location pointed to by `path` should be the location that
+     * the row previously was at. It may not be a valid location anymore.
+     *
+     * Nodes that are deleted are not unreffed, this means that any
+     * outstanding references on the deleted node should not be released.
+     * @param path - a `GtkTreePath` pointing to the previous location of
+     */
     rowDeleted(path) {
         call("libgtk-4.so.1", "gtk_tree_model_row_deleted", [
             {
@@ -644,6 +985,16 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the ::row-has-child-toggled signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-has-child-toggled].
+     *
+     * This should be called by models after the child
+     * state of a node changes.
+     * @param path - a `GtkTreePath` pointing to the changed row
+     * @param iter - a valid `GtkTreeIter` pointing to the changed row
+     */
     rowHasChildToggled(path, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_row_has_child_toggled", [
             {
@@ -670,6 +1021,13 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the ::row-inserted signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-inserted].
+     * @param path - a `GtkTreePath` pointing to the inserted row
+     * @param iter - a valid `GtkTreeIter` pointing to the inserted row
+     */
     rowInserted(path, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_row_inserted", [
             {
@@ -696,6 +1054,18 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the ::rows-reordered signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::rows-reordered].
+     *
+     * This should be called by models when their rows have been
+     * reordered.
+     * @param path - a `GtkTreePath` pointing to the tree node whose children
+     * @param iter - a valid `GtkTreeIter` pointing to the node
+     * @param newOrder - an array of integers
+     * @param length - length of `new_order` array
+     */
     rowsReorderedWithLength(path, newOrder, length, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_rows_reordered_with_length", [
             {
@@ -734,6 +1104,17 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Lets the tree unref the node.
+     *
+     * This is an optional method for models to implement.
+     * To be more specific, models may ignore this call as it exists
+     * primarily for performance reasons. For more information on what
+     * this means, see gtk_tree_model_ref_node().
+     *
+     * Please note that nodes that are deleted are not unreffed.
+     * @param iter - the `GtkTreeIter`
+     */
     unrefNode(iter) {
         call("libgtk-4.so.1", "gtk_tree_model_unref_node", [
             {
@@ -751,6 +1132,14 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Fills in `sort_column_id` and `order` with the current sort column and the
+     * order. It returns %TRUE unless the `sort_column_id` is
+     * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+     * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+     * @param sortColumnId - The sort column id to be filled in
+     * @param order - The `GtkSortType` to be filled in
+     */
     getSortColumnId(sortColumnId, order) {
         return call("libgtk-4.so.1", "gtk_tree_sortable_get_sort_column_id", [
             {
@@ -773,6 +1162,11 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if the model has a default sort function. This is used
+     * primarily by GtkTreeViewColumns in order to determine if a model can
+     * go back to the default state, or not.
+     */
     hasDefaultSortFunc() {
         return call("libgtk-4.so.1", "gtk_tree_sortable_has_default_sort_func", [
             {
@@ -781,6 +1175,19 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets the default comparison function used when sorting to be @sort_func.
+     * If the current sort column id of `sortable` is
+     * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+     * this function.
+     *
+     * If `sort_func` is %NULL, then there will be no default comparison function.
+     * This means that once the model  has been sorted, it can’t go back to the
+     * default state. In this case, when the current sort column id of `sortable` is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+     * @param sortFunc - The comparison function
+     * @param userData - User data to pass to @sort_func
+     * @param destroy - Destroy notifier of @user_data
+     */
     setDefaultSortFunc(sortFunc, userData, destroy) {
         call("libgtk-4.so.1", "gtk_tree_sortable_set_default_sort_func", [
             {
@@ -803,6 +1210,19 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the current sort column to be @sort_column_id. The `sortable` will
+     * resort itself to reflect this change, after emitting a
+     * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+     * a regular column id, or one of the following special values:
+     *
+     * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+     * will be used, if it is set
+     *
+     * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+     * @param sortColumnId - the sort column id to set
+     * @param order - The sort order of the column
+     */
     setSortColumnId(sortColumnId, order) {
         call("libgtk-4.so.1", "gtk_tree_sortable_set_sort_column_id", [
             {
@@ -819,6 +1239,15 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the comparison function used when sorting to be @sort_func. If the
+     * current sort column id of `sortable` is the same as @sort_column_id, then
+     * the model will sort using this function.
+     * @param sortColumnId - the sort column id to set the function for
+     * @param sortFunc - The comparison function
+     * @param userData - User data to pass to @sort_func
+     * @param destroy - Destroy notifier of @user_data
+     */
     setSortFunc(sortColumnId, sortFunc, userData, destroy) {
         call("libgtk-4.so.1", "gtk_tree_sortable_set_sort_func", [
             {
@@ -845,6 +1274,9 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits a `GtkTreeSortable::sort-column-changed` signal on @sortable.
+     */
     sortColumnChanged() {
         call("libgtk-4.so.1", "gtk_tree_sortable_sort_column_changed", [
             {