/* gtkliststore.c * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library. If not, see . */ #include "config.h" #include #include #include #include #include "gtktreemodel.h" #include "gtkliststore.h" #include "gtktreedatalist.h" #include "gtktreednd.h" #include "gtkintl.h" #include "gtkbuildable.h" #include "gtkbuilderprivate.h" /** * SECTION:gtkliststore * @Short_description: A list-like data structure that can be used with the GtkTreeView * @Title: GtkListStore * @See_also:#GtkTreeModel, #GtkTreeStore * * 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][gtk3-GtkTreeView-drag-and-drop] * interfaces. * * The #GtkListStore can accept most GObject types 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 gtk_tree_model_row_changed() to emit the * #GtkTreeModel::row_changed signal. This most commonly affects lists with * #GdkTextures stored. * * An example for creating a simple list store: * |[ * enum { * COLUMN_STRING, * COLUMN_INT, * COLUMN_BOOLEAN, * N_COLUMNS * }; * * { * GtkListStore *list_store; * GtkTreePath *path; * GtkTreeIter iter; * gint i; * * list_store = gtk_list_store_new (N_COLUMNS, * G_TYPE_STRING, * G_TYPE_INT, * G_TYPE_BOOLEAN); * * for (i = 0; i < 10; i++) * { * gchar *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); * } * ]| * * # Performance Considerations * * Internally, the #GtkListStore was implemented with a linked list with * a tail pointer prior to GTK+ 2.6. 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 GtkBuildable interface allows * to specify the model columns with a element that may contain * multiple 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 element. It can contain multiple * elements, each specifying to content for one row of the list model. * Inside a , the 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: * |[ * * * * * * * * * John * Doe * 25 * * * Johan * Dahlin * 50 * * * * ]| */ struct _GtkListStorePrivate { GtkTreeIterCompareFunc default_sort_func; GDestroyNotify default_sort_destroy; GList *sort_list; GType *column_headers; gint stamp; gint n_columns; gint sort_column_id; gint length; GtkSortType order; guint columns_dirty : 1; gpointer default_sort_data; gpointer seq; /* head of the list */ }; #define GTK_LIST_STORE_IS_SORTED(list) (((GtkListStore*)(list))->priv->sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID) static void gtk_list_store_tree_model_init (GtkTreeModelIface *iface); static void gtk_list_store_drag_source_init(GtkTreeDragSourceIface *iface); static void gtk_list_store_drag_dest_init (GtkTreeDragDestIface *iface); static void gtk_list_store_sortable_init (GtkTreeSortableIface *iface); static void gtk_list_store_buildable_init (GtkBuildableIface *iface); static void gtk_list_store_finalize (GObject *object); static GtkTreeModelFlags gtk_list_store_get_flags (GtkTreeModel *tree_model); static gint gtk_list_store_get_n_columns (GtkTreeModel *tree_model); static GType gtk_list_store_get_column_type (GtkTreeModel *tree_model, gint index); static gboolean gtk_list_store_get_iter (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path); static GtkTreePath *gtk_list_store_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter); static void gtk_list_store_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value); static gboolean gtk_list_store_iter_next (GtkTreeModel *tree_model, GtkTreeIter *iter); static gboolean gtk_list_store_iter_previous (GtkTreeModel *tree_model, GtkTreeIter *iter); static gboolean gtk_list_store_iter_children (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent); static gboolean gtk_list_store_iter_has_child (GtkTreeModel *tree_model, GtkTreeIter *iter); static gint gtk_list_store_iter_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter); static gboolean gtk_list_store_iter_nth_child (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n); static gboolean gtk_list_store_iter_parent (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child); static void gtk_list_store_set_n_columns (GtkListStore *list_store, gint n_columns); static void gtk_list_store_set_column_type (GtkListStore *list_store, gint column, GType type); static void gtk_list_store_increment_stamp (GtkListStore *list_store); /* Drag and Drop */ static gboolean real_gtk_list_store_row_draggable (GtkTreeDragSource *drag_source, GtkTreePath *path); static gboolean gtk_list_store_drag_data_delete (GtkTreeDragSource *drag_source, GtkTreePath *path); static GdkContentProvider * gtk_list_store_drag_data_get (GtkTreeDragSource *drag_source, GtkTreePath *path); static gboolean gtk_list_store_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, const GValue *value); static gboolean gtk_list_store_row_drop_possible (GtkTreeDragDest *drag_dest, GtkTreePath *dest_path, const GValue *value); /* sortable */ static void gtk_list_store_sort (GtkListStore *list_store); static void gtk_list_store_sort_iter_changed (GtkListStore *list_store, GtkTreeIter *iter, gint column); static gboolean gtk_list_store_get_sort_column_id (GtkTreeSortable *sortable, gint *sort_column_id, GtkSortType *order); static void gtk_list_store_set_sort_column_id (GtkTreeSortable *sortable, gint sort_column_id, GtkSortType order); static void gtk_list_store_set_sort_func (GtkTreeSortable *sortable, gint sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GDestroyNotify destroy); static void gtk_list_store_set_default_sort_func (GtkTreeSortable *sortable, GtkTreeIterCompareFunc func, gpointer data, GDestroyNotify destroy); static gboolean gtk_list_store_has_default_sort_func (GtkTreeSortable *sortable); /* buildable */ static gboolean gtk_list_store_buildable_custom_tag_start (GtkBuildable *buildable, GtkBuilder *builder, GObject *child, const gchar *tagname, GtkBuildableParser *parser, gpointer *data); static void gtk_list_store_buildable_custom_tag_end (GtkBuildable *buildable, GtkBuilder *builder, GObject *child, const gchar *tagname, gpointer data); G_DEFINE_TYPE_WITH_CODE (GtkListStore, gtk_list_store, G_TYPE_OBJECT, G_ADD_PRIVATE (GtkListStore) G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL, gtk_list_store_tree_model_init) G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE, gtk_list_store_drag_source_init) G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_DEST, gtk_list_store_drag_dest_init) G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_SORTABLE, gtk_list_store_sortable_init) G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, gtk_list_store_buildable_init)) static void gtk_list_store_class_init (GtkListStoreClass *class) { GObjectClass *object_class; object_class = (GObjectClass*) class; object_class->finalize = gtk_list_store_finalize; } static void gtk_list_store_tree_model_init (GtkTreeModelIface *iface) { iface->get_flags = gtk_list_store_get_flags; iface->get_n_columns = gtk_list_store_get_n_columns; iface->get_column_type = gtk_list_store_get_column_type; iface->get_iter = gtk_list_store_get_iter; iface->get_path = gtk_list_store_get_path; iface->get_value = gtk_list_store_get_value; iface->iter_next = gtk_list_store_iter_next; iface->iter_previous = gtk_list_store_iter_previous; iface->iter_children = gtk_list_store_iter_children; iface->iter_has_child = gtk_list_store_iter_has_child; iface->iter_n_children = gtk_list_store_iter_n_children; iface->iter_nth_child = gtk_list_store_iter_nth_child; iface->iter_parent = gtk_list_store_iter_parent; } static void gtk_list_store_drag_source_init (GtkTreeDragSourceIface *iface) { iface->row_draggable = real_gtk_list_store_row_draggable; iface->drag_data_delete = gtk_list_store_drag_data_delete; iface->drag_data_get = gtk_list_store_drag_data_get; } static void gtk_list_store_drag_dest_init (GtkTreeDragDestIface *iface) { iface->drag_data_received = gtk_list_store_drag_data_received; iface->row_drop_possible = gtk_list_store_row_drop_possible; } static void gtk_list_store_sortable_init (GtkTreeSortableIface *iface) { iface->get_sort_column_id = gtk_list_store_get_sort_column_id; iface->set_sort_column_id = gtk_list_store_set_sort_column_id; iface->set_sort_func = gtk_list_store_set_sort_func; iface->set_default_sort_func = gtk_list_store_set_default_sort_func; iface->has_default_sort_func = gtk_list_store_has_default_sort_func; } void gtk_list_store_buildable_init (GtkBuildableIface *iface) { iface->custom_tag_start = gtk_list_store_buildable_custom_tag_start; iface->custom_tag_end = gtk_list_store_buildable_custom_tag_end; } static void gtk_list_store_init (GtkListStore *list_store) { GtkListStorePrivate *priv; list_store->priv = gtk_list_store_get_instance_private (list_store); priv = list_store->priv; priv->seq = g_sequence_new (NULL); priv->sort_list = NULL; priv->stamp = g_random_int (); priv->sort_column_id = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID; priv->columns_dirty = FALSE; priv->length = 0; } static gboolean iter_is_valid (GtkTreeIter *iter, GtkListStore *list_store) { return iter != NULL && iter->user_data != NULL && list_store->priv->stamp == iter->stamp && !g_sequence_iter_is_end (iter->user_data) && g_sequence_iter_get_sequence (iter->user_data) == list_store->priv->seq; } /** * gtk_list_store_new: * @n_columns: number of columns in the list store * @...: all #GType types for the columns, from first to last * * Creates a new list store as with @n_columns columns each of the types passed * in. Note that only types derived from standard GObject fundamental types * are supported. * * As an example, `gtk_list_store_new (3, G_TYPE_INT, G_TYPE_STRING, * GDK_TYPE_TEXTURE);` will create a new #GtkListStore with three columns, of type * int, string and #GdkTexture, respectively. * * Returns: a new #GtkListStore */ GtkListStore * gtk_list_store_new (gint n_columns, ...) { GtkListStore *retval; va_list args; gint i; g_return_val_if_fail (n_columns > 0, NULL); retval = g_object_new (GTK_TYPE_LIST_STORE, NULL); gtk_list_store_set_n_columns (retval, n_columns); va_start (args, n_columns); for (i = 0; i < n_columns; i++) { GType type = va_arg (args, GType); if (! _gtk_tree_data_list_check_type (type)) { g_warning ("%s: Invalid type %s", G_STRLOC, g_type_name (type)); g_object_unref (retval); va_end (args); return NULL; } gtk_list_store_set_column_type (retval, i, type); } va_end (args); return retval; } /** * gtk_list_store_newv: (rename-to gtk_list_store_new) * @n_columns: number of columns in the list store * @types: (array length=n_columns): an array of #GType types for the columns, from first to last * * Non-vararg creation function. Used primarily by language bindings. * * Returns: (transfer full): a new #GtkListStore **/ GtkListStore * gtk_list_store_newv (gint n_columns, GType *types) { GtkListStore *retval; gint i; g_return_val_if_fail (n_columns > 0, NULL); retval = g_object_new (GTK_TYPE_LIST_STORE, NULL); gtk_list_store_set_n_columns (retval, n_columns); for (i = 0; i < n_columns; i++) { if (! _gtk_tree_data_list_check_type (types[i])) { g_warning ("%s: Invalid type %s", G_STRLOC, g_type_name (types[i])); g_object_unref (retval); return NULL; } gtk_list_store_set_column_type (retval, i, types[i]); } return retval; } /** * gtk_list_store_set_column_types: * @list_store: A #GtkListStore * @n_columns: Number of columns for the list store * @types: (array length=n_columns): An array length n of #GTypes * * This function is meant primarily for #GObjects that inherit from #GtkListStore, * and should only be used when constructing a new #GtkListStore. It will not * function after a row has been added, or a method on the #GtkTreeModel * interface is called. **/ void gtk_list_store_set_column_types (GtkListStore *list_store, gint n_columns, GType *types) { GtkListStorePrivate *priv; gint i; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); priv = list_store->priv; g_return_if_fail (priv->columns_dirty == 0); gtk_list_store_set_n_columns (list_store, n_columns); for (i = 0; i < n_columns; i++) { if (! _gtk_tree_data_list_check_type (types[i])) { g_warning ("%s: Invalid type %s", G_STRLOC, g_type_name (types[i])); continue; } gtk_list_store_set_column_type (list_store, i, types[i]); } } static void gtk_list_store_set_n_columns (GtkListStore *list_store, gint n_columns) { GtkListStorePrivate *priv = list_store->priv; int i; if (priv->n_columns == n_columns) return; priv->column_headers = g_renew (GType, priv->column_headers, n_columns); for (i = priv->n_columns; i < n_columns; i++) priv->column_headers[i] = G_TYPE_INVALID; priv->n_columns = n_columns; if (priv->sort_list) _gtk_tree_data_list_header_free (priv->sort_list); priv->sort_list = _gtk_tree_data_list_header_new (n_columns, priv->column_headers); } static void gtk_list_store_set_column_type (GtkListStore *list_store, gint column, GType type) { GtkListStorePrivate *priv = list_store->priv; if (!_gtk_tree_data_list_check_type (type)) { g_warning ("%s: Invalid type %s", G_STRLOC, g_type_name (type)); return; } priv->column_headers[column] = type; } static void gtk_list_store_finalize (GObject *object) { GtkListStore *list_store = GTK_LIST_STORE (object); GtkListStorePrivate *priv = list_store->priv; g_sequence_foreach (priv->seq, (GFunc) _gtk_tree_data_list_free, priv->column_headers); g_sequence_free (priv->seq); _gtk_tree_data_list_header_free (priv->sort_list); g_free (priv->column_headers); if (priv->default_sort_destroy) { GDestroyNotify d = priv->default_sort_destroy; priv->default_sort_destroy = NULL; d (priv->default_sort_data); priv->default_sort_data = NULL; } G_OBJECT_CLASS (gtk_list_store_parent_class)->finalize (object); } /* Fulfill the GtkTreeModel requirements */ static GtkTreeModelFlags gtk_list_store_get_flags (GtkTreeModel *tree_model) { return GTK_TREE_MODEL_ITERS_PERSIST | GTK_TREE_MODEL_LIST_ONLY; } static gint gtk_list_store_get_n_columns (GtkTreeModel *tree_model) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; priv->columns_dirty = TRUE; return priv->n_columns; } static GType gtk_list_store_get_column_type (GtkTreeModel *tree_model, gint index) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; g_return_val_if_fail (index < priv->n_columns, G_TYPE_INVALID); priv->columns_dirty = TRUE; return priv->column_headers[index]; } static gboolean gtk_list_store_get_iter (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; GSequence *seq; gint i; priv->columns_dirty = TRUE; seq = priv->seq; i = gtk_tree_path_get_indices (path)[0]; if (i >= g_sequence_get_length (seq)) { iter->stamp = 0; return FALSE; } iter->stamp = priv->stamp; iter->user_data = g_sequence_get_iter_at_pos (seq, i); return TRUE; } static GtkTreePath * gtk_list_store_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; GtkTreePath *path; g_return_val_if_fail (iter->stamp == priv->stamp, NULL); if (g_sequence_iter_is_end (iter->user_data)) return NULL; path = gtk_tree_path_new (); gtk_tree_path_append_index (path, g_sequence_iter_get_position (iter->user_data)); return path; } static void gtk_list_store_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; GtkTreeDataList *list; gint tmp_column = column; g_return_if_fail (column < priv->n_columns); g_return_if_fail (iter_is_valid (iter, list_store)); list = g_sequence_get (iter->user_data); while (tmp_column-- > 0 && list) list = list->next; if (list == NULL) g_value_init (value, priv->column_headers[column]); else _gtk_tree_data_list_node_to_value (list, priv->column_headers[column], value); } static gboolean gtk_list_store_iter_next (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; gboolean retval; g_return_val_if_fail (priv->stamp == iter->stamp, FALSE); iter->user_data = g_sequence_iter_next (iter->user_data); retval = g_sequence_iter_is_end (iter->user_data); if (retval) iter->stamp = 0; return !retval; } static gboolean gtk_list_store_iter_previous (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; g_return_val_if_fail (priv->stamp == iter->stamp, FALSE); if (g_sequence_iter_is_begin (iter->user_data)) { iter->stamp = 0; return FALSE; } iter->user_data = g_sequence_iter_prev (iter->user_data); return TRUE; } static gboolean gtk_list_store_iter_children (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent) { GtkListStore *list_store = (GtkListStore *) tree_model; GtkListStorePrivate *priv = list_store->priv; /* this is a list, nodes have no children */ if (parent) { iter->stamp = 0; return FALSE; } if (g_sequence_get_length (priv->seq) > 0) { iter->stamp = priv->stamp; iter->user_data = g_sequence_get_begin_iter (priv->seq); return TRUE; } else { iter->stamp = 0; return FALSE; } } static gboolean gtk_list_store_iter_has_child (GtkTreeModel *tree_model, GtkTreeIter *iter) { return FALSE; } static gint gtk_list_store_iter_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; if (iter == NULL) return g_sequence_get_length (priv->seq); g_return_val_if_fail (priv->stamp == iter->stamp, -1); return 0; } static gboolean gtk_list_store_iter_nth_child (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n) { GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; GSequenceIter *child; iter->stamp = 0; if (parent) return FALSE; child = g_sequence_get_iter_at_pos (priv->seq, n); if (g_sequence_iter_is_end (child)) return FALSE; iter->stamp = priv->stamp; iter->user_data = child; return TRUE; } static gboolean gtk_list_store_iter_parent (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child) { iter->stamp = 0; return FALSE; } static gboolean gtk_list_store_real_set_value (GtkListStore *list_store, GtkTreeIter *iter, gint column, GValue *value, gboolean sort) { GtkListStorePrivate *priv = list_store->priv; GtkTreeDataList *list; GtkTreeDataList *prev; gint old_column = column; GValue real_value = G_VALUE_INIT; gboolean converted = FALSE; gboolean retval = FALSE; if (! g_type_is_a (G_VALUE_TYPE (value), priv->column_headers[column])) { if (! (g_value_type_transformable (G_VALUE_TYPE (value), priv->column_headers[column]))) { g_warning ("%s: Unable to convert from %s to %s", G_STRLOC, g_type_name (G_VALUE_TYPE (value)), g_type_name (priv->column_headers[column])); return retval; } g_value_init (&real_value, priv->column_headers[column]); if (!g_value_transform (value, &real_value)) { g_warning ("%s: Unable to make conversion from %s to %s", G_STRLOC, g_type_name (G_VALUE_TYPE (value)), g_type_name (priv->column_headers[column])); g_value_unset (&real_value); return retval; } converted = TRUE; } prev = list = g_sequence_get (iter->user_data); while (list != NULL) { if (column == 0) { if (converted) _gtk_tree_data_list_value_to_node (list, &real_value); else _gtk_tree_data_list_value_to_node (list, value); retval = TRUE; if (converted) g_value_unset (&real_value); if (sort && GTK_LIST_STORE_IS_SORTED (list_store)) gtk_list_store_sort_iter_changed (list_store, iter, old_column); return retval; } column--; prev = list; list = list->next; } if (g_sequence_get (iter->user_data) == NULL) { list = _gtk_tree_data_list_alloc(); g_sequence_set (iter->user_data, list); list->next = NULL; } else { list = prev->next = _gtk_tree_data_list_alloc (); list->next = NULL; } while (column != 0) { list->next = _gtk_tree_data_list_alloc (); list = list->next; list->next = NULL; column --; } if (converted) _gtk_tree_data_list_value_to_node (list, &real_value); else _gtk_tree_data_list_value_to_node (list, value); retval = TRUE; if (converted) g_value_unset (&real_value); if (sort && GTK_LIST_STORE_IS_SORTED (list_store)) gtk_list_store_sort_iter_changed (list_store, iter, old_column); return retval; } /** * gtk_list_store_set_value: * @list_store: A #GtkListStore * @iter: A valid #GtkTreeIter for the row being modified * @column: column number to modify * @value: new value for the cell * * Sets the data in the cell specified by @iter and @column. * The type of @value must be convertible to the type of the * column. * **/ void gtk_list_store_set_value (GtkListStore *list_store, GtkTreeIter *iter, gint column, GValue *value) { GtkListStorePrivate *priv; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter_is_valid (iter, list_store)); g_return_if_fail (G_IS_VALUE (value)); priv = list_store->priv; g_return_if_fail (column >= 0 && column < priv->n_columns); if (gtk_list_store_real_set_value (list_store, iter, column, value, TRUE)) { GtkTreePath *path; path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); gtk_tree_model_row_changed (GTK_TREE_MODEL (list_store), path, iter); gtk_tree_path_free (path); } } static GtkTreeIterCompareFunc gtk_list_store_get_compare_func (GtkListStore *list_store) { GtkListStorePrivate *priv = list_store->priv; GtkTreeIterCompareFunc func = NULL; if (GTK_LIST_STORE_IS_SORTED (list_store)) { if (priv->sort_column_id != -1) { GtkTreeDataSortHeader *header; header = _gtk_tree_data_list_get_header (priv->sort_list, priv->sort_column_id); g_return_val_if_fail (header != NULL, NULL); g_return_val_if_fail (header->func != NULL, NULL); func = header->func; } else { func = priv->default_sort_func; } } return func; } static void gtk_list_store_set_vector_internal (GtkListStore *list_store, GtkTreeIter *iter, gboolean *emit_signal, gboolean *maybe_need_sort, gint *columns, GValue *values, gint n_values) { GtkListStorePrivate *priv = list_store->priv; gint i; GtkTreeIterCompareFunc func = NULL; func = gtk_list_store_get_compare_func (list_store); if (func != _gtk_tree_data_list_compare_func) *maybe_need_sort = TRUE; for (i = 0; i < n_values; i++) { *emit_signal = gtk_list_store_real_set_value (list_store, iter, columns[i], &values[i], FALSE) || *emit_signal; if (func == _gtk_tree_data_list_compare_func && columns[i] == priv->sort_column_id) *maybe_need_sort = TRUE; } } static void gtk_list_store_set_valist_internal (GtkListStore *list_store, GtkTreeIter *iter, gboolean *emit_signal, gboolean *maybe_need_sort, va_list var_args) { GtkListStorePrivate *priv = list_store->priv; gint column; GtkTreeIterCompareFunc func = NULL; column = va_arg (var_args, gint); func = gtk_list_store_get_compare_func (list_store); if (func != _gtk_tree_data_list_compare_func) *maybe_need_sort = TRUE; while (column != -1) { GValue value = G_VALUE_INIT; gchar *error = NULL; if (column < 0 || column >= priv->n_columns) { g_warning ("%s: Invalid column number %d added to iter (remember to end your list of columns with a -1)", G_STRLOC, column); break; } G_VALUE_COLLECT_INIT (&value, priv->column_headers[column], var_args, 0, &error); if (error) { g_warning ("%s: %s", G_STRLOC, error); g_free (error); /* we purposely leak the value here, it might not be * in a sane state if an error condition occurred */ break; } /* FIXME: instead of calling this n times, refactor with above */ *emit_signal = gtk_list_store_real_set_value (list_store, iter, column, &value, FALSE) || *emit_signal; if (func == _gtk_tree_data_list_compare_func && column == priv->sort_column_id) *maybe_need_sort = TRUE; g_value_unset (&value); column = va_arg (var_args, gint); } } /** * gtk_list_store_set_valuesv: (rename-to gtk_list_store_set) * @list_store: A #GtkListStore * @iter: A valid #GtkTreeIter for the row being modified * @columns: (array length=n_values): an array of column numbers * @values: (array length=n_values): an array of GValues * @n_values: the length of the @columns and @values arrays * * 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. */ void gtk_list_store_set_valuesv (GtkListStore *list_store, GtkTreeIter *iter, gint *columns, GValue *values, gint n_values) { GtkListStorePrivate *priv; gboolean emit_signal = FALSE; gboolean maybe_need_sort = FALSE; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter_is_valid (iter, list_store)); priv = list_store->priv; gtk_list_store_set_vector_internal (list_store, iter, &emit_signal, &maybe_need_sort, columns, values, n_values); if (maybe_need_sort && GTK_LIST_STORE_IS_SORTED (list_store)) gtk_list_store_sort_iter_changed (list_store, iter, priv->sort_column_id); if (emit_signal) { GtkTreePath *path; path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); gtk_tree_model_row_changed (GTK_TREE_MODEL (list_store), path, iter); gtk_tree_path_free (path); } } /** * gtk_list_store_set_valist: * @list_store: A #GtkListStore * @iter: A valid #GtkTreeIter for the row being modified * @var_args: va_list of column/value pairs * * See gtk_list_store_set(); this version takes a va_list for use by language * bindings. * **/ void gtk_list_store_set_valist (GtkListStore *list_store, GtkTreeIter *iter, va_list var_args) { GtkListStorePrivate *priv; gboolean emit_signal = FALSE; gboolean maybe_need_sort = FALSE; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter_is_valid (iter, list_store)); priv = list_store->priv; gtk_list_store_set_valist_internal (list_store, iter, &emit_signal, &maybe_need_sort, var_args); if (maybe_need_sort && GTK_LIST_STORE_IS_SORTED (list_store)) gtk_list_store_sort_iter_changed (list_store, iter, priv->sort_column_id); if (emit_signal) { GtkTreePath *path; path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); gtk_tree_model_row_changed (GTK_TREE_MODEL (list_store), path, iter); gtk_tree_path_free (path); } } /** * gtk_list_store_set: * @list_store: a #GtkListStore * @iter: row iterator * @...: pairs of column number and value, terminated with -1 * * 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. */ void gtk_list_store_set (GtkListStore *list_store, GtkTreeIter *iter, ...) { va_list var_args; va_start (var_args, iter); gtk_list_store_set_valist (list_store, iter, var_args); va_end (var_args); } /** * gtk_list_store_remove: * @list_store: A #GtkListStore * @iter: A valid #GtkTreeIter * * 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. * * Returns: %TRUE if @iter is valid, %FALSE if not. **/ gboolean gtk_list_store_remove (GtkListStore *list_store, GtkTreeIter *iter) { GtkListStorePrivate *priv; GtkTreePath *path; GSequenceIter *ptr, *next; g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), FALSE); g_return_val_if_fail (iter_is_valid (iter, list_store), FALSE); priv = list_store->priv; path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); ptr = iter->user_data; next = g_sequence_iter_next (ptr); _gtk_tree_data_list_free (g_sequence_get (ptr), priv->column_headers); g_sequence_remove (iter->user_data); priv->length--; gtk_tree_model_row_deleted (GTK_TREE_MODEL (list_store), path); gtk_tree_path_free (path); if (g_sequence_iter_is_end (next)) { iter->stamp = 0; return FALSE; } else { iter->stamp = priv->stamp; iter->user_data = next; return TRUE; } } /** * gtk_list_store_insert: * @list_store: A #GtkListStore * @iter: (out): An unset #GtkTreeIter to set to the new row * @position: position to insert the new row, or -1 for last * * 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(). * **/ void gtk_list_store_insert (GtkListStore *list_store, GtkTreeIter *iter, gint position) { GtkListStorePrivate *priv; GtkTreePath *path; GSequence *seq; GSequenceIter *ptr; gint length; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); priv = list_store->priv; priv->columns_dirty = TRUE; seq = priv->seq; length = g_sequence_get_length (seq); if (position > length || position < 0) position = length; ptr = g_sequence_get_iter_at_pos (seq, position); ptr = g_sequence_insert_before (ptr, NULL); iter->stamp = priv->stamp; iter->user_data = ptr; g_assert (iter_is_valid (iter, list_store)); priv->length++; path = gtk_tree_path_new (); gtk_tree_path_append_index (path, position); gtk_tree_model_row_inserted (GTK_TREE_MODEL (list_store), path, iter); gtk_tree_path_free (path); } /** * gtk_list_store_insert_before: * @list_store: A #GtkListStore * @iter: (out): An unset #GtkTreeIter to set to the new row * @sibling: (allow-none): A valid #GtkTreeIter, or %NULL * * 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(). * **/ void gtk_list_store_insert_before (GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling) { GtkListStorePrivate *priv; GSequenceIter *after; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); priv = list_store->priv; if (sibling) g_return_if_fail (iter_is_valid (sibling, list_store)); if (!sibling) after = g_sequence_get_end_iter (priv->seq); else after = sibling->user_data; gtk_list_store_insert (list_store, iter, g_sequence_iter_get_position (after)); } /** * gtk_list_store_insert_after: * @list_store: A #GtkListStore * @iter: (out): An unset #GtkTreeIter to set to the new row * @sibling: (allow-none): A valid #GtkTreeIter, or %NULL * * 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(). * **/ void gtk_list_store_insert_after (GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling) { GtkListStorePrivate *priv; GSequenceIter *after; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); priv = list_store->priv; if (sibling) g_return_if_fail (iter_is_valid (sibling, list_store)); if (!sibling) after = g_sequence_get_begin_iter (priv->seq); else after = g_sequence_iter_next (sibling->user_data); gtk_list_store_insert (list_store, iter, g_sequence_iter_get_position (after)); } /** * gtk_list_store_prepend: * @list_store: A #GtkListStore * @iter: (out): An unset #GtkTreeIter to set to the prepend row * * 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(). * **/ void gtk_list_store_prepend (GtkListStore *list_store, GtkTreeIter *iter) { g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); gtk_list_store_insert (list_store, iter, 0); } /** * gtk_list_store_append: * @list_store: A #GtkListStore * @iter: (out): An unset #GtkTreeIter to set to the appended row * * 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(). * **/ void gtk_list_store_append (GtkListStore *list_store, GtkTreeIter *iter) { g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); gtk_list_store_insert (list_store, iter, -1); } static void gtk_list_store_increment_stamp (GtkListStore *list_store) { GtkListStorePrivate *priv = list_store->priv; do { priv->stamp++; } while (priv->stamp == 0); } /** * gtk_list_store_clear: * @list_store: a #GtkListStore. * * Removes all rows from the list store. * **/ void gtk_list_store_clear (GtkListStore *list_store) { GtkListStorePrivate *priv; GtkTreeIter iter; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); priv = list_store->priv; while (g_sequence_get_length (priv->seq) > 0) { iter.stamp = priv->stamp; iter.user_data = g_sequence_get_begin_iter (priv->seq); gtk_list_store_remove (list_store, &iter); } gtk_list_store_increment_stamp (list_store); } /** * gtk_list_store_iter_is_valid: * @list_store: A #GtkListStore. * @iter: A #GtkTreeIter. * * > This function is slow. Only use it for debugging and/or testing * > purposes. * * Checks if the given iter is a valid iter for this #GtkListStore. * * Returns: %TRUE if the iter is valid, %FALSE if the iter is invalid. **/ gboolean gtk_list_store_iter_is_valid (GtkListStore *list_store, GtkTreeIter *iter) { GtkListStorePrivate *priv; GSequenceIter *seq_iter; g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), FALSE); g_return_val_if_fail (iter != NULL, FALSE); /* can't use iter_is_valid() here, because iter might point * to random memory. * * We MUST NOT dereference it. */ priv = list_store->priv; if (iter == NULL || iter->user_data == NULL || priv->stamp != iter->stamp) return FALSE; for (seq_iter = g_sequence_get_begin_iter (priv->seq); !g_sequence_iter_is_end (seq_iter); seq_iter = g_sequence_iter_next (seq_iter)) { if (seq_iter == iter->user_data) return TRUE; } return FALSE; } static gboolean real_gtk_list_store_row_draggable (GtkTreeDragSource *drag_source, GtkTreePath *path) { return TRUE; } static gboolean gtk_list_store_drag_data_delete (GtkTreeDragSource *drag_source, GtkTreePath *path) { GtkTreeIter iter; if (gtk_list_store_get_iter (GTK_TREE_MODEL (drag_source), &iter, path)) { gtk_list_store_remove (GTK_LIST_STORE (drag_source), &iter); return TRUE; } return FALSE; } static GdkContentProvider * gtk_list_store_drag_data_get (GtkTreeDragSource *drag_source, GtkTreePath *path) { /* Note that we don't need to handle the GTK_TREE_MODEL_ROW * target, because the default handler does it for us, but * we do anyway for the convenience of someone maybe overriding the * default handler. */ return gtk_tree_create_row_drag_content (GTK_TREE_MODEL (drag_source), path); } static gboolean gtk_list_store_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, const GValue *value) { GtkTreeModel *tree_model = GTK_TREE_MODEL (drag_dest); GtkListStore *list_store = GTK_LIST_STORE (tree_model); GtkListStorePrivate *priv = list_store->priv; GtkTreeModel *src_model = NULL; GtkTreePath *src_path = NULL; gboolean retval = FALSE; if (gtk_tree_get_row_drag_data (value, &src_model, &src_path) && src_model == tree_model) { /* Copy the given row to a new position */ GtkTreeIter src_iter; GtkTreeIter dest_iter; GtkTreePath *prev; if (!gtk_list_store_get_iter (src_model, &src_iter, src_path)) { goto out; } /* Get the path to insert _after_ (dest is the path to insert _before_) */ prev = gtk_tree_path_copy (dest); if (!gtk_tree_path_prev (prev)) { /* dest was the first spot in the list; which means we are supposed * to prepend. */ gtk_list_store_prepend (list_store, &dest_iter); retval = TRUE; } else { if (gtk_list_store_get_iter (tree_model, &dest_iter, prev)) { GtkTreeIter tmp_iter = dest_iter; gtk_list_store_insert_after (list_store, &dest_iter, &tmp_iter); retval = TRUE; } } gtk_tree_path_free (prev); /* If we succeeded in creating dest_iter, copy data from src */ if (retval) { GtkTreeDataList *dl = g_sequence_get (src_iter.user_data); GtkTreeDataList *copy_head = NULL; GtkTreeDataList *copy_prev = NULL; GtkTreeDataList *copy_iter = NULL; GtkTreePath *path; gint col; col = 0; while (dl) { copy_iter = _gtk_tree_data_list_node_copy (dl, priv->column_headers[col]); if (copy_head == NULL) copy_head = copy_iter; if (copy_prev) copy_prev->next = copy_iter; copy_prev = copy_iter; dl = dl->next; ++col; } dest_iter.stamp = priv->stamp; g_sequence_set (dest_iter.user_data, copy_head); path = gtk_list_store_get_path (tree_model, &dest_iter); gtk_tree_model_row_changed (tree_model, path, &dest_iter); gtk_tree_path_free (path); } } else { /* FIXME maybe add some data targets eventually, or handle text * targets in the simple case. */ } out: if (src_path) gtk_tree_path_free (src_path); return retval; } static gboolean gtk_list_store_row_drop_possible (GtkTreeDragDest *drag_dest, GtkTreePath *dest_path, const GValue *value) { gint *indices; GtkTreeModel *src_model = NULL; GtkTreePath *src_path = NULL; gboolean retval = FALSE; /* don't accept drops if the list has been sorted */ if (GTK_LIST_STORE_IS_SORTED (drag_dest)) return FALSE; if (!gtk_tree_get_row_drag_data (value, &src_model, &src_path)) goto out; if (src_model != GTK_TREE_MODEL (drag_dest)) goto out; if (gtk_tree_path_get_depth (dest_path) != 1) goto out; /* can drop before any existing node, or before one past any existing. */ indices = gtk_tree_path_get_indices (dest_path); if (indices[0] <= g_sequence_get_length (GTK_LIST_STORE (drag_dest)->priv->seq)) retval = TRUE; out: if (src_path) gtk_tree_path_free (src_path); return retval; } /* Sorting and reordering */ /* Reordering */ static gint gtk_list_store_reorder_func (GSequenceIter *a, GSequenceIter *b, gpointer user_data) { GHashTable *new_positions = user_data; gint apos = GPOINTER_TO_INT (g_hash_table_lookup (new_positions, a)); gint bpos = GPOINTER_TO_INT (g_hash_table_lookup (new_positions, b)); if (apos < bpos) return -1; if (apos > bpos) return 1; return 0; } /** * gtk_list_store_reorder: * @store: A #GtkListStore. * @new_order: (array zero-terminated=1): an array of integers mapping the new * position of each child to its old position before the re-ordering, * i.e. @new_order`[newpos] = oldpos`. It must have * exactly as many items as the list store’s length. * * Reorders @store to follow the order indicated by @new_order. Note that * this function only works with unsorted stores. **/ void gtk_list_store_reorder (GtkListStore *store, gint *new_order) { GtkListStorePrivate *priv; gint i; GtkTreePath *path; GHashTable *new_positions; GSequenceIter *ptr; gint *order; g_return_if_fail (GTK_IS_LIST_STORE (store)); g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store)); g_return_if_fail (new_order != NULL); priv = store->priv; order = g_new (gint, g_sequence_get_length (priv->seq)); for (i = 0; i < g_sequence_get_length (priv->seq); i++) order[new_order[i]] = i; new_positions = g_hash_table_new (g_direct_hash, g_direct_equal); ptr = g_sequence_get_begin_iter (priv->seq); i = 0; while (!g_sequence_iter_is_end (ptr)) { g_hash_table_insert (new_positions, ptr, GINT_TO_POINTER (order[i++])); ptr = g_sequence_iter_next (ptr); } g_free (order); g_sequence_sort_iter (priv->seq, gtk_list_store_reorder_func, new_positions); g_hash_table_destroy (new_positions); /* emit signal */ path = gtk_tree_path_new (); gtk_tree_model_rows_reordered (GTK_TREE_MODEL (store), path, NULL, new_order); gtk_tree_path_free (path); } static GHashTable * save_positions (GSequence *seq) { GHashTable *positions = g_hash_table_new (g_direct_hash, g_direct_equal); GSequenceIter *ptr; ptr = g_sequence_get_begin_iter (seq); while (!g_sequence_iter_is_end (ptr)) { g_hash_table_insert (positions, ptr, GINT_TO_POINTER (g_sequence_iter_get_position (ptr))); ptr = g_sequence_iter_next (ptr); } return positions; } static int * generate_order (GSequence *seq, GHashTable *old_positions) { GSequenceIter *ptr; int *order = g_new (int, g_sequence_get_length (seq)); int i; i = 0; ptr = g_sequence_get_begin_iter (seq); while (!g_sequence_iter_is_end (ptr)) { int old_pos = GPOINTER_TO_INT (g_hash_table_lookup (old_positions, ptr)); order[i++] = old_pos; ptr = g_sequence_iter_next (ptr); } g_hash_table_destroy (old_positions); return order; } /** * gtk_list_store_swap: * @store: A #GtkListStore. * @a: A #GtkTreeIter. * @b: Another #GtkTreeIter. * * Swaps @a and @b in @store. Note that this function only works with * unsorted stores. **/ void gtk_list_store_swap (GtkListStore *store, GtkTreeIter *a, GtkTreeIter *b) { GtkListStorePrivate *priv; GHashTable *old_positions; gint *order; GtkTreePath *path; g_return_if_fail (GTK_IS_LIST_STORE (store)); g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store)); g_return_if_fail (iter_is_valid (a, store)); g_return_if_fail (iter_is_valid (b, store)); priv = store->priv; if (a->user_data == b->user_data) return; old_positions = save_positions (priv->seq); g_sequence_swap (a->user_data, b->user_data); order = generate_order (priv->seq, old_positions); path = gtk_tree_path_new (); gtk_tree_model_rows_reordered (GTK_TREE_MODEL (store), path, NULL, order); gtk_tree_path_free (path); g_free (order); } static void gtk_list_store_move_to (GtkListStore *store, GtkTreeIter *iter, gint new_pos) { GtkListStorePrivate *priv = store->priv; GHashTable *old_positions; GtkTreePath *path; gint *order; old_positions = save_positions (priv->seq); g_sequence_move (iter->user_data, g_sequence_get_iter_at_pos (priv->seq, new_pos)); order = generate_order (priv->seq, old_positions); path = gtk_tree_path_new (); gtk_tree_model_rows_reordered (GTK_TREE_MODEL (store), path, NULL, order); gtk_tree_path_free (path); g_free (order); } /** * gtk_list_store_move_before: * @store: A #GtkListStore. * @iter: A #GtkTreeIter. * @position: (allow-none): A #GtkTreeIter, or %NULL. * * 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. **/ void gtk_list_store_move_before (GtkListStore *store, GtkTreeIter *iter, GtkTreeIter *position) { gint pos; g_return_if_fail (GTK_IS_LIST_STORE (store)); g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store)); g_return_if_fail (iter_is_valid (iter, store)); if (position) g_return_if_fail (iter_is_valid (position, store)); if (position) pos = g_sequence_iter_get_position (position->user_data); else pos = -1; gtk_list_store_move_to (store, iter, pos); } /** * gtk_list_store_move_after: * @store: A #GtkListStore. * @iter: A #GtkTreeIter. * @position: (allow-none): A #GtkTreeIter or %NULL. * * 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. **/ void gtk_list_store_move_after (GtkListStore *store, GtkTreeIter *iter, GtkTreeIter *position) { gint pos; g_return_if_fail (GTK_IS_LIST_STORE (store)); g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store)); g_return_if_fail (iter_is_valid (iter, store)); if (position) g_return_if_fail (iter_is_valid (position, store)); if (position) pos = g_sequence_iter_get_position (position->user_data) + 1; else pos = 0; gtk_list_store_move_to (store, iter, pos); } /* Sorting */ static gint gtk_list_store_compare_func (GSequenceIter *a, GSequenceIter *b, gpointer user_data) { GtkListStore *list_store = user_data; GtkListStorePrivate *priv = list_store->priv; GtkTreeIter iter_a; GtkTreeIter iter_b; gint retval; GtkTreeIterCompareFunc func; gpointer data; if (priv->sort_column_id != -1) { GtkTreeDataSortHeader *header; header = _gtk_tree_data_list_get_header (priv->sort_list, priv->sort_column_id); g_return_val_if_fail (header != NULL, 0); g_return_val_if_fail (header->func != NULL, 0); func = header->func; data = header->data; } else { g_return_val_if_fail (priv->default_sort_func != NULL, 0); func = priv->default_sort_func; data = priv->default_sort_data; } iter_a.stamp = priv->stamp; iter_a.user_data = (gpointer)a; iter_b.stamp = priv->stamp; iter_b.user_data = (gpointer)b; g_assert (iter_is_valid (&iter_a, list_store)); g_assert (iter_is_valid (&iter_b, list_store)); retval = (* func) (GTK_TREE_MODEL (list_store), &iter_a, &iter_b, data); if (priv->order == GTK_SORT_DESCENDING) { if (retval > 0) retval = -1; else if (retval < 0) retval = 1; } return retval; } static void gtk_list_store_sort (GtkListStore *list_store) { GtkListStorePrivate *priv = list_store->priv; gint *new_order; GtkTreePath *path; GHashTable *old_positions; if (!GTK_LIST_STORE_IS_SORTED (list_store) || g_sequence_get_length (priv->seq) <= 1) return; old_positions = save_positions (priv->seq); g_sequence_sort_iter (priv->seq, gtk_list_store_compare_func, list_store); /* Let the world know about our new order */ new_order = generate_order (priv->seq, old_positions); path = gtk_tree_path_new (); gtk_tree_model_rows_reordered (GTK_TREE_MODEL (list_store), path, NULL, new_order); gtk_tree_path_free (path); g_free (new_order); } static gboolean iter_is_sorted (GtkListStore *list_store, GtkTreeIter *iter) { GSequenceIter *cmp; if (!g_sequence_iter_is_begin (iter->user_data)) { cmp = g_sequence_iter_prev (iter->user_data); if (gtk_list_store_compare_func (cmp, iter->user_data, list_store) > 0) return FALSE; } cmp = g_sequence_iter_next (iter->user_data); if (!g_sequence_iter_is_end (cmp)) { if (gtk_list_store_compare_func (iter->user_data, cmp, list_store) > 0) return FALSE; } return TRUE; } static void gtk_list_store_sort_iter_changed (GtkListStore *list_store, GtkTreeIter *iter, gint column) { GtkListStorePrivate *priv = list_store->priv; GtkTreePath *path; path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); gtk_tree_model_row_changed (GTK_TREE_MODEL (list_store), path, iter); gtk_tree_path_free (path); if (!iter_is_sorted (list_store, iter)) { GHashTable *old_positions; gint *order; old_positions = save_positions (priv->seq); g_sequence_sort_changed_iter (iter->user_data, gtk_list_store_compare_func, list_store); order = generate_order (priv->seq, old_positions); path = gtk_tree_path_new (); gtk_tree_model_rows_reordered (GTK_TREE_MODEL (list_store), path, NULL, order); gtk_tree_path_free (path); g_free (order); } } static gboolean gtk_list_store_get_sort_column_id (GtkTreeSortable *sortable, gint *sort_column_id, GtkSortType *order) { GtkListStore *list_store = GTK_LIST_STORE (sortable); GtkListStorePrivate *priv = list_store->priv; if (sort_column_id) * sort_column_id = priv->sort_column_id; if (order) * order = priv->order; if (priv->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID || priv->sort_column_id == GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID) return FALSE; return TRUE; } static void gtk_list_store_set_sort_column_id (GtkTreeSortable *sortable, gint sort_column_id, GtkSortType order) { GtkListStore *list_store = GTK_LIST_STORE (sortable); GtkListStorePrivate *priv = list_store->priv; if ((priv->sort_column_id == sort_column_id) && (priv->order == order)) return; if (sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID) { if (sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) { GtkTreeDataSortHeader *header = NULL; header = _gtk_tree_data_list_get_header (priv->sort_list, sort_column_id); /* We want to make sure that we have a function */ g_return_if_fail (header != NULL); g_return_if_fail (header->func != NULL); } else { g_return_if_fail (priv->default_sort_func != NULL); } } priv->sort_column_id = sort_column_id; priv->order = order; gtk_tree_sortable_sort_column_changed (sortable); gtk_list_store_sort (list_store); } static void gtk_list_store_set_sort_func (GtkTreeSortable *sortable, gint sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GDestroyNotify destroy) { GtkListStore *list_store = GTK_LIST_STORE (sortable); GtkListStorePrivate *priv = list_store->priv; priv->sort_list = _gtk_tree_data_list_set_header (priv->sort_list, sort_column_id, func, data, destroy); if (priv->sort_column_id == sort_column_id) gtk_list_store_sort (list_store); } static void gtk_list_store_set_default_sort_func (GtkTreeSortable *sortable, GtkTreeIterCompareFunc func, gpointer data, GDestroyNotify destroy) { GtkListStore *list_store = GTK_LIST_STORE (sortable); GtkListStorePrivate *priv = list_store->priv; if (priv->default_sort_destroy) { GDestroyNotify d = priv->default_sort_destroy; priv->default_sort_destroy = NULL; d (priv->default_sort_data); } priv->default_sort_func = func; priv->default_sort_data = data; priv->default_sort_destroy = destroy; if (priv->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) gtk_list_store_sort (list_store); } static gboolean gtk_list_store_has_default_sort_func (GtkTreeSortable *sortable) { GtkListStore *list_store = GTK_LIST_STORE (sortable); GtkListStorePrivate *priv = list_store->priv; return (priv->default_sort_func != NULL); } /** * gtk_list_store_insert_with_values: * @list_store: A #GtkListStore * @iter: (out) (allow-none): An unset #GtkTreeIter to set to the new row, or %NULL * @position: position to insert the new row, or -1 to append after existing * rows * @...: pairs of column number and value, terminated with -1 * * 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 * |[ * 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 emit a row_inserted signal, * while the latter will emit row_inserted, row_changed and, if the list store * is sorted, rows_reordered. Since emitting the rows_reordered signal * 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. */ void gtk_list_store_insert_with_values (GtkListStore *list_store, GtkTreeIter *iter, gint position, ...) { GtkListStorePrivate *priv; GtkTreePath *path; GSequence *seq; GSequenceIter *ptr; GtkTreeIter tmp_iter; gint length; gboolean changed = FALSE; gboolean maybe_need_sort = FALSE; va_list var_args; /* FIXME: refactor to reduce overlap with gtk_list_store_set() */ g_return_if_fail (GTK_IS_LIST_STORE (list_store)); priv = list_store->priv; if (!iter) iter = &tmp_iter; priv->columns_dirty = TRUE; seq = priv->seq; length = g_sequence_get_length (seq); if (position > length || position < 0) position = length; ptr = g_sequence_get_iter_at_pos (seq, position); ptr = g_sequence_insert_before (ptr, NULL); iter->stamp = priv->stamp; iter->user_data = ptr; g_assert (iter_is_valid (iter, list_store)); priv->length++; va_start (var_args, position); gtk_list_store_set_valist_internal (list_store, iter, &changed, &maybe_need_sort, var_args); va_end (var_args); /* Don't emit rows_reordered here */ if (maybe_need_sort && GTK_LIST_STORE_IS_SORTED (list_store)) g_sequence_sort_changed_iter (iter->user_data, gtk_list_store_compare_func, list_store); /* Just emit row_inserted */ path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); gtk_tree_model_row_inserted (GTK_TREE_MODEL (list_store), path, iter); gtk_tree_path_free (path); } /** * gtk_list_store_insert_with_valuesv: * @list_store: A #GtkListStore * @iter: (out) (allow-none): An unset #GtkTreeIter to set to the new row, or %NULL. * @position: position to insert the new row, or -1 for last * @columns: (array length=n_values): an array of column numbers * @values: (array length=n_values): an array of GValues * @n_values: the length of the @columns and @values arrays * * 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. */ void gtk_list_store_insert_with_valuesv (GtkListStore *list_store, GtkTreeIter *iter, gint position, gint *columns, GValue *values, gint n_values) { GtkListStorePrivate *priv; GtkTreePath *path; GSequence *seq; GSequenceIter *ptr; GtkTreeIter tmp_iter; gint length; gboolean changed = FALSE; gboolean maybe_need_sort = FALSE; /* FIXME refactor to reduce overlap with * gtk_list_store_insert_with_values() */ g_return_if_fail (GTK_IS_LIST_STORE (list_store)); priv = list_store->priv; if (!iter) iter = &tmp_iter; priv->columns_dirty = TRUE; seq = priv->seq; length = g_sequence_get_length (seq); if (position > length || position < 0) position = length; ptr = g_sequence_get_iter_at_pos (seq, position); ptr = g_sequence_insert_before (ptr, NULL); iter->stamp = priv->stamp; iter->user_data = ptr; g_assert (iter_is_valid (iter, list_store)); priv->length++; gtk_list_store_set_vector_internal (list_store, iter, &changed, &maybe_need_sort, columns, values, n_values); /* Don't emit rows_reordered here */ if (maybe_need_sort && GTK_LIST_STORE_IS_SORTED (list_store)) g_sequence_sort_changed_iter (iter->user_data, gtk_list_store_compare_func, list_store); /* Just emit row_inserted */ path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); gtk_tree_model_row_inserted (GTK_TREE_MODEL (list_store), path, iter); gtk_tree_path_free (path); } /* GtkBuildable custom tag implementation * * * * * */ typedef struct { gboolean translatable; gchar *context; int id; } ColInfo; typedef struct { GtkBuilder *builder; GObject *object; GSList *column_type_names; GType *column_types; GValue *values; gint *colids; ColInfo **columns; gint last_row; gint n_columns; gint row_column; gboolean is_data; const gchar *domain; } SubParserData; static void list_store_start_element (GtkBuildableParseContext *context, const gchar *element_name, const gchar **names, const gchar **values, gpointer user_data, GError **error) { SubParserData *data = (SubParserData*)user_data; if (strcmp (element_name, "col") == 0) { gint id = -1; const gchar *id_str; const gchar *msg_context = NULL; gboolean translatable = FALSE; ColInfo *info; GValue val = G_VALUE_INIT; if (!_gtk_builder_check_parent (data->builder, context, "row", error)) return; if (data->row_column >= data->n_columns) { g_set_error (error, GTK_BUILDER_ERROR, GTK_BUILDER_ERROR_INVALID_VALUE, "Too many columns, maximum is %d", data->n_columns - 1); _gtk_builder_prefix_error (data->builder, context, error); return; } if (!g_markup_collect_attributes (element_name, names, values, error, G_MARKUP_COLLECT_STRING, "id", &id_str, G_MARKUP_COLLECT_BOOLEAN|G_MARKUP_COLLECT_OPTIONAL, "translatable", &translatable, G_MARKUP_COLLECT_STRING|G_MARKUP_COLLECT_OPTIONAL, "comments", NULL, G_MARKUP_COLLECT_STRING|G_MARKUP_COLLECT_OPTIONAL, "context", &msg_context, G_MARKUP_COLLECT_INVALID)) { _gtk_builder_prefix_error (data->builder, context, error); return; } if (!gtk_builder_value_from_string_type (data->builder, G_TYPE_INT, id_str, &val, error)) { _gtk_builder_prefix_error (data->builder, context, error); return; } id = g_value_get_int (&val); if (id < 0 || id >= data->n_columns) { g_set_error (error, GTK_BUILDER_ERROR, GTK_BUILDER_ERROR_INVALID_VALUE, "id value %d out of range", id); _gtk_builder_prefix_error (data->builder, context, error); return; } info = g_slice_new0 (ColInfo); info->translatable = translatable; info->context = g_strdup (msg_context); info->id = id; data->colids[data->row_column] = id; data->columns[data->row_column] = info; data->row_column++; data->is_data = TRUE; } else if (strcmp (element_name, "row") == 0) { if (!_gtk_builder_check_parent (data->builder, context, "data", error)) return; if (!g_markup_collect_attributes (element_name, names, values, error, G_MARKUP_COLLECT_INVALID, NULL, NULL, G_MARKUP_COLLECT_INVALID)) _gtk_builder_prefix_error (data->builder, context, error); } else if (strcmp (element_name, "columns") == 0 || strcmp (element_name, "data") == 0) { if (!_gtk_builder_check_parent (data->builder, context, "object", error)) return; if (!g_markup_collect_attributes (element_name, names, values, error, G_MARKUP_COLLECT_INVALID, NULL, NULL, G_MARKUP_COLLECT_INVALID)) _gtk_builder_prefix_error (data->builder, context, error); } else if (strcmp (element_name, "column") == 0) { const gchar *type; if (!_gtk_builder_check_parent (data->builder, context, "columns", error)) return; if (!g_markup_collect_attributes (element_name, names, values, error, G_MARKUP_COLLECT_STRING, "type", &type, G_MARKUP_COLLECT_INVALID)) { _gtk_builder_prefix_error (data->builder, context, error); return; } data->column_type_names = g_slist_prepend (data->column_type_names, g_strdup (type)); } else { _gtk_builder_error_unhandled_tag (data->builder, context, "GtkListStore", element_name, error); } } static void list_store_end_element (GtkBuildableParseContext *context, const gchar *element_name, gpointer user_data, GError **error) { SubParserData *data = (SubParserData*)user_data; g_assert (data->builder); if (strcmp (element_name, "row") == 0) { GtkTreeIter iter; int i; gtk_list_store_insert_with_valuesv (GTK_LIST_STORE (data->object), &iter, data->last_row, data->colids, data->values, data->row_column); for (i = 0; i < data->row_column; i++) { ColInfo *info = data->columns[i]; g_free (info->context); g_slice_free (ColInfo, info); data->columns[i] = NULL; g_value_unset (&data->values[i]); } g_free (data->values); data->values = g_new0 (GValue, data->n_columns); data->last_row++; data->row_column = 0; } else if (strcmp (element_name, "columns") == 0) { GType *column_types; GSList *l; int i; GType type; data->column_type_names = g_slist_reverse (data->column_type_names); column_types = g_new0 (GType, g_slist_length (data->column_type_names)); for (l = data->column_type_names, i = 0; l; l = l->next, i++) { type = gtk_builder_get_type_from_name (data->builder, l->data); if (type == G_TYPE_INVALID) { g_warning ("Unknown type %s specified in treemodel %s", (const gchar*)l->data, gtk_buildable_get_name (GTK_BUILDABLE (data->object))); continue; } column_types[i] = type; g_free (l->data); } gtk_list_store_set_column_types (GTK_LIST_STORE (data->object), i, column_types); g_free (column_types); } else if (strcmp (element_name, "col") == 0) { data->is_data = FALSE; } } static void list_store_text (GtkBuildableParseContext *context, const gchar *text, gsize text_len, gpointer user_data, GError **error) { SubParserData *data = (SubParserData*)user_data; gint i; gchar *string; ColInfo *info; if (!data->is_data) return; i = data->row_column - 1; info = data->columns[i]; string = g_strndup (text, text_len); if (info->translatable && text_len) { gchar *translated; /* FIXME: This will not use the domain set in the .ui file, * since the parser is not telling the builder about the domain. * However, it will work for gtk_builder_set_translation_domain() calls. */ translated = g_strdup (_gtk_builder_parser_translate (data->domain, info->context, string)); g_free (string); string = translated; } if (!gtk_builder_value_from_string_type (data->builder, data->column_types[info->id], string, &data->values[i], error)) { _gtk_builder_prefix_error (data->builder, context, error); } g_free (string); } static const GtkBuildableParser list_store_parser = { list_store_start_element, list_store_end_element, list_store_text }; static gboolean gtk_list_store_buildable_custom_tag_start (GtkBuildable *buildable, GtkBuilder *builder, GObject *child, const gchar *tagname, GtkBuildableParser *parser, gpointer *parser_data) { SubParserData *data; if (child) return FALSE; if (strcmp (tagname, "columns") == 0) { data = g_slice_new0 (SubParserData); data->builder = builder; data->object = G_OBJECT (buildable); data->column_type_names = NULL; *parser = list_store_parser; *parser_data = data; return TRUE; } else if (strcmp (tagname, "data") == 0) { gint n_columns = gtk_list_store_get_n_columns (GTK_TREE_MODEL (buildable)); if (n_columns == 0) g_error ("Cannot append data to an empty model"); data = g_slice_new0 (SubParserData); data->builder = builder; data->object = G_OBJECT (buildable); data->values = g_new0 (GValue, n_columns); data->colids = g_new0 (gint, n_columns); data->columns = g_new0 (ColInfo*, n_columns); data->column_types = GTK_LIST_STORE (buildable)->priv->column_headers; data->n_columns = n_columns; data->last_row = 0; data->domain = gtk_builder_get_translation_domain (builder); *parser = list_store_parser; *parser_data = data; return TRUE; } return FALSE; } static void gtk_list_store_buildable_custom_tag_end (GtkBuildable *buildable, GtkBuilder *builder, GObject *child, const gchar *tagname, gpointer parser_data) { SubParserData *data = (SubParserData*)parser_data; if (strcmp (tagname, "columns") == 0) { g_slist_free (data->column_type_names); g_slice_free (SubParserData, data); } else if (strcmp (tagname, "data") == 0) { int i; for (i = 0; i < data->n_columns; i++) { ColInfo *info = data->columns[i]; if (info) { g_free (info->context); g_slice_free (ColInfo, info); } } g_free (data->colids); g_free (data->columns); g_free (data->values); g_slice_free (SubParserData, data); } }