X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;ds=sidebyside;f=gtk%2Fgtktreemodelsort.c;h=20b0f53239a5567d765dca5a8d5495e2a6368684;hb=75e6b53a78140092a500dac9c71e438111f1cc9b;hp=373edbb6b3b0c22d21a6e3165dae01c14894f8c4;hpb=e05a96609d5f3c2725ab2a7a35438cd2c6aed8c2;p=~andy%2Fgtk diff --git a/gtk/gtktreemodelsort.c b/gtk/gtktreemodelsort.c index 373edbb6b..20b0f5323 100644 --- a/gtk/gtktreemodelsort.c +++ b/gtk/gtktreemodelsort.c @@ -37,13 +37,17 @@ * we warned you and we're not liable for any head injuries. */ +#include +#include + #include "gtktreemodelsort.h" #include "gtktreesortable.h" #include "gtktreestore.h" -#include "gtksignal.h" #include "gtktreedatalist.h" -#include #include "gtkintl.h" +#include "gtkprivate.h" +#include "gtktreednd.h" +#include "gtkalias.h" typedef struct _SortElt SortElt; typedef struct _SortLevel SortLevel; @@ -97,7 +101,7 @@ enum { #define SORT_ELT(sort_elt) ((SortElt *)sort_elt) #define SORT_LEVEL(sort_level) ((SortLevel *)sort_level) -#define GET_CHILD_ITER(tree_model_sort,child_iter,sort_iter) gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT (tree_model_sort), child_iter, sort_iter); +#define GET_CHILD_ITER(tree_model_sort,ch_iter,so_iter) gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT (tree_model_sort), ch_iter, so_iter); #define NO_SORT_FUNC ((GtkTreeIterCompareFunc) 0x1) @@ -108,6 +112,7 @@ static void gtk_tree_model_sort_init (GtkTreeModelSort *tr static void gtk_tree_model_sort_class_init (GtkTreeModelSortClass *tree_model_sort_class); static void gtk_tree_model_sort_tree_model_init (GtkTreeModelIface *iface); static void gtk_tree_model_sort_tree_sortable_init (GtkTreeSortableIface *iface); +static void gtk_tree_model_sort_drag_source_init (GtkTreeDragSourceIface*iface); static void gtk_tree_model_sort_finalize (GObject *object); static void gtk_tree_model_sort_set_property (GObject *object, guint prop_id, @@ -178,6 +183,15 @@ static void gtk_tree_model_sort_real_unref_node (GtkTreeModel static void gtk_tree_model_sort_unref_node (GtkTreeModel *tree_model, GtkTreeIter *iter); +/* TreeDragSource interface */ +static gboolean gtk_tree_model_sort_row_draggable (GtkTreeDragSource *drag_source, + GtkTreePath *path); +static gboolean gtk_tree_model_sort_drag_data_get (GtkTreeDragSource *drag_source, + GtkTreePath *path, + GtkSelectionData *selection_data); +static gboolean gtk_tree_model_sort_drag_data_delete (GtkTreeDragSource *drag_source, + GtkTreePath *path); + /* TreeSortable interface */ static gboolean gtk_tree_model_sort_get_sort_column_id (GtkTreeSortable *sortable, gint *sort_column_id, @@ -211,7 +225,7 @@ static void gtk_tree_model_sort_sort (GtkTreeModelSort *tre static gint gtk_tree_model_sort_level_find_insert (GtkTreeModelSort *tree_model_sort, SortLevel *level, GtkTreeIter *iter, - gboolean skip_sort_elt); + gint skip_index); static gboolean gtk_tree_model_sort_insert_value (GtkTreeModelSort *tree_model_sort, SortLevel *level, GtkTreePath *s_path, @@ -260,9 +274,17 @@ gtk_tree_model_sort_get_type (void) NULL }; - tree_model_sort_type = g_type_register_static (G_TYPE_OBJECT, - "GtkTreeModelSort", - &tree_model_sort_info, 0); + static const GInterfaceInfo drag_source_info = + { + (GInterfaceInitFunc) gtk_tree_model_sort_drag_source_init, + NULL, + NULL + }; + + tree_model_sort_type = + g_type_register_static (G_TYPE_OBJECT, I_("GtkTreeModelSort"), + &tree_model_sort_info, 0); + g_type_add_interface_static (tree_model_sort_type, GTK_TYPE_TREE_MODEL, &tree_model_info); @@ -270,6 +292,10 @@ gtk_tree_model_sort_get_type (void) g_type_add_interface_static (tree_model_sort_type, GTK_TYPE_TREE_SORTABLE, &sortable_info); + + g_type_add_interface_static (tree_model_sort_type, + GTK_TYPE_TREE_DRAG_SOURCE, + &drag_source_info); } return tree_model_sort_type; @@ -302,10 +328,10 @@ gtk_tree_model_sort_class_init (GtkTreeModelSortClass *class) g_object_class_install_property (object_class, PROP_MODEL, g_param_spec_object ("model", - _("TreeModelSort Model"), - _("The model for the TreeModelSort to sort"), + P_("TreeModelSort Model"), + P_("The model for the TreeModelSort to sort"), GTK_TYPE_TREE_MODEL, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); } static void @@ -337,11 +363,19 @@ gtk_tree_model_sort_tree_sortable_init (GtkTreeSortableIface *iface) iface->has_default_sort_func = gtk_tree_model_sort_has_default_sort_func; } +static void +gtk_tree_model_sort_drag_source_init (GtkTreeDragSourceIface *iface) +{ + iface->row_draggable = gtk_tree_model_sort_row_draggable; + iface->drag_data_delete = gtk_tree_model_sort_drag_data_delete; + iface->drag_data_get = gtk_tree_model_sort_drag_data_get; +} + /** * gtk_tree_model_sort_new_with_model: * @child_model: A #GtkTreeModel * - * Creates a new #GtkTreeModel, with @child_model as the child_model. + * Creates a new #GtkTreeModel, with @child_model as the child model. * * Return value: A new #GtkTreeModel. */ @@ -352,7 +386,7 @@ gtk_tree_model_sort_new_with_model (GtkTreeModel *child_model) g_return_val_if_fail (GTK_IS_TREE_MODEL (child_model), NULL); - retval = GTK_TREE_MODEL (g_object_new (gtk_tree_model_sort_get_type (), NULL)); + retval = g_object_new (gtk_tree_model_sort_get_type (), NULL); gtk_tree_model_sort_set_model (GTK_TREE_MODEL_SORT (retval), child_model); @@ -435,7 +469,7 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, gboolean free_s_path = FALSE; - gint offset, index = 0, i; + gint index = 0, old_index, i; g_return_if_fail (start_s_path != NULL || start_s_iter != NULL); @@ -460,6 +494,8 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, level = iter.user_data; elt = iter.user_data2; + level->ref_count++; + if (level->array->len < 2 || (tree_model_sort->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID && tree_model_sort->default_sort_func == NO_SORT_FUNC)) @@ -471,36 +507,46 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, gtk_tree_path_free (path); + level->ref_count--; + return; } - + if (!GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort)) { gtk_tree_model_get_iter (tree_model_sort->child_model, &tmpiter, start_s_path); } - offset = elt->offset; - - for (i = 0; i < level->array->len; i++) - if (elt->offset == g_array_index (level->array, SortElt, i).offset) - index = i; + old_index = elt - SORT_ELT (level->array->data); memcpy (&tmp, elt, sizeof (SortElt)); - g_array_remove_index (level->array, index); if (GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort)) index = gtk_tree_model_sort_level_find_insert (tree_model_sort, level, &tmp.iter, - TRUE); + old_index); else index = gtk_tree_model_sort_level_find_insert (tree_model_sort, level, &tmpiter, - TRUE); + old_index); - g_array_insert_val (level->array, index, tmp); + if (index < old_index) + { + g_memmove (level->array->data + ((index + 1)*sizeof (SortElt)), + level->array->data + ((index)*sizeof (SortElt)), + (old_index - index)* sizeof(SortElt)); + } + else if (index > old_index) + { + g_memmove (level->array->data + ((old_index)*sizeof (SortElt)), + level->array->data + ((old_index + 1)*sizeof (SortElt)), + (index - old_index)* sizeof(SortElt)); + } + memcpy (level->array->data + ((index)*sizeof (SortElt)), + &tmp, sizeof (SortElt)); for (i = 0; i < level->array->len; i++) if (g_array_index (level->array, SortElt, i).children) @@ -510,8 +556,68 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, gtk_tree_path_append_index (path, index); gtk_tree_model_sort_increment_stamp (tree_model_sort); - gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path); + /* if the item moved, then emit rows_reordered */ + if (old_index != index) + { + gint *new_order; + gint j; + + GtkTreePath *tmppath; + + new_order = g_new (gint, level->array->len); + + for (j = 0; j < level->array->len; j++) + { + if (index > old_index) + { + if (j == index) + new_order[j] = old_index; + else if (j >= old_index && j < index) + new_order[j] = j + 1; + else + new_order[j] = j; + } + else if (index < old_index) + { + if (j == index) + new_order[j] = old_index; + else if (j > index && j <= old_index) + new_order[j] = j - 1; + else + new_order[j] = j; + } + /* else? shouldn't really happen */ + } + + if (level->parent_elt) + { + iter.stamp = tree_model_sort->stamp; + iter.user_data = level->parent_level; + iter.user_data2 = level->parent_elt; + + tmppath = gtk_tree_model_get_path (GTK_TREE_MODEL (tree_model_sort), &iter); + + gtk_tree_model_rows_reordered (GTK_TREE_MODEL (tree_model_sort), + tmppath, &iter, new_order); + } + else + { + /* toplevel */ + tmppath = gtk_tree_path_new (); + + gtk_tree_model_rows_reordered (GTK_TREE_MODEL (tree_model_sort), tmppath, + NULL, new_order); + } + + gtk_tree_path_free (tmppath); + g_free (new_order); + } + + level->ref_count--; + + /* emit row_changed signal (at new location) */ + gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path); gtk_tree_model_row_changed (GTK_TREE_MODEL (data), path, &iter); gtk_tree_path_free (path); @@ -594,22 +700,6 @@ gtk_tree_model_sort_row_inserted (GtkTreeModel *s_model, if (!elt->children) { - GtkTreePath *tmppath; - GtkTreeIter tmpiter; - - tmpiter.stamp = tree_model_sort->stamp; - tmpiter.user_data = level; - tmpiter.user_data2 = elt; - - tmppath = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &tmpiter); - if (tmppath) - { - gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), - tmppath, - &tmpiter); - gtk_tree_path_free (tmppath); - } - /* not covering this signal */ goto done; } @@ -622,6 +712,12 @@ gtk_tree_model_sort_row_inserted (GtkTreeModel *s_model, if (!parent_level) goto done; + if (level->ref_count == 0 && level != tree_model_sort->root) + { + gtk_tree_model_sort_free_level (tree_model_sort, level); + goto done; + } + if (!gtk_tree_model_sort_insert_value (tree_model_sort, parent_level, s_path, @@ -708,12 +804,20 @@ gtk_tree_model_sort_row_deleted (GtkTreeModel *s_model, while (elt->ref_count > 0) gtk_tree_model_sort_real_unref_node (GTK_TREE_MODEL (data), &iter, FALSE); - if (level->ref_count == 0 && level != tree_model_sort->root) + if (level->ref_count == 0) { - /* This will prune the level, so I can just emit the signal and not worry - * about cleaning this level up. */ + /* This will prune the level, so I can just emit the signal and + * not worry about cleaning this level up. + * Careful, root level is not cleaned up in increment stamp. + */ gtk_tree_model_sort_increment_stamp (tree_model_sort); gtk_tree_path_free (path); + if (level == tree_model_sort->root) + { + gtk_tree_model_sort_free_level (tree_model_sort, + tree_model_sort->root); + tree_model_sort->root = NULL; + } return; } @@ -832,7 +936,15 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model, static GtkTreeModelFlags gtk_tree_model_sort_get_flags (GtkTreeModel *tree_model) { + GtkTreeModelFlags flags; + g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model), 0); + g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->child_model != NULL, 0); + + flags = gtk_tree_model_get_flags (GTK_TREE_MODEL_SORT (tree_model)->child_model); + + if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY) + return GTK_TREE_MODEL_LIST_ONLY; return 0; } @@ -895,8 +1007,12 @@ gtk_tree_model_sort_get_iter (GtkTreeModel *tree_model, level = g_array_index (level->array, SortElt, indices[i]).children; } - if (level == NULL) - return FALSE; + if (!level || indices[i] >= level->array->len) + { + iter->stamp = 0; + return FALSE; + } + iter->stamp = tree_model_sort->stamp; iter->user_data = level; iter->user_data2 = &g_array_index (level->array, SortElt, indices[depth - 1]); @@ -1154,7 +1270,6 @@ gtk_tree_model_sort_real_unref_node (GtkTreeModel *tree_model, gboolean propagate_unref) { GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model; - GtkTreeIter child_iter; SortLevel *level; SortElt *elt; @@ -1162,10 +1277,13 @@ gtk_tree_model_sort_real_unref_node (GtkTreeModel *tree_model, g_return_if_fail (GTK_TREE_MODEL_SORT (tree_model)->child_model != NULL); g_return_if_fail (GTK_TREE_MODEL_SORT (tree_model)->stamp == iter->stamp); - GET_CHILD_ITER (tree_model, &child_iter, iter); - if (propagate_unref) - gtk_tree_model_unref_node (GTK_TREE_MODEL_SORT (tree_model)->child_model, &child_iter); + { + GtkTreeIter child_iter; + + GET_CHILD_ITER (tree_model, &child_iter, iter); + gtk_tree_model_unref_node (GTK_TREE_MODEL_SORT (tree_model)->child_model, &child_iter); + } level = iter->user_data; elt = iter->user_data2; @@ -1174,6 +1292,7 @@ gtk_tree_model_sort_real_unref_node (GtkTreeModel *tree_model, elt->ref_count--; level->ref_count--; + if (level->ref_count == 0) { SortLevel *parent_level = level->parent_level; @@ -1208,14 +1327,15 @@ gtk_tree_model_sort_get_sort_column_id (GtkTreeSortable *sortable, g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (sortable), FALSE); - if (tree_model_sort->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) - return FALSE; - if (sort_column_id) *sort_column_id = tree_model_sort->sort_column_id; if (order) *order = tree_model_sort->order; + if (tree_model_sort->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID || + tree_model_sort->sort_column_id == GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID) + return FALSE; + return TRUE; } @@ -1256,8 +1376,9 @@ gtk_tree_model_sort_set_sort_column_id (GtkTreeSortable *sortable, tree_model_sort->sort_column_id = sort_column_id; tree_model_sort->order = order; - gtk_tree_model_sort_sort (tree_model_sort); gtk_tree_sortable_sort_column_changed (sortable); + + gtk_tree_model_sort_sort (tree_model_sort); } static void @@ -1305,6 +1426,9 @@ gtk_tree_model_sort_set_sort_func (GtkTreeSortable *sortable, header->func = func; header->data = data; header->destroy = destroy; + + if (tree_model_sort->sort_column_id == sort_column_id) + gtk_tree_model_sort_sort (tree_model_sort); } static void @@ -1328,6 +1452,9 @@ gtk_tree_model_sort_set_default_sort_func (GtkTreeSortable *sortable, tree_model_sort->default_sort_func = func; tree_model_sort->default_sort_data = data; tree_model_sort->default_sort_destroy = destroy; + + if (tree_model_sort->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) + gtk_tree_model_sort_sort (tree_model_sort); } static gboolean @@ -1340,6 +1467,65 @@ gtk_tree_model_sort_has_default_sort_func (GtkTreeSortable *sortable) return (tree_model_sort->default_sort_func != NULL); } +/* DragSource interface */ +static gboolean +gtk_tree_model_sort_row_draggable (GtkTreeDragSource *drag_source, + GtkTreePath *path) +{ + GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *)drag_source; + GtkTreePath *child_path; + gboolean draggable; + + g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (drag_source), FALSE); + g_return_val_if_fail (path != NULL, FALSE); + + child_path = gtk_tree_model_sort_convert_path_to_child_path (tree_model_sort, + path); + draggable = gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (tree_model_sort->child_model), child_path); + gtk_tree_path_free (child_path); + + return draggable; +} + +static gboolean +gtk_tree_model_sort_drag_data_get (GtkTreeDragSource *drag_source, + GtkTreePath *path, + GtkSelectionData *selection_data) +{ + GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *)drag_source; + GtkTreePath *child_path; + gboolean gotten; + + g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (drag_source), FALSE); + g_return_val_if_fail (path != NULL, FALSE); + + child_path = gtk_tree_model_sort_convert_path_to_child_path (tree_model_sort, + path); + gotten = gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (tree_model_sort->child_model), child_path, selection_data); + gtk_tree_path_free (child_path); + + return gotten; +} + +static gboolean +gtk_tree_model_sort_drag_data_delete (GtkTreeDragSource *drag_source, + GtkTreePath *path) +{ + GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *)drag_source; + GtkTreePath *child_path; + gboolean deleted; + + g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (drag_source), FALSE); + g_return_val_if_fail (path != NULL, FALSE); + + child_path = gtk_tree_model_sort_convert_path_to_child_path (tree_model_sort, + path); + deleted = gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (tree_model_sort->child_model), child_path); + gtk_tree_path_free (child_path); + + return deleted; +} + /* sorting code - private */ static gint gtk_tree_model_sort_compare_func (gconstpointer a, @@ -1438,6 +1624,8 @@ gtk_tree_model_sort_sort_level (GtkTreeModelSort *tree_model_sort, if (level->array->len < 1 && !((SortElt *)level->array->data)->children) return; + level->ref_count++; + /* Set up data */ data.tree_model_sort = tree_model_sort; if (level->parent_elt) @@ -1559,6 +1747,8 @@ gtk_tree_model_sort_sort_level (GtkTreeModelSort *tree_model_sort, } g_free (new_order); + + level->ref_count--; } static void @@ -1592,9 +1782,9 @@ static gint gtk_tree_model_sort_level_find_insert (GtkTreeModelSort *tree_model_sort, SortLevel *level, GtkTreeIter *iter, - gboolean skip_sort_elt) + gint skip_index) { - gint middle; + gint start, middle, end; gint cmp; SortElt *tmp_elt; GtkTreeIter tmp_iter; @@ -1602,8 +1792,6 @@ gtk_tree_model_sort_level_find_insert (GtkTreeModelSort *tree_model_sort, GtkTreeIterCompareFunc func; gpointer data; - GtkTreePath *path; - if (tree_model_sort->sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) { GtkTreeDataSortHeader *header; @@ -1625,19 +1813,36 @@ gtk_tree_model_sort_level_find_insert (GtkTreeModelSort *tree_model_sort, } g_return_val_if_fail (func != NULL, 0); - - for (middle = 0; middle < level->array->len; middle++) - { - tmp_elt = &(g_array_index (level->array, SortElt, middle)); - if (!skip_sort_elt && SORT_ELT (iter->user_data2) == tmp_elt) - continue; + start = 0; + end = level->array->len; + if (skip_index < 0) + skip_index = end; + else + end--; - path = gtk_tree_model_sort_elt_get_path (level, tmp_elt); - gtk_tree_model_get_iter (tree_model_sort->child_model, - &tmp_iter, path); - gtk_tree_path_free (path); + if (start == end) + return 0; + + while (start != end) + { + middle = (start + end) / 2; + if (middle < skip_index) + tmp_elt = &(g_array_index (level->array, SortElt, middle)); + else + tmp_elt = &(g_array_index (level->array, SortElt, middle + 1)); + + if (!GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort)) + { + GtkTreePath *path = gtk_tree_model_sort_elt_get_path (level, tmp_elt); + gtk_tree_model_get_iter (tree_model_sort->child_model, + &tmp_iter, path); + gtk_tree_path_free (path); + } + else + tmp_iter = tmp_elt->iter; + if (tree_model_sort->order == GTK_SORT_ASCENDING) cmp = (* func) (GTK_TREE_MODEL (tree_model_sort->child_model), &tmp_iter, iter, data); @@ -1645,11 +1850,16 @@ gtk_tree_model_sort_level_find_insert (GtkTreeModelSort *tree_model_sort, cmp = (* func) (GTK_TREE_MODEL (tree_model_sort->child_model), iter, &tmp_iter, data); - if (cmp > 0) - break; + if (cmp <= 0) + start = middle + 1; + else + end = middle; } - return middle; + if (cmp <= 0) + return middle + 1; + else + return middle; } static gboolean @@ -1684,7 +1894,7 @@ gtk_tree_model_sort_insert_value (GtkTreeModelSort *tree_model_sort, else index = gtk_tree_model_sort_level_find_insert (tree_model_sort, level, s_iter, - FALSE); + -1); g_array_insert_vals (level->array, index, &elt, 1); tmp_elt = SORT_ELT (level->array->data); @@ -1723,11 +1933,12 @@ gtk_tree_model_sort_elt_get_path (SortLevel *level, /** * gtk_tree_model_sort_set_model: * @tree_model_sort: The #GtkTreeModelSort. - * @child_model: A #GtkTreeModel, or NULL. + * @child_model: A #GtkTreeModel, or %NULL. * - * Sets the model of @tree_model_sort to be @model. If @model is NULL, then the - * old model is unset. The sort function is unset as a result of this call. - * The model will be in an unsorted state until a sort function is set. + * Sets the model of @tree_model_sort to be @model. If @model is %NULL, + * then the old model is unset. The sort function is unset as a result + * of this call. The model will be in an unsorted state until a sort + * function is set. **/ static void gtk_tree_model_sort_set_model (GtkTreeModelSort *tree_model_sort, @@ -1736,19 +1947,19 @@ gtk_tree_model_sort_set_model (GtkTreeModelSort *tree_model_sort, g_return_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model_sort)); if (child_model) - g_object_ref (G_OBJECT (child_model)); + g_object_ref (child_model); if (tree_model_sort->child_model) { - g_signal_handler_disconnect (G_OBJECT (tree_model_sort->child_model), + g_signal_handler_disconnect (tree_model_sort->child_model, tree_model_sort->changed_id); - g_signal_handler_disconnect (G_OBJECT (tree_model_sort->child_model), + g_signal_handler_disconnect (tree_model_sort->child_model, tree_model_sort->inserted_id); - g_signal_handler_disconnect (G_OBJECT (tree_model_sort->child_model), + g_signal_handler_disconnect (tree_model_sort->child_model, tree_model_sort->has_child_toggled_id); - g_signal_handler_disconnect (G_OBJECT (tree_model_sort->child_model), + g_signal_handler_disconnect (tree_model_sort->child_model, tree_model_sort->deleted_id); - g_signal_handler_disconnect (G_OBJECT (tree_model_sort->child_model), + g_signal_handler_disconnect (tree_model_sort->child_model, tree_model_sort->reordered_id); /* reset our state */ @@ -1757,7 +1968,7 @@ gtk_tree_model_sort_set_model (GtkTreeModelSort *tree_model_sort, tree_model_sort->root = NULL; _gtk_tree_data_list_header_free (tree_model_sort->sort_list); tree_model_sort->sort_list = NULL; - g_object_unref (G_OBJECT (tree_model_sort->child_model)); + g_object_unref (tree_model_sort->child_model); } tree_model_sort->child_model = child_model; @@ -1767,7 +1978,6 @@ gtk_tree_model_sort_set_model (GtkTreeModelSort *tree_model_sort, GType *types; gint i, n_columns; - g_object_ref (tree_model_sort->child_model); tree_model_sort->changed_id = g_signal_connect (child_model, "row_changed", G_CALLBACK (gtk_tree_model_sort_row_changed), @@ -1890,8 +2100,8 @@ gtk_real_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_mode * * Converts @child_path to a path relative to @tree_model_sort. That is, * @child_path points to a path in the child model. The returned path will - * point to the same row in the sorted model. If @child_path isn't a valid path - * on the child model, then %NULL is returned. + * point to the same row in the sorted model. If @child_path isn't a valid + * path on the child model, then %NULL is returned. * * Return value: A newly allocated #GtkTreePath, or %NULL **/ @@ -1945,10 +2155,11 @@ gtk_tree_model_sort_convert_child_iter_to_iter (GtkTreeModelSort *tree_model_sor * @tree_model_sort: A #GtkTreeModelSort * @sorted_path: A #GtkTreePath to convert * - * Converts @sorted_path to a path on the child model of @tree_model_sort. That - * is, @sorted_path points to a location in @tree_model_sort. The returned path - * will point to the same location in the model not being sorted. If @sorted_path - * does not point to a location in the child model, %NULL is returned. + * Converts @sorted_path to a path on the child model of @tree_model_sort. + * That is, @sorted_path points to a location in @tree_model_sort. The + * returned path will point to the same location in the model not being + * sorted. If @sorted_path does not point to a location in the child model, + * %NULL is returned. * * Return value: A newly allocated #GtkTreePath, or %NULL **/ @@ -2113,7 +2324,7 @@ gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, if (gtk_tree_model_iter_next (tree_model_sort->child_model, &iter) == FALSE && i < length - 1) { - g_warning ("There is a discrepency between the sort model and the child model."); + g_warning ("There is a discrepancy between the sort model and the child model."); return; } } @@ -2280,12 +2491,15 @@ gtk_tree_model_sort_iter_is_valid_helper (GtkTreeIter *iter, * @tree_model_sort: A #GtkTreeModelSort. * @iter: A #GtkTreeIter. * - * WARNING: This function is slow. Only use it for debugging and/or testing - * purposes. + * + * This function is slow. Only use it for debugging and/or testing purposes. + * * * Checks if the given iter is a valid iter for this #GtkTreeModelSort. * * Return value: %TRUE if the iter is valid, %FALSE if the iter is invalid. + * + * Since: 2.2 **/ gboolean gtk_tree_model_sort_iter_is_valid (GtkTreeModelSort *tree_model_sort, @@ -2300,3 +2514,6 @@ gtk_tree_model_sort_iter_is_valid (GtkTreeModelSort *tree_model_sort, return gtk_tree_model_sort_iter_is_valid_helper (iter, tree_model_sort->root); } + +#define __GTK_TREE_MODEL_SORT_C__ +#include "gtkaliasdef.c"