[79:7] extends: object
A list-like data structure that can be used with the [class@Gtk.TreeView].
The GtkListStore object is a list model for use with a GtkTreeView
widget. It implements the GtkTreeModel interface, and consequentialy, can
use all of the methods available there. It also implements the
GtkTreeSortable interface so it can be sorted by the view. Finally, it also
implements the tree drag and
drop interfaces. The GtkListStore can accept
most GTypes as a column type, though it can’t accept all custom types.
Internally, it will keep a copy of data passed in (such as a string or a
boxed pointer). Columns that accept GObjects are handled a little
differently. The GtkListStore will keep a reference to the object instead
of copying the value. As a result, if the object is modified, it is up to the
application writer to call [method@Gtk.TreeModel.row_changed] to emit the
[signal@Gtk.TreeModel::row_changed] signal. This most commonly affects lists
with [class@Gdk.Texture]s stored. An example for creating a simple list
store: c enum { COLUMN_STRING, COLUMN_INT, COLUMN_BOOLEAN, N_COLUMNS }; { GtkListStore *list_store; GtkTreePath *path; GtkTreeIter iter; int i; list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN); for (i = 0; i < 10; i++) { char *some_data; some_data = get_some_data (i); // Add a new row to the model gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_STRING, some_data, COLUMN_INT, i, COLUMN_BOOLEAN, FALSE, -1); // As the store will keep a copy of the string internally, // we free some_data. g_free (some_data); } // Modify a particular row path = gtk_tree_path_new_from_string ("4"); gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store), &iter, path); gtk_tree_path_free (path); gtk_list_store_set (list_store, &iter, COLUMN_BOOLEAN, TRUE, -1); } GtkListStore is
deprecated since GTK 4.10, and should not be used in newly written code. You
should use [class@Gio.ListStore] instead, and the various list models
provided by GTK. ## Performance Considerations Internally, the GtkListStore
was originally implemented with a linked list with a tail pointer. As a
result, it was fast at data insertion and deletion, and not fast at random
data access. The GtkListStore sets the GTK_TREE_MODEL_ITERS_PERSIST flag,
which means that GtkTreeIters can be cached while the row exists. Thus, if
access to a particular row is needed often and your code is expected to run
on older versions of GTK, it is worth keeping the iter around. ## Atomic
Operations It is important to note that only the methods
gtk_list_store_insert_with_values() and gtk_list_store_insert_with_valuesv()
are atomic, in the sense that the row is being appended to the store and the
values filled in in a single operation with regard to GtkTreeModel
signaling. In contrast, using e.g. gtk_list_store_append() and then
gtk_list_store_set() will first create a row, which triggers the
GtkTreeModel::row-inserted signal on GtkListStore. The row, however, is
still empty, and any signal handler connecting to
GtkTreeModel::row-inserted on this particular store should be prepared for
the situation that the row might be empty. This is especially important if
you are wrapping the GtkListStore inside a GtkTreeModelFilter and are
using a GtkTreeModelFilterVisibleFunc. Using any of the non-atomic
operations to append rows to the GtkListStore will cause the
GtkTreeModelFilterVisibleFunc to be visited with an empty row first; the
function must be prepared for that. ## GtkListStore as GtkBuildable The
GtkListStore implementation of the [iface@Gtk.Buildable] interface allows to
specify the model columns with a <columns> element that may contain
multiple <column> elements, each specifying one model column. The “type”
attribute specifies the data type for the column. Additionally, it is
possible to specify content for the list store in the UI definition, with the
<data> element. It can contain multiple <row> elements, each specifying
to content for one row of the list model. Inside a <row>, the <col>
elements specify the content for individual cells. Note that it is probably
more common to define your models in the code, and one might consider it a
layering violation to specify the content of a list store in a UI definition,
data, not presentation, and common wisdom is to separate the two, as far as
possible. An example of a UI Definition fragment for a list store: ```xml
GtkListStore (n_columns = null, ___ = null)
Creates a new list store. The list store will have @n_columns columns, with each column using the given type passed to this function. Note that only types derived from standard GObject fundamental types are supported. As an example:
c gtk_list_store_new (3, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_TEXTURE);will create a newGtkListStorewith three columns, of typeint,gchararrayandGdkTexture, respectively.
n_columns is number of columns in the list store.___ is all GType types for the columns, from first to last.toNativeHandle (Source)
Normalizes a constructor argument into a raw pointer carrier. Accepts a raw NativeHandle, a raw NativeBuffer returned from
fn.call(...), another generated wrapper exposinghandle(), or null. Returns null when the argument carries no pointer.
Source is the raw handle, raw buffer, wrapper, or null.A raw pointer carrier or null when no pointer is present.getLib ()
Returns the opened native library for this generated wrapper.
The opened native library.handle ()
Returns the wrapped NativeHandle.
The wrapped NativeHandle.isNull ()
Returns true when the wrapped handle is null.
A bool.describe ()
Returns a small string for debugging generated wrappers.
A string.asObject ()
Wraps this handle as
GObject.
A GObject object.asBuildable ()
Wraps this handle as
GtkBuildable.
A GtkBuildable object.asTreeDragDest ()
Wraps this handle as
GtkTreeDragDest.
A GtkTreeDragDest object.asTreeDragSource ()
Wraps this handle as
GtkTreeDragSource.
A GtkTreeDragSource object.asTreeModel ()
Wraps this handle as
GtkTreeModel.
A GtkTreeModel object.asTreeSortable ()
Wraps this handle as
GtkTreeSortable.
A GtkTreeSortable object.append ()
Appends a new row to @list_store. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
iter is An unset GtkTreeIter to set to the appended row.None.clear ()
Removes all rows from the list store.
None.insert (int position)
Creates a new row at @position. @iter will be changed to point to this new row. If @position is -1 or is larger than the number of rows on the list, then the new row will be appended to the list. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
iter is An unset GtkTreeIter to set to the new row.position is position to insert the new row, or -1 for last.None.insert_after (object sibling)
Inserts a new row after @sibling. If @sibling is %NULL, then the row will be prepended to the beginning of the list. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
iter is An unset GtkTreeIter to set to the new row.sibling is A valid GtkTreeIter.None.insert_before (object sibling)
Inserts a new row before @sibling. If @sibling is %NULL, then the row will be appended to the end of the list. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
iter is An unset GtkTreeIter to set to the new row.sibling is A valid GtkTreeIter.None.insert_with_values (int position, list varargs)
Creates a new row at @position. @iter will be changed to point to this new row. If @position is -1, or larger than the number of rows in the list, then the new row will be appended to the list. The row will be filled with the values given to this function. Calling
gtk_list_store_insert_with_values (list_store, iter, position...)has the same effect as calling:c static void insert_value (GtkListStore *list_store, GtkTreeIter *iter, int position) { gtk_list_store_insert (list_store, iter, position); gtk_list_store_set (list_store, iter // ... ); }with the difference that the former will only emitGtkTreeModel::row-inserted once, while the latter will emitGtkTreeModel::row-inserted,GtkTreeModel::row-changed and, if the list store is sorted,GtkTreeModel::rows-reordered for every inserted value. Since emitting theGtkTreeModel::rows-reorderedsignal repeatedly can affect the performance of the program, gtk_list_store_insert_with_values() should generally be preferred when inserting rows in a sorted list store.
iter is An unset GtkTreeIter to set to the new row.position is position to insert the new row, or -1 to append after existing rows.... is pairs of column number and value, terminated with -1.None.insert_with_valuesv (int position, list columns, list values)
A variant of gtk_list_store_insert_with_values() which takes the columns and values as two arrays, instead of varargs. This function is mainly intended for language-bindings.
iter is An unset GtkTreeIter to set to the new row.position is position to insert the new row, or -1 for last.columns is an array of column numbers.values is an array of GValues.n_values is the length of the @columns and @values arrays.None.iter_is_valid (object iter)
Checks if the given iter is a valid iter for this
GtkListStore. This function is slow. Only use it for debugging and/or testing purposes.
iter is the iterator to check.%TRUE if the iter is valid, %FALSE if the iter is invalid..move_after (object iter, object position)
Moves @iter in @store to the position after @position. Note that this function only works with unsorted stores. If @position is %NULL, @iter will be moved to the start of the list.
iter is A GtkTreeIter.position is A GtkTreeIter.None.move_before (object iter, object position)
Moves @iter in @store to the position before @position. Note that this function only works with unsorted stores. If @position is %NULL, @iter will be moved to the end of the list.
iter is A GtkTreeIter.position is A GtkTreeIter.None.prepend ()
Prepends a new row to @list_store. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
iter is An unset GtkTreeIter to set to the prepend row.None.remove (object iter)
Removes the given row from the list store. After being removed, @iter is set to be the next valid row, or invalidated if it pointed to the last row in @list_store.
iter is A valid GtkTreeIter.%TRUE if @iter is valid, %FALSE if not..reorder (list new_order)
Reorders @store to follow the order indicated by @new_order. Note that this function only works with unsorted stores.
new_order is an array of integers mapping the new position of each child to its old position before the re-ordering, i.e.[newpos]** = oldpos. It must have exactly as many items as the list store’s length..None.set (object iter, list varargs)
Sets the value of one or more cells in the row referenced by @iter. The variable argument list should contain integer column numbers, each column number followed by the value to be set. The list is terminated by a -1. For example, to set column 0 with type %G_TYPE_STRING to “Foo”, you would write
gtk_list_store_set (store, iter, 0, "Foo", -1). The value will be referenced by the store if it is a %G_TYPE_OBJECT, and it will be copied if it is a %G_TYPE_STRING or %G_TYPE_BOXED.
iter is row iterator.... is pairs of column number and value, terminated with -1.None.set_column_types (list types)
Sets the types of the columns of a list store. This function is meant primarily for objects that inherit from
GtkListStore, and should only be used when constructing a new instance. This function cannot be called after a row has been added, or a method on theGtkTreeModelinterface is called.
n_columns is Number of columns for the list store.types is An array length n of GTypes.None.set_value (object iter, int column, object value)
Sets the data in the cell specified by @iter and @column. The type of
must be convertible to the type of the column.iter is A valid GtkTreeIter for the row being modified.column is column number to modify.value is new value for the cell.None.set_valuesv (object iter, list columns, list values)
A variant of gtk_list_store_set_valist() which takes the columns and values as two arrays, instead of varargs. This function is mainly intended for language-bindings and in case the number of columns to change is not known until run-time.
iter is A valid GtkTreeIter for the row being modified.columns is an array of column numbers.values is an array of GValues.n_values is the length of the @columns and @values arrays.None.swap (object a, object b)
Swaps @a and @b in @store. Note that this function only works with unsorted stores.
a is A GtkTreeIter.b is Another GtkTreeIter.None.[526:14] static extends: object
Alternate constructors for GtkListStore. Usage:
GtkListStoreCtors.<name>(...). The primary constructor lives
directly on GtkListStore.
newNewv (list types)
Creates a new
GtkListStore. This function is meant to be used by language bindings.
n_columns is number of columns in the list store.types is an array of GType types for the columns, from first to last.A new GtkListStore.
