+Fri Jul 26 22:53:37 2002 Kristian Rietveld <kris@gtk.org>
+
+ API additions: _move, _reorder and _swap for stores, path
+ constructor.
+
+ * gtk/gtktreemodel.[ch] (gtk_tree_path_new_from_indices): new function.
+
+ * gtk/gtkliststore.[ch]: added gtk_list_store_reorder_func (private),
+ gtk_list_store_reorder, gtk_list_store_swap, gtk_list_store_move.
+
+ * gtk/gtktreestore.[ch]: added gtk_tree_store_reorder_func (private),
+ gtk_tree_store_reorder, gtk_tree_store_swap, gtk_tree_store_move.
+
+Fri Jul 26 22:32:57 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreestore.c (node_free): return FALSE,
+ (gtk_tree_store_finalize): use g_node_traverse instead of
+ g_node_children_foreach, so the whole tree will be freed (#88854,
+ patch from Emmanuel Briot).
+
+Fri Jul 26 22:32:24 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_button_press): fix some memleaks,
+ (#84426, patch from Matthias Clasen).
+
+Fri Jul 26 22:31:25 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_unref_tree_helper): _iter_children
+ check shouldn't be in g_return_return_val_if_fail (pointed out by
+ Josh Green, #88997),
+ (gtk_tree_view_set_model): call _gtk_tree_view_column_unset_model
+ for each column when we unset the model (part of #82484),
+ (gtk_tree_view_get_cell_area): return if we ran out of tree or
+ if we got an invalid path (#82376).
+
+ * gtk/gtktreeprivate.h: add _gtk_tree_view_column_unset_model.
+
+ * gtk/gtktreeviewcolumn.c: implement _gtk_tree_view_column_unset_model
+ which disconnects the sort_column_changed_signal (part of #82484).
+
+ * gtk/gtkliststore.c (gtk_list_store_insert): append row if the
+ given postion is off the end of the tree (#85813).
+
+ * gtk/gtkentry.c (gtk_cell_editable_key_press_event): let's use
+ 2-space indent, commit changes if up/down keys has been pressed,
+ this overrides the focus key foo so the user won't be surprised
+ (#84665).
+
Fri Jul 26 16:34:34 2002 Shivram U <shivaram.upadhyayula@wipro.com>
* gdk/gdkpixbuf-drawable.c (gdk_pixbuf_get_from_drawable),
+Fri Jul 26 22:53:37 2002 Kristian Rietveld <kris@gtk.org>
+
+ API additions: _move, _reorder and _swap for stores, path
+ constructor.
+
+ * gtk/gtktreemodel.[ch] (gtk_tree_path_new_from_indices): new function.
+
+ * gtk/gtkliststore.[ch]: added gtk_list_store_reorder_func (private),
+ gtk_list_store_reorder, gtk_list_store_swap, gtk_list_store_move.
+
+ * gtk/gtktreestore.[ch]: added gtk_tree_store_reorder_func (private),
+ gtk_tree_store_reorder, gtk_tree_store_swap, gtk_tree_store_move.
+
+Fri Jul 26 22:32:57 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreestore.c (node_free): return FALSE,
+ (gtk_tree_store_finalize): use g_node_traverse instead of
+ g_node_children_foreach, so the whole tree will be freed (#88854,
+ patch from Emmanuel Briot).
+
+Fri Jul 26 22:32:24 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_button_press): fix some memleaks,
+ (#84426, patch from Matthias Clasen).
+
+Fri Jul 26 22:31:25 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_unref_tree_helper): _iter_children
+ check shouldn't be in g_return_return_val_if_fail (pointed out by
+ Josh Green, #88997),
+ (gtk_tree_view_set_model): call _gtk_tree_view_column_unset_model
+ for each column when we unset the model (part of #82484),
+ (gtk_tree_view_get_cell_area): return if we ran out of tree or
+ if we got an invalid path (#82376).
+
+ * gtk/gtktreeprivate.h: add _gtk_tree_view_column_unset_model.
+
+ * gtk/gtktreeviewcolumn.c: implement _gtk_tree_view_column_unset_model
+ which disconnects the sort_column_changed_signal (part of #82484).
+
+ * gtk/gtkliststore.c (gtk_list_store_insert): append row if the
+ given postion is off the end of the tree (#85813).
+
+ * gtk/gtkentry.c (gtk_cell_editable_key_press_event): let's use
+ 2-space indent, commit changes if up/down keys has been pressed,
+ this overrides the focus key foo so the user won't be surprised
+ (#84665).
+
Fri Jul 26 16:34:34 2002 Shivram U <shivaram.upadhyayula@wipro.com>
* gdk/gdkpixbuf-drawable.c (gdk_pixbuf_get_from_drawable),
+Fri Jul 26 22:53:37 2002 Kristian Rietveld <kris@gtk.org>
+
+ API additions: _move, _reorder and _swap for stores, path
+ constructor.
+
+ * gtk/gtktreemodel.[ch] (gtk_tree_path_new_from_indices): new function.
+
+ * gtk/gtkliststore.[ch]: added gtk_list_store_reorder_func (private),
+ gtk_list_store_reorder, gtk_list_store_swap, gtk_list_store_move.
+
+ * gtk/gtktreestore.[ch]: added gtk_tree_store_reorder_func (private),
+ gtk_tree_store_reorder, gtk_tree_store_swap, gtk_tree_store_move.
+
+Fri Jul 26 22:32:57 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreestore.c (node_free): return FALSE,
+ (gtk_tree_store_finalize): use g_node_traverse instead of
+ g_node_children_foreach, so the whole tree will be freed (#88854,
+ patch from Emmanuel Briot).
+
+Fri Jul 26 22:32:24 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_button_press): fix some memleaks,
+ (#84426, patch from Matthias Clasen).
+
+Fri Jul 26 22:31:25 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_unref_tree_helper): _iter_children
+ check shouldn't be in g_return_return_val_if_fail (pointed out by
+ Josh Green, #88997),
+ (gtk_tree_view_set_model): call _gtk_tree_view_column_unset_model
+ for each column when we unset the model (part of #82484),
+ (gtk_tree_view_get_cell_area): return if we ran out of tree or
+ if we got an invalid path (#82376).
+
+ * gtk/gtktreeprivate.h: add _gtk_tree_view_column_unset_model.
+
+ * gtk/gtktreeviewcolumn.c: implement _gtk_tree_view_column_unset_model
+ which disconnects the sort_column_changed_signal (part of #82484).
+
+ * gtk/gtkliststore.c (gtk_list_store_insert): append row if the
+ given postion is off the end of the tree (#85813).
+
+ * gtk/gtkentry.c (gtk_cell_editable_key_press_event): let's use
+ 2-space indent, commit changes if up/down keys has been pressed,
+ this overrides the focus key foo so the user won't be surprised
+ (#84665).
+
Fri Jul 26 16:34:34 2002 Shivram U <shivaram.upadhyayula@wipro.com>
* gdk/gdkpixbuf-drawable.c (gdk_pixbuf_get_from_drawable),
+Fri Jul 26 22:53:37 2002 Kristian Rietveld <kris@gtk.org>
+
+ API additions: _move, _reorder and _swap for stores, path
+ constructor.
+
+ * gtk/gtktreemodel.[ch] (gtk_tree_path_new_from_indices): new function.
+
+ * gtk/gtkliststore.[ch]: added gtk_list_store_reorder_func (private),
+ gtk_list_store_reorder, gtk_list_store_swap, gtk_list_store_move.
+
+ * gtk/gtktreestore.[ch]: added gtk_tree_store_reorder_func (private),
+ gtk_tree_store_reorder, gtk_tree_store_swap, gtk_tree_store_move.
+
+Fri Jul 26 22:32:57 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreestore.c (node_free): return FALSE,
+ (gtk_tree_store_finalize): use g_node_traverse instead of
+ g_node_children_foreach, so the whole tree will be freed (#88854,
+ patch from Emmanuel Briot).
+
+Fri Jul 26 22:32:24 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_button_press): fix some memleaks,
+ (#84426, patch from Matthias Clasen).
+
+Fri Jul 26 22:31:25 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_unref_tree_helper): _iter_children
+ check shouldn't be in g_return_return_val_if_fail (pointed out by
+ Josh Green, #88997),
+ (gtk_tree_view_set_model): call _gtk_tree_view_column_unset_model
+ for each column when we unset the model (part of #82484),
+ (gtk_tree_view_get_cell_area): return if we ran out of tree or
+ if we got an invalid path (#82376).
+
+ * gtk/gtktreeprivate.h: add _gtk_tree_view_column_unset_model.
+
+ * gtk/gtktreeviewcolumn.c: implement _gtk_tree_view_column_unset_model
+ which disconnects the sort_column_changed_signal (part of #82484).
+
+ * gtk/gtkliststore.c (gtk_list_store_insert): append row if the
+ given postion is off the end of the tree (#85813).
+
+ * gtk/gtkentry.c (gtk_cell_editable_key_press_event): let's use
+ 2-space indent, commit changes if up/down keys has been pressed,
+ this overrides the focus key foo so the user won't be surprised
+ (#84665).
+
Fri Jul 26 16:34:34 2002 Shivram U <shivaram.upadhyayula@wipro.com>
* gdk/gdkpixbuf-drawable.c (gdk_pixbuf_get_from_drawable),
+Fri Jul 26 22:53:37 2002 Kristian Rietveld <kris@gtk.org>
+
+ API additions: _move, _reorder and _swap for stores, path
+ constructor.
+
+ * gtk/gtktreemodel.[ch] (gtk_tree_path_new_from_indices): new function.
+
+ * gtk/gtkliststore.[ch]: added gtk_list_store_reorder_func (private),
+ gtk_list_store_reorder, gtk_list_store_swap, gtk_list_store_move.
+
+ * gtk/gtktreestore.[ch]: added gtk_tree_store_reorder_func (private),
+ gtk_tree_store_reorder, gtk_tree_store_swap, gtk_tree_store_move.
+
+Fri Jul 26 22:32:57 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreestore.c (node_free): return FALSE,
+ (gtk_tree_store_finalize): use g_node_traverse instead of
+ g_node_children_foreach, so the whole tree will be freed (#88854,
+ patch from Emmanuel Briot).
+
+Fri Jul 26 22:32:24 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_button_press): fix some memleaks,
+ (#84426, patch from Matthias Clasen).
+
+Fri Jul 26 22:31:25 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_unref_tree_helper): _iter_children
+ check shouldn't be in g_return_return_val_if_fail (pointed out by
+ Josh Green, #88997),
+ (gtk_tree_view_set_model): call _gtk_tree_view_column_unset_model
+ for each column when we unset the model (part of #82484),
+ (gtk_tree_view_get_cell_area): return if we ran out of tree or
+ if we got an invalid path (#82376).
+
+ * gtk/gtktreeprivate.h: add _gtk_tree_view_column_unset_model.
+
+ * gtk/gtktreeviewcolumn.c: implement _gtk_tree_view_column_unset_model
+ which disconnects the sort_column_changed_signal (part of #82484).
+
+ * gtk/gtkliststore.c (gtk_list_store_insert): append row if the
+ given postion is off the end of the tree (#85813).
+
+ * gtk/gtkentry.c (gtk_cell_editable_key_press_event): let's use
+ 2-space indent, commit changes if up/down keys has been pressed,
+ this overrides the focus key foo so the user won't be surprised
+ (#84665).
+
Fri Jul 26 16:34:34 2002 Shivram U <shivaram.upadhyayula@wipro.com>
* gdk/gdkpixbuf-drawable.c (gdk_pixbuf_get_from_drawable),
+Fri Jul 26 22:53:37 2002 Kristian Rietveld <kris@gtk.org>
+
+ API additions: _move, _reorder and _swap for stores, path
+ constructor.
+
+ * gtk/gtktreemodel.[ch] (gtk_tree_path_new_from_indices): new function.
+
+ * gtk/gtkliststore.[ch]: added gtk_list_store_reorder_func (private),
+ gtk_list_store_reorder, gtk_list_store_swap, gtk_list_store_move.
+
+ * gtk/gtktreestore.[ch]: added gtk_tree_store_reorder_func (private),
+ gtk_tree_store_reorder, gtk_tree_store_swap, gtk_tree_store_move.
+
+Fri Jul 26 22:32:57 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreestore.c (node_free): return FALSE,
+ (gtk_tree_store_finalize): use g_node_traverse instead of
+ g_node_children_foreach, so the whole tree will be freed (#88854,
+ patch from Emmanuel Briot).
+
+Fri Jul 26 22:32:24 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_button_press): fix some memleaks,
+ (#84426, patch from Matthias Clasen).
+
+Fri Jul 26 22:31:25 2002 Kristian Rietveld <kris@gtk.org>
+
+ Merge from stable:
+
+ * gtk/gtktreeview.c (gtk_tree_view_unref_tree_helper): _iter_children
+ check shouldn't be in g_return_return_val_if_fail (pointed out by
+ Josh Green, #88997),
+ (gtk_tree_view_set_model): call _gtk_tree_view_column_unset_model
+ for each column when we unset the model (part of #82484),
+ (gtk_tree_view_get_cell_area): return if we ran out of tree or
+ if we got an invalid path (#82376).
+
+ * gtk/gtktreeprivate.h: add _gtk_tree_view_column_unset_model.
+
+ * gtk/gtktreeviewcolumn.c: implement _gtk_tree_view_column_unset_model
+ which disconnects the sort_column_changed_signal (part of #82484).
+
+ * gtk/gtkliststore.c (gtk_list_store_insert): append row if the
+ given postion is off the end of the tree (#85813).
+
+ * gtk/gtkentry.c (gtk_cell_editable_key_press_event): let's use
+ 2-space indent, commit changes if up/down keys has been pressed,
+ this overrides the focus key foo so the user won't be surprised
+ (#84665).
+
Fri Jul 26 16:34:34 2002 Shivram U <shivaram.upadhyayula@wipro.com>
* gdk/gdkpixbuf-drawable.c (gdk_pixbuf_get_from_drawable),
GdkEventKey *key_event,
gpointer data)
{
- if (key_event->keyval == GDK_Escape)
- {
- entry->editing_canceled = TRUE;
- gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
- gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
+ if (key_event->keyval == GDK_Escape)
+ {
+ entry->editing_canceled = TRUE;
+ gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
+ gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
- return TRUE;
- }
+ return TRUE;
+ }
- return FALSE;
+ /* override focus */
+ if (key_event->keyval == GDK_Up || key_event->keyval == GDK_Down)
+ {
+ gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
+ gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
+
+ return TRUE;
+ }
+
+ return FALSE;
}
static void
if (list == NULL)
{
- g_warning ("%s: position %d is off the end of the list\n", G_STRLOC, position);
+ /* position if off the end of the list, append it */
+ gtk_list_store_append (list_store, iter);
+
return;
}
return retval;
}
-
-/* Sorting */
+/* Sorting and reordering */
typedef struct _SortTuple
{
gint offset;
GSList *el;
} SortTuple;
+/* Reordering */
+static gint
+gtk_list_store_reorder_func (gconstpointer a,
+ gconstpointer b,
+ gpointer user_data)
+{
+ SortTuple *a_reorder;
+ SortTuple *b_reorder;
+
+ a_reorder = (SortTuple *)a;
+ b_reorder = (SortTuple *)b;
+
+ if (a_reorder->offset < b_reorder->offset)
+ return -1;
+ if (a_reorder->offset > b_reorder->offset)
+ return 1;
+
+ return 0;
+}
+
+/**
+ * gtk_list_store_reorder:
+ * @store: A #GtkTreeStore.
+ * @new_order: An integer array indicating the new order for the list.
+ *
+ * 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)
+{
+ gint i;
+ GSList *current_list;
+ GtkTreePath *path;
+ SortTuple *sort_array;
+
+ 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);
+
+ sort_array = g_new (SortTuple, store->length);
+
+ current_list = store->root;
+
+ for (i = 0; i < store->length; i++)
+ {
+ sort_array[i].offset = new_order[i];
+ sort_array[i].el = current_list;
+
+ current_list = current_list->next;
+ }
+
+ g_qsort_with_data (sort_array,
+ store->length,
+ sizeof (SortTuple),
+ gtk_list_store_reorder_func,
+ NULL);
+
+ for (i = 0; i < store->length - 1; i++)
+ G_SLIST (sort_array[i].el)->next = G_SLIST (sort_array[i+1].el);
+
+ store->root = G_SLIST (sort_array[0].el);
+ store->tail = G_SLIST (sort_array[store->length-1].el);
+ G_SLIST (store->tail)->next = NULL;
+
+ /* 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);
+ g_free (sort_array);
+}
+
+/**
+ * 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)
+{
+ GSList *i, *prev_a = NULL, *prev_b = NULL;
+ gint j, a_count = 0, b_count = 0, *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 (VALID_ITER (a, store));
+ g_return_if_fail (VALID_ITER (b, store));
+
+ if (a->user_data == b->user_data)
+ return;
+
+ if (a->user_data == store->root)
+ prev_a = NULL;
+ else
+ {
+ for (i = store->root; i; i = i->next, a_count++)
+ if (i->next == a->user_data)
+ {
+ prev_a = i;
+ break;
+ }
+
+ a_count++;
+ }
+
+ if (a->user_data == store->root)
+ prev_b = NULL;
+ else
+ {
+ for (i = store->root; i; i = i->next, b_count++)
+ if (i->next == b->user_data)
+ {
+ prev_b = i;
+ break;
+ }
+
+ b_count++;
+ }
+
+ if (!prev_a)
+ store->root = b->user_data;
+ else
+ prev_a->next = b->user_data;
+
+ if (!prev_b)
+ store->root = a->user_data;
+ else
+ prev_b->next = a->user_data;
+
+ /* think a_next inspead of a_prev here ... */
+ prev_a = G_SLIST (a->user_data)->next;
+ prev_b = G_SLIST (b->user_data)->next;
+
+ G_SLIST (a->user_data)->next = prev_b;
+ G_SLIST (b->user_data)->next = prev_a;
+
+ /* emit signal */
+ order = g_new (gint, store->length);
+ for (j = 0; j < store->length; j++)
+ if (j == a_count)
+ order[j] = b_count;
+ else if (j == b_count)
+ order[j] = a_count;
+ else
+ order[j] = j;
+
+ 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:
+ * @store: A #GtkTreeStore.
+ * @iter: A #GtkTreeIter.
+ * @position: A #GtkTreePath.
+ *
+ * Moves @iter in @store to the position before @position. Note that this
+ * function only works with unsorted stores.
+ **/
+void
+gtk_list_store_move (GtkListStore *store,
+ GtkTreeIter *iter,
+ GtkTreePath *position)
+{
+ GSList *i, *prev = NULL, *new_prev = NULL;
+ gint old_pos = 0, j = 0, *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 (VALID_ITER (iter, store));
+ g_return_if_fail (position != NULL);
+
+ if (gtk_tree_path_get_depth (position) != 1)
+ return;
+
+ if (iter->user_data == store->root)
+ prev = NULL;
+ else
+ {
+ for (i = store->root; i; i = i->next, old_pos++)
+ if (i->next == iter->user_data)
+ {
+ prev = i;
+ break;
+ }
+
+ old_pos++;
+ }
+
+ if (old_pos == gtk_tree_path_get_indices (position)[0])
+ return;
+
+ if (gtk_tree_path_get_indices (position)[0] == 0)
+ new_prev = NULL;
+ else
+ {
+ for (i = store->root; i; i = i->next, j++)
+ if (j == gtk_tree_path_get_indices (position)[0] - 1)
+ {
+ new_prev = i;
+ break;
+ }
+ }
+
+ if (!prev)
+ store->root = G_SLIST (iter->user_data)->next;
+ else
+ prev->next = G_SLIST (iter->user_data)->next;
+
+ if (!new_prev)
+ {
+ G_SLIST (iter->user_data)->next = store->root;
+ store->root = G_SLIST (iter->user_data);
+ }
+ else
+ {
+ G_SLIST (iter->user_data)->next = new_prev->next;
+ new_prev->next = G_SLIST (iter->user_data);
+ }
+
+ /* emit signal */
+ order = g_new (gint, store->length);
+ for (j = 0; j < store->length; j++)
+ if (j < old_pos)
+ order[j] = j;
+ else if (j >= old_pos && j < gtk_tree_path_get_indices (position)[0])
+ order[j] = j + 1;
+ else if (j == gtk_tree_path_get_indices (position)[0])
+ order[j] = old_pos;
+ else
+ order[j] = j;
+
+ 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);
+}
+
+/* Sorting */
static gint
gtk_list_store_compare_func (gconstpointer a,
gconstpointer b,
void gtk_list_store_clear (GtkListStore *list_store);
gboolean gtk_list_store_iter_is_valid (GtkListStore *list_store,
GtkTreeIter *iter);
+void gtk_list_store_reorder (GtkListStore *store,
+ gint *new_order);
+void gtk_list_store_swap (GtkListStore *store,
+ GtkTreeIter *a,
+ GtkTreeIter *b);
+void gtk_list_store_move (GtkListStore *store,
+ GtkTreeIter *iter,
+ GtkTreePath *position);
#ifdef __cplusplus
return retval;
}
+/**
+ * gtk_tree_path_new_from_indices:
+ * @first_index and @varargs: list of integers terminated by -1
+ *
+ * Creates a new path with @first_index and @varargs as indices.
+ *
+ * Return value: A newly created GtkTreePath.
+ **/
+GtkTreePath *
+gtk_tree_path_new_from_indices (gint first_index,
+ ...)
+{
+ int arg;
+ va_list args;
+ GtkTreePath *path;
+
+ path = gtk_tree_path_new ();
+
+ va_start (args, first_index);
+ arg = first_index;
+
+ while (arg != -1)
+ {
+ gtk_tree_path_append_index (path, arg);
+ arg = va_arg (args, gint);
+ }
+
+ va_end (args);
+
+ return path;
+}
+
/**
* gtk_tree_path_to_string:
* @path: A #GtkTreePath
/* GtkTreePath operations */
GtkTreePath *gtk_tree_path_new (void);
GtkTreePath *gtk_tree_path_new_from_string (const gchar *path);
+GtkTreePath *gtk_tree_path_new_from_indices (gint first_index,
+ ...);
gchar *gtk_tree_path_to_string (GtkTreePath *path);
#define gtk_tree_path_new_root() gtk_tree_path_new_first()
GtkTreePath *gtk_tree_path_new_first (void);
void _gtk_tree_view_column_unrealize_button (GtkTreeViewColumn *column);
void _gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column,
GtkTreeView *tree_view);
+void _gtk_tree_view_column_unset_model (GtkTreeViewColumn *column,
+ GtkTreeModel *old_model);
void _gtk_tree_view_column_unset_tree_view (GtkTreeViewColumn *column);
void _gtk_tree_view_column_set_width (GtkTreeViewColumn *column,
gint width);
tree_store->column_headers[column] = type;
}
-static void
+static gboolean
node_free (GNode *node, gpointer data)
{
_gtk_tree_data_list_free (node->data, (GType*)data);
+ return FALSE;
}
static void
{
GtkTreeStore *tree_store = GTK_TREE_STORE (object);
- g_node_children_foreach (tree_store->root, G_TRAVERSE_ALL, node_free, tree_store->column_headers);
+ g_node_traverse (tree_store->root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
+ node_free, tree_store->column_headers);
_gtk_tree_data_list_header_free (tree_store->sort_list);
g_free (tree_store->column_headers);
return retval;
}
-/* Sorting */
+/* Sorting and reordering */
typedef struct _SortTuple
{
gint offset;
GNode *node;
} SortTuple;
+/* Reordering */
+static gint
+gtk_tree_store_reorder_func (gconstpointer a,
+ gconstpointer b,
+ gpointer user_data)
+{
+ SortTuple *a_reorder;
+ SortTuple *b_reorder;
+
+ a_reorder = (SortTuple *)a;
+ b_reorder = (SortTuple *)b;
+
+ if (a_reorder->offset < b_reorder->offset)
+ return -1;
+ if (a_reorder->offset > b_reorder->offset)
+ return 1;
+
+ return 0;
+}
+
+/**
+ * gtk_tree_store_reorder:
+ * @store: A #GtkTreeStore.
+ * @parent: A #GtkTreeIter.
+ * @new_order: An integer array indication the new order for the list.
+ *
+ * Reorders the children of @parent in @store to follow the order
+ * indicated by @new_order. Note that this function only works with
+ * unsorted stores.
+ **/
+void
+gtk_tree_store_reorder (GtkTreeStore *store,
+ GtkTreeIter *parent,
+ gint *new_order)
+{
+ gint i, length = 0;
+ GNode *level, *node;
+ GtkTreePath *path;
+ SortTuple *sort_array;
+
+ g_return_if_fail (GTK_IS_TREE_STORE (store));
+ g_return_if_fail (!GTK_TREE_STORE_IS_SORTED (store));
+ g_return_if_fail (parent == NULL || VALID_ITER (parent, store));
+ g_return_if_fail (new_order != NULL);
+
+ if (!parent)
+ level = G_NODE (store->root)->children;
+ else
+ level = G_NODE (parent->user_data)->children;
+
+ /* count nodes */
+ node = level;
+ while (node)
+ {
+ length++;
+ node = node->next;
+ }
+
+ /* set up sortarray */
+ sort_array = g_new (SortTuple, length);
+
+ node = level;
+ for (i = 0; i < length; i++)
+ {
+ sort_array[i].offset = new_order[i];
+ sort_array[i].node = node;
+
+ node = node->next;
+ }
+
+ g_qsort_with_data (sort_array,
+ length,
+ sizeof (SortTuple),
+ gtk_tree_store_reorder_func,
+ NULL);
+
+ /* fix up level */
+ for (i = 0; i < length - 1; i++)
+ {
+ sort_array[i].node->next = sort_array[i+1].node;
+ sort_array[i+1].node->prev = sort_array[i].node;
+ }
+
+ sort_array[length-1].node->next = NULL;
+ sort_array[0].node->prev = NULL;
+ if (parent)
+ G_NODE (parent->user_data)->children = sort_array[0].node;
+ else
+ G_NODE (store->root)->children = sort_array[0].node;
+
+ /* emit signal */
+ if (parent)
+ path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), parent);
+ else
+ path = gtk_tree_path_new ();
+ gtk_tree_model_rows_reordered (GTK_TREE_MODEL (store), path,
+ parent, new_order);
+ gtk_tree_path_free (path);
+ g_free (sort_array);
+}
+
+/**
+ * gtk_tree_store_swap:
+ * @store: A #GtkTreeStore.
+ * @a: A #GtkTreeIter.
+ * @b: Another #GtkTreeIter.
+ *
+ * Swaps @a and @b in the same level of @store. Note that this function
+ * only works with unsorted stores.
+ **/
+void
+gtk_tree_store_swap (GtkTreeStore *store,
+ GtkTreeIter *a,
+ GtkTreeIter *b)
+{
+ GNode *tmp, *node_a, *node_b, *parent_node;
+ gint i, a_count, b_count, length, *order;
+ GtkTreePath *path_a, *path_b;
+ GtkTreeIter parent;
+
+ g_return_if_fail (GTK_IS_TREE_STORE (store));
+ g_return_if_fail (VALID_ITER (a, store));
+ g_return_if_fail (VALID_ITER (b, store));
+
+ node_a = G_NODE (a->user_data);
+ node_b = G_NODE (b->user_data);
+
+ /* basic sanity checking */
+ if (node_a == node_b)
+ return;
+
+ path_a = gtk_tree_model_get_path (GTK_TREE_MODEL (store), a);
+ path_b = gtk_tree_model_get_path (GTK_TREE_MODEL (store), b);
+
+ g_return_if_fail (path_a && path_b);
+
+ gtk_tree_path_up (path_a);
+ gtk_tree_path_up (path_b);
+
+ if (gtk_tree_path_compare (path_a, path_b))
+ {
+ gtk_tree_path_free (path_a);
+ gtk_tree_path_free (path_b);
+
+ g_warning ("Given childs are not in the same level\n");
+ return;
+ }
+
+ gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &parent, path_a);
+ parent_node = G_NODE (parent.user_data);
+
+ gtk_tree_path_free (path_b);
+
+ /* counting nodes */
+ tmp = parent_node;
+ i = a_count = b_count = 0;
+ while (tmp)
+ {
+ if (tmp == node_a)
+ a_count = i;
+ if (tmp == node_b)
+ b_count = i;
+
+ tmp = tmp->next;
+ i++;
+ }
+ length = i;
+
+ /* hacking the tree */
+ if (!node_a->prev)
+ parent_node->children = node_b;
+ else
+ node_a->prev->next = node_b;
+
+ if (!node_b->prev)
+ parent_node->children = node_a;
+ else
+ node_b->prev->next = node_a;
+
+ if (node_a->next)
+ node_a->next->prev = node_b;
+
+ if (node_b->next)
+ node_b->next->prev = node_a;
+
+ tmp = node_a->next;
+ node_a->next = node_b->next;
+ node_b->next = tmp;
+
+ tmp = node_a->prev;
+ node_a->prev = node_b->prev;
+ node_b->prev = tmp;
+
+ /* emit signal */
+ order = g_new (gint, length);
+ for (i = 0; i < length; i++)
+ if (i == a_count)
+ order[i] = b_count;
+ else if (i == b_count)
+ order[i] = a_count;
+ else
+ order[i] = i;
+
+ gtk_tree_model_rows_reordered (GTK_TREE_MODEL (store), path_a,
+ &parent, order);
+ gtk_tree_path_free (path_a);
+ g_free (order);
+}
+
+/**
+ * gtk_tree_store_move:
+ * @store: A #GtkTreeStore.
+ * @iter: A #GtkTreeIter.
+ * @position: A #GtkTreePath.
+ *
+ * Moves @iter in @store to the position before @position. @iter and
+ * @position should be in the same level. Note that this function only
+ * works with unsorted stores.
+ **/
+void
+gtk_tree_store_move (GtkTreeStore *store,
+ GtkTreeIter *iter,
+ GtkTreePath *position)
+{
+ GNode *tmp, *new_prev, *new_next, *old_prev, *old_next;
+ gint old_pos, new_pos, length, i, *order;
+ GtkTreePath *path, *tmppath;
+ GtkTreeIter parent, new_iter;
+
+ g_return_if_fail (GTK_IS_TREE_STORE (store));
+ g_return_if_fail (!GTK_TREE_STORE_IS_SORTED (store));
+ g_return_if_fail (VALID_ITER (iter, store));
+ g_return_if_fail (position != NULL);
+
+ /* sanity checks */
+ path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter);
+
+ if (!gtk_tree_path_compare (path, position))
+ {
+ gtk_tree_path_free (path);
+ return;
+ }
+
+ if (gtk_tree_path_get_depth (path) != gtk_tree_path_get_depth (position))
+ {
+ gtk_tree_path_free (path);
+
+ g_warning ("Given childs are not in the same level\n");
+ return;
+ }
+
+ tmppath = gtk_tree_path_copy (position);
+ gtk_tree_path_up (path);
+ gtk_tree_path_up (tmppath);
+
+ if (gtk_tree_path_compare (path, tmppath))
+ {
+ gtk_tree_path_free (path);
+ gtk_tree_path_free (tmppath);
+
+ g_warning ("Given childs are not in the same level\n");
+ return;
+ }
+
+ gtk_tree_path_free (tmppath);
+ gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &parent, path);
+
+ gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &new_iter, position);
+
+ new_prev = G_NODE (new_iter.user_data)->prev;
+ new_next = G_NODE (new_iter.user_data);
+
+ old_prev = G_NODE (iter->user_data)->prev;
+ old_next = G_NODE (iter->user_data)->next;
+
+ /* counting nodes */
+ tmp = G_NODE (parent.user_data);
+ length = old_pos = 0;
+ while (tmp)
+ {
+ if (tmp == iter->user_data)
+ old_pos = length;
+
+ tmp = tmp->next;
+ length++;
+ }
+
+ /* hacking the tree */
+ if (!old_prev)
+ G_NODE (parent.user_data)->children = old_next;
+ else
+ old_prev->next = old_next;
+
+ if (old_next)
+ old_next->prev = old_prev;
+
+ if (!new_prev)
+ G_NODE (parent.user_data)->children = iter->user_data;
+ else
+ new_prev->next = iter->user_data;
+
+ if (new_next)
+ new_next->prev = iter->user_data;
+
+ G_NODE (iter->user_data)->prev = new_prev;
+ G_NODE (iter->user_data)->next = new_next;
+
+ /* emit signal */
+ new_pos = gtk_tree_path_get_indices (position)[gtk_tree_path_get_depth (position)-1];
+ order = g_new (gint, length);
+ for (i = 0; i < length; i++)
+ if (i < old_pos)
+ order[i] = i;
+ else if (i >= old_pos && i < new_pos)
+ order[i] = i + 1;
+ else if (i == new_pos)
+ order[i] = old_pos;
+ else
+ order[i] = i;
+
+ 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);
+}
+
+/* Sorting */
static gint
gtk_tree_store_compare_func (gconstpointer a,
gconstpointer b,
void gtk_tree_store_clear (GtkTreeStore *tree_store);
gboolean gtk_tree_store_iter_is_valid (GtkTreeStore *tree_store,
GtkTreeIter *iter);
+void gtk_tree_store_reorder (GtkTreeStore *tree_store,
+ GtkTreeIter *parent,
+ gint *new_order);
+void gtk_tree_store_swap (GtkTreeStore *store,
+ GtkTreeIter *a,
+ GtkTreeIter *b);
+void gtk_tree_store_move (GtkTreeStore *store,
+ GtkTreeIter *iter,
+ GtkTreePath *position);
#ifdef __cplusplus
}
if (column == NULL)
- return FALSE;
+ {
+ gtk_tree_path_free (path);
+
+ return FALSE;
+ }
/* decide if we edit */
if (event->type == GDK_BUTTON_PRESS &&
&area,
(GdkEvent *)event,
flags);
+ g_free (path_string);
gtk_tree_path_free (path);
gtk_tree_path_free (anchor);
return TRUE;
gtk_tree_view_column_cell_get_size (column,
NULL, NULL, NULL,
&tmp_width, &tmp_height);
+
height = MAX (height, tmp_height);
height = MAX (height, tree_view->priv->expander_size);
while (new_node && new_node->left != new_tree->nil)
new_node = new_node->left;
- g_return_val_if_fail (gtk_tree_model_iter_children (model, &child, iter), FALSE);
+ if (!gtk_tree_model_iter_children (model, &child, iter))
+ return FALSE;
+
retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
}
if (tree_view->priv->model)
{
+ GList *tmplist = tree_view->priv->columns;
+
gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
g_signal_handlers_disconnect_by_func (G_OBJECT (tree_view->priv->model),
(gpointer) gtk_tree_view_row_deleted, tree_view);
g_signal_handlers_disconnect_by_func (G_OBJECT (tree_view->priv->model),
(gpointer) gtk_tree_view_rows_reordered, tree_view);
+
+ for (; tmplist; tmplist = tmplist->next)
+ _gtk_tree_view_column_unset_model (tmplist->data,
+ tree_view->priv->model);
+
if (tree_view->priv->tree)
{
_gtk_rbtree_free (tree_view->priv->tree);
if (path)
{
+ gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
+
/* Get vertical coords */
- if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
- tree == NULL)
+ if ((!ret && tree == NULL) || ret)
return;
rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
GParamSpec *pspec);
static void gtk_tree_view_column_finalize (GObject *object);
-/* Button handling code */
+/* Button handling code */
static void gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column);
static void gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column);
GtkSortType real_order;
if (tree_column->sort_column_changed_signal == 0)
- tree_column->sort_column_changed_signal =
+ tree_column->sort_column_changed_signal =
g_signal_connect (G_OBJECT (model), "sort_column_changed",
GTK_SIGNAL_FUNC (gtk_tree_view_model_sort_column_changed),
tree_column);
column->window = NULL;
}
+void
+_gtk_tree_view_column_unset_model (GtkTreeViewColumn *column,
+ GtkTreeModel *old_model)
+{
+ if (column->sort_column_changed_signal)
+ g_signal_handler_disconnect (G_OBJECT (old_model),
+ column->sort_column_changed_signal);
+ column->sort_column_changed_signal = 0;
+}
+
void
_gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column,
GtkTreeView *tree_view)
projects / ~andy / gtk / commitdiff