X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtktreemodelsort.c;h=b2046c2d8ebf1472863c3a63a08e04fde7a59a38;hb=24fa27732942b074e5a0c5872944cb3ba2fde1aa;hp=e64f3705479e9177f663feec5e70483d508217dd;hpb=dec7a340471c019411d3555254c3219f1208cb3a;p=~andy%2Fgtk diff --git a/gtk/gtktreemodelsort.c b/gtk/gtktreemodelsort.c index e64f37054..b2046c2d8 100644 --- a/gtk/gtktreemodelsort.c +++ b/gtk/gtktreemodelsort.c @@ -13,22 +13,7 @@ * 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, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -/* NOTE: There is a potential for confusion in this code as to whether an iter, - * path or value refers to the GtkTreeModelSort model, or the child model being - * sorted. As a convention, variables referencing the child model will have an - * s_ prefix before them (ie. s_iter, s_value, s_path); - */ - -/* ITER FORMAT: - * - * iter->stamp = tree_model_sort->stamp - * iter->user_data = SortLevel - * iter->user_data2 = SortElt + * License along with this library. If not, see . */ #include "config.h" @@ -150,42 +135,120 @@ */ +/* Notes on this implementation of GtkTreeModelSort + * ================================================ + * + * Warnings + * -------- + * + * In this code there is a potential for confusion as to whether an iter, + * path or value refers to the GtkTreeModelSort model, or to the child model + * that has been set. As a convention, variables referencing the child model + * will have an s_ prefix before them (ie. s_iter, s_value, s_path); + * Conversion of iterators and paths between GtkTreeModelSort and the child + * model is done through the various gtk_tree_model_sort_convert_* functions. + * + * Iterator format + * --------------- + * + * The iterator format of iterators handed out by GtkTreeModelSort is as + * follows: + * + * iter->stamp = tree_model_sort->stamp + * iter->user_data = SortLevel + * iter->user_data2 = SortElt + * + * Internal data structure + * ----------------------- + * + * Using SortLevel and SortElt, GtkTreeModelSort maintains a "cache" of + * the mapping from GtkTreeModelSort nodes to nodes in the child model. + * This is to avoid sorting a level each time an operation is requested + * on GtkTreeModelSort, such as get iter, get path, get value. + * + * A SortElt corresponds to a single node. A node and its siblings are + * stored in a SortLevel. The SortLevel keeps a reference to the parent + * SortElt and its SortLevel (if any). The SortElt can have a "children" + * pointer set, which points at a child level (a sub level). + * + * In a SortLevel, nodes are stored in a GSequence. The GSequence + * allows for fast additions and removals, and supports sorting + * the level of SortElt nodes. + * + * It is important to recognize the two different mappings that play + * a part in this code: + * I. The mapping from the client to this model. The order in which + * nodes are stored in the GSequence is the order in which the + * nodes are exposed to clients of the GtkTreeModelSort. + * II. The mapping from this model to its child model. Each SortElt + * contains an "offset" field which is the offset of the + * corresponding node in the child model. + * + * Reference counting + * ------------------ + * + * GtkTreeModelSort forwards all reference and unreference operations + * to the corresponding node in the child model. The reference count + * of each node is also maintained internally, in the "ref_count" + * fields in SortElt and SortLevel. For each ref and unref operation on + * a SortElt, the "ref_count" of the SortLevel is updated accordingly. + * In addition, if a SortLevel has a parent, a reference is taken on + * this parent. This happens in gtk_tree_model_sort_build_level() and + * the reference is released again in gtk_tree_model_sort_free_level(). + * This ensures that when GtkTreeModelSort takes a reference on a node + * (for example during sorting), all parent nodes are referenced + * according to reference counting rule 1, see the GtkTreeModel + * documentation. + * + * When a level has a reference count of zero, which means that + * none of the nodes in the level is referenced, the level has + * a "zero ref count" on all its parents. As soon as the level + * reaches a reference count of zero, the zero ref count value is + * incremented by one on all parents of this level. Similarly, as + * soon as the reference count of a level changes from zero, the + * zero ref count value is decremented by one on all parents. + * + * The zero ref count value is used to clear unused portions of + * the cache. If a SortElt has a zero ref count of one, then + * its child level is unused and can be removed from the cache. + * If the zero ref count value is higher than one, then the + * child level contains sublevels which are unused as well. + * gtk_tree_model_sort_clear_cache() uses this to not recurse + * into levels which have a zero ref count of zero. + */ + typedef struct _SortElt SortElt; typedef struct _SortLevel SortLevel; typedef struct _SortData SortData; -typedef struct _SortTuple SortTuple; struct _SortElt { - GtkTreeIter iter; - SortLevel *children; - gint offset; - gint ref_count; - gint zero_ref_count; + GtkTreeIter iter; + SortLevel *children; + gint offset; + gint ref_count; + gint zero_ref_count; + GSequenceIter *siter; /* iter into seq */ + gint old_index; /* used while sorting */ }; struct _SortLevel { - GArray *array; + GSequence *seq; gint ref_count; - gint parent_elt_index; + SortElt *parent_elt; SortLevel *parent_level; }; struct _SortData { GtkTreeModelSort *tree_model_sort; - GtkTreePath *parent_path; - gint parent_path_depth; - gint *parent_path_indices; GtkTreeIterCompareFunc sort_func; gpointer sort_data; -}; -struct _SortTuple -{ - SortElt *elt; - gint offset; + GtkTreePath *parent_path; + gint parent_path_depth; + gint *parent_path_indices; }; /* Properties */ @@ -236,9 +299,7 @@ struct _GtkTreeModelSortPrivate #define SORT_ELT(sort_elt) ((SortElt *)sort_elt) #define SORT_LEVEL(sort_level) ((SortLevel *)sort_level) - -#define SORT_LEVEL_PARENT_ELT(level) (&g_array_index (SORT_LEVEL ((level))->parent_level->array, SortElt, SORT_LEVEL ((level))->parent_elt_index)) -#define SORT_LEVEL_ELT_INDEX(level, elt) (SORT_ELT ((elt)) - SORT_ELT (SORT_LEVEL ((level))->array->data)) +#define GET_ELT(siter) ((SortElt *) (siter ? g_sequence_get (siter) : NULL)) #define GET_CHILD_ITER(tree_model_sort,ch_iter,so_iter) gtk_tree_model_sort_convert_iter_to_child_iter((GtkTreeModelSort*)(tree_model_sort), (ch_iter), (so_iter)); @@ -353,7 +414,7 @@ static gboolean gtk_tree_model_sort_has_default_sort_func (GtkTreeSortable /* Private functions (sort funcs, level handling and other utils) */ static void gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, SortLevel *parent_level, - gint parent_elt_index); + SortElt *parent_elt); static void gtk_tree_model_sort_free_level (GtkTreeModelSort *tree_model_sort, SortLevel *sort_level, gboolean unref); @@ -363,10 +424,6 @@ static void gtk_tree_model_sort_sort_level (GtkTreeModelSort *tre gboolean recurse, gboolean emit_reordered); static void gtk_tree_model_sort_sort (GtkTreeModelSort *tree_model_sort); -static gint gtk_tree_model_sort_level_find_insert (GtkTreeModelSort *tree_model_sort, - SortLevel *level, - GtkTreeIter *iter, - gint skip_index); static gboolean gtk_tree_model_sort_insert_value (GtkTreeModelSort *tree_model_sort, SortLevel *level, GtkTreePath *s_path, @@ -379,6 +436,15 @@ static GtkTreePath *gtk_real_tree_model_sort_convert_child_path_to_path (GtkTree GtkTreePath *child_path, gboolean build_levels); +static gint gtk_tree_model_sort_compare_func (gconstpointer a, + gconstpointer b, + gpointer user_data); +static gint gtk_tree_model_sort_offset_compare_func (gconstpointer a, + gconstpointer b, + gpointer user_data); +static void gtk_tree_model_sort_clear_cache_helper (GtkTreeModelSort *tree_model_sort, + SortLevel *level); + G_DEFINE_TYPE_WITH_CODE (GtkTreeModelSort, gtk_tree_model_sort, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL, @@ -556,6 +622,122 @@ gtk_tree_model_sort_get_property (GObject *object, } } +/* helpers */ +static SortElt * +sort_elt_new (void) +{ + return g_slice_new (SortElt); +} + +static void +sort_elt_free (gpointer elt) +{ + g_slice_free (SortElt, elt); +} + +static void +increase_offset_iter (gpointer data, + gpointer user_data) +{ + SortElt *elt = data; + gint offset = GPOINTER_TO_INT (user_data); + + if (elt->offset >= offset) + elt->offset++; +} + +static void +decrease_offset_iter (gpointer data, + gpointer user_data) +{ + SortElt *elt = data; + gint offset = GPOINTER_TO_INT (user_data); + + if (elt->offset > offset) + elt->offset--; +} + +static void +fill_sort_data (SortData *data, + GtkTreeModelSort *tree_model_sort, + SortLevel *level) +{ + GtkTreeModelSortPrivate *priv = tree_model_sort->priv; + + data->tree_model_sort = tree_model_sort; + + if (priv->sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) + { + GtkTreeDataSortHeader *header; + + header = _gtk_tree_data_list_get_header (priv->sort_list, + priv->sort_column_id); + + g_return_if_fail (header != NULL); + g_return_if_fail (header->func != NULL); + + data->sort_func = header->func; + data->sort_data = header->data; + } + else + { + /* absolutely SHOULD NOT happen: */ + g_return_if_fail (priv->default_sort_func != NULL); + + data->sort_func = priv->default_sort_func; + data->sort_data = priv->default_sort_data; + } + + if (level->parent_elt) + { + data->parent_path = gtk_tree_model_sort_elt_get_path (level->parent_level, + level->parent_elt); + gtk_tree_path_append_index (data->parent_path, 0); + } + else + { + data->parent_path = gtk_tree_path_new_first (); + } + data->parent_path_depth = gtk_tree_path_get_depth (data->parent_path); + data->parent_path_indices = gtk_tree_path_get_indices (data->parent_path); +} + +static void +free_sort_data (SortData *data) +{ + gtk_tree_path_free (data->parent_path); +} + +static SortElt * +lookup_elt_with_offset (GtkTreeModelSort *tree_model_sort, + SortLevel *level, + gint offset, + GSequenceIter **ret_siter) +{ + GSequenceIter *siter, *end_siter; + + /* FIXME: We have to do a search like this, because the sequence is not + * (always) sorted on offset order. Perhaps we should introduce a + * second sequence which is sorted on offset order. + */ + end_siter = g_sequence_get_end_iter (level->seq); + for (siter = g_sequence_get_begin_iter (level->seq); + siter != end_siter; + siter = g_sequence_iter_next (siter)) + { + SortElt *elt = g_sequence_get (siter); + + if (elt->offset == offset) + break; + } + + if (ret_siter) + *ret_siter = siter; + + return GET_ELT (siter); +} + + static void gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, GtkTreePath *start_s_path, @@ -568,13 +750,13 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, GtkTreeIter iter; GtkTreeIter tmpiter; - SortElt tmp; SortElt *elt; SortLevel *level; + SortData sort_data; gboolean free_s_path = FALSE; - gint index = 0, old_index, i; + gint index = 0, old_index; g_return_if_fail (start_s_path != NULL || start_s_iter != NULL); @@ -600,7 +782,7 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, level = iter.user_data; elt = iter.user_data2; - if (level->array->len < 2 || + if (g_sequence_get_length (level->seq) < 2 || (priv->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID && priv->default_sort_func == NO_SORT_FUNC)) { @@ -614,47 +796,24 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, return; } - - if (!GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort)) - { - gtk_tree_model_get_iter (priv->child_model, - &tmpiter, start_s_path); - } - - old_index = elt - SORT_ELT (level->array->data); - - memcpy (&tmp, elt, sizeof (SortElt)); 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, - old_index); + tmpiter = elt->iter; else - index = gtk_tree_model_sort_level_find_insert (tree_model_sort, - level, - &tmpiter, - old_index); + gtk_tree_model_get_iter (priv->child_model, + &tmpiter, start_s_path); - 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)); + old_index = g_sequence_iter_get_position (elt->siter); + + fill_sort_data (&sort_data, tree_model_sort, level); + g_sequence_sort_changed (elt->siter, + gtk_tree_model_sort_compare_func, + &sort_data); + free_sort_data (&sort_data); - for (i = 0; i < level->array->len; i++) - if (g_array_index (level->array, SortElt, i).children) - g_array_index (level->array, SortElt, i).children->parent_elt_index = i; + index = g_sequence_iter_get_position (elt->siter); + /* Prepare the path for signal emission */ gtk_tree_path_up (path); gtk_tree_path_append_index (path, index); @@ -668,9 +827,9 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, GtkTreePath *tmppath; - new_order = g_new (gint, level->array->len); + new_order = g_new (gint, g_sequence_get_length (level->seq)); - for (j = 0; j < level->array->len; j++) + for (j = 0; j < g_sequence_get_length (level->seq); j++) { if (index > old_index) { @@ -693,11 +852,11 @@ gtk_tree_model_sort_row_changed (GtkTreeModel *s_model, /* else? shouldn't really happen */ } - if (level->parent_elt_index >= 0) + if (level->parent_elt) { iter.stamp = priv->stamp; iter.user_data = level->parent_level; - iter.user_data2 = SORT_LEVEL_PARENT_ELT (level); + iter.user_data2 = level->parent_elt; tmppath = gtk_tree_model_get_path (GTK_TREE_MODEL (tree_model_sort), &iter); @@ -764,7 +923,7 @@ gtk_tree_model_sort_row_inserted (GtkTreeModel *s_model, if (!priv->root) { - gtk_tree_model_sort_build_level (tree_model_sort, NULL, -1); + gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL); /* the build level already put the inserted iter in the level, so no need to handle this signal anymore */ @@ -775,15 +934,13 @@ gtk_tree_model_sort_row_inserted (GtkTreeModel *s_model, /* find the parent level */ while (i < gtk_tree_path_get_depth (s_path) - 1) { - gint j; - if (!level) { /* level not yet build, we won't cover this signal */ goto done; } - if (level->array->len < gtk_tree_path_get_indices (s_path)[i]) + if (g_sequence_get_length (level->seq) < gtk_tree_path_get_indices (s_path)[i]) { g_warning ("%s: A node was inserted with a parent that's not in the tree.\n" "This possibly means that a GtkTreeModel inserted a child node\n" @@ -792,13 +949,9 @@ gtk_tree_model_sort_row_inserted (GtkTreeModel *s_model, goto done; } - elt = NULL; - for (j = 0; j < level->array->len; j++) - if (g_array_index (level->array, SortElt, j).offset == gtk_tree_path_get_indices (s_path)[i]) - { - elt = &g_array_index (level->array, SortElt, j); - break; - } + elt = lookup_elt_with_offset (tree_model_sort, level, + gtk_tree_path_get_indices (s_path)[i], + NULL); g_return_if_fail (elt != NULL); @@ -882,7 +1035,6 @@ gtk_tree_model_sort_row_deleted (GtkTreeModel *s_model, SortLevel *level; GtkTreeIter iter; gint offset; - gint i; g_return_if_fail (s_path != NULL); @@ -925,22 +1077,14 @@ gtk_tree_model_sort_row_deleted (GtkTreeModel *s_model, return; } - /* Remove the row */ - for (i = 0; i < level->array->len; i++) - if (elt->offset == g_array_index (level->array, SortElt, i).offset) - break; - - g_array_remove_index (level->array, i); + g_sequence_remove (elt->siter); + elt = NULL; - /* update all offsets */ - for (i = 0; i < level->array->len; i++) - { - elt = & (g_array_index (level->array, SortElt, i)); - if (elt->offset > offset) - elt->offset--; - if (elt->children) - elt->children->parent_elt_index = i; - } + /* The sequence is not ordered on offset, so we traverse the entire + * sequence. + */ + g_sequence_foreach (level->seq, decrease_offset_iter, + GINT_TO_POINTER (offset)); gtk_tree_model_sort_increment_stamp (tree_model_sort); gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path); @@ -959,8 +1103,9 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model, SortLevel *level; GtkTreeIter iter; gint *tmp_array; - int i, j; + int i, length; GtkTreePath *path; + GSequenceIter *siter, *end_siter; GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data); GtkTreeModelSortPrivate *priv = tree_model_sort->priv; @@ -980,7 +1125,6 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model, return; gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path); - level = SORT_LEVEL (iter.user_data); elt = SORT_ELT (iter.user_data2); if (!elt->children) @@ -992,30 +1136,55 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model, level = elt->children; } - if (level->array->len < 2) + length = g_sequence_get_length (level->seq); + if (length < 2) { gtk_tree_path_free (path); return; } - tmp_array = g_new (int, level->array->len); - for (i = 0; i < level->array->len; i++) + tmp_array = g_new (int, length); + + /* FIXME: I need to think about whether this can be done in a more + * efficient way? + */ + i = 0; + end_siter = g_sequence_get_end_iter (level->seq); + for (siter = g_sequence_get_begin_iter (level->seq); + siter != end_siter; + siter = g_sequence_iter_next (siter)) { - for (j = 0; j < level->array->len; j++) + gint j; + SortElt *elt = g_sequence_get (siter); + + for (j = 0; j < length; j++) { - if (g_array_index (level->array, SortElt, i).offset == new_order[j]) + if (elt->offset == new_order[j]) tmp_array[i] = j; } + + i++; } - for (i = 0; i < level->array->len; i++) - g_array_index (level->array, SortElt, i).offset = tmp_array[i]; + /* This loop cannot be merged with the above loop nest, because that + * would introduce duplicate offsets. + */ + i = 0; + end_siter = g_sequence_get_end_iter (level->seq); + for (siter = g_sequence_get_begin_iter (level->seq); + siter != end_siter; + siter = g_sequence_iter_next (siter)) + { + SortElt *elt = g_sequence_get (siter); + + elt->offset = tmp_array[i]; + i++; + } g_free (tmp_array); if (priv->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID && priv->default_sort_func == NO_SORT_FUNC) { - gtk_tree_model_sort_sort_level (tree_model_sort, level, FALSE, FALSE); gtk_tree_model_sort_increment_stamp (tree_model_sort); @@ -1085,15 +1254,17 @@ gtk_tree_model_sort_get_iter (GtkTreeModel *tree_model, GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model; GtkTreeModelSortPrivate *priv = tree_model_sort->priv; gint *indices; + SortElt *elt; SortLevel *level; gint depth, i; + GSequenceIter *siter; g_return_val_if_fail (priv->child_model != NULL, FALSE); indices = gtk_tree_path_get_indices (path); if (priv->root == NULL) - gtk_tree_model_sort_build_level (tree_model_sort, NULL, -1); + gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL); level = SORT_LEVEL (priv->root); depth = gtk_tree_path_get_depth (path); @@ -1106,18 +1277,27 @@ gtk_tree_model_sort_get_iter (GtkTreeModel *tree_model, for (i = 0; i < depth - 1; i++) { if ((level == NULL) || - (indices[i] >= level->array->len)) + (indices[i] >= g_sequence_get_length (level->seq))) { iter->stamp = 0; return FALSE; } - if (g_array_index (level->array, SortElt, indices[i]).children == NULL) - gtk_tree_model_sort_build_level (tree_model_sort, level, indices[i]); - level = g_array_index (level->array, SortElt, indices[i]).children; + siter = g_sequence_get_iter_at_pos (level->seq, indices[i]); + if (g_sequence_iter_is_end (siter)) + { + iter->stamp = 0; + return FALSE; + } + + elt = GET_ELT (siter); + if (elt->children == NULL) + gtk_tree_model_sort_build_level (tree_model_sort, level, elt); + + level = elt->children; } - if (!level || indices[i] >= level->array->len) + if (!level || indices[i] >= g_sequence_get_length (level->seq)) { iter->stamp = 0; return FALSE; @@ -1125,7 +1305,14 @@ gtk_tree_model_sort_get_iter (GtkTreeModel *tree_model, iter->stamp = priv->stamp; iter->user_data = level; - iter->user_data2 = &g_array_index (level->array, SortElt, indices[depth - 1]); + + siter = g_sequence_get_iter_at_pos (level->seq, indices[depth - 1]); + if (g_sequence_iter_is_end (siter)) + { + iter->stamp = 0; + return FALSE; + } + iter->user_data2 = GET_ELT (siter); return TRUE; } @@ -1138,7 +1325,7 @@ gtk_tree_model_sort_get_path (GtkTreeModel *tree_model, GtkTreeModelSortPrivate *priv = tree_model_sort->priv; GtkTreePath *retval; SortLevel *level; - gint elt_index; + SortElt *elt; g_return_val_if_fail (priv->child_model != NULL, NULL); g_return_val_if_fail (priv->stamp == iter->stamp, NULL); @@ -1146,13 +1333,16 @@ gtk_tree_model_sort_get_path (GtkTreeModel *tree_model, retval = gtk_tree_path_new (); level = SORT_LEVEL (iter->user_data); - elt_index = SORT_LEVEL_ELT_INDEX (level, iter->user_data2); + elt = SORT_ELT (iter->user_data2); while (level) { - gtk_tree_path_prepend_index (retval, elt_index); + gint index; + + index = g_sequence_iter_get_position (elt->siter); + gtk_tree_path_prepend_index (retval, index); - elt_index = level->parent_elt_index; + elt = level->parent_elt; level = level->parent_level; } @@ -1183,21 +1373,21 @@ gtk_tree_model_sort_iter_next (GtkTreeModel *tree_model, { GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model; GtkTreeModelSortPrivate *priv = tree_model_sort->priv; - SortLevel *level; SortElt *elt; + GSequenceIter *siter; g_return_val_if_fail (priv->child_model != NULL, FALSE); g_return_val_if_fail (priv->stamp == iter->stamp, FALSE); - level = iter->user_data; elt = iter->user_data2; - if (elt - (SortElt *)level->array->data >= level->array->len - 1) + siter = g_sequence_iter_next (elt->siter); + if (g_sequence_iter_is_end (siter)) { iter->stamp = 0; return FALSE; } - iter->user_data2 = elt + 1; + iter->user_data2 = GET_ELT (siter); return TRUE; } @@ -1208,21 +1398,22 @@ gtk_tree_model_sort_iter_previous (GtkTreeModel *tree_model, { GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model; GtkTreeModelSortPrivate *priv = tree_model_sort->priv; - SortLevel *level; SortElt *elt; + GSequenceIter *siter; g_return_val_if_fail (priv->child_model != NULL, FALSE); g_return_val_if_fail (priv->stamp == iter->stamp, FALSE); - level = iter->user_data; elt = iter->user_data2; - if (elt == (SortElt *)level->array->data) + if (g_sequence_iter_is_begin (elt->siter)) { iter->stamp = 0; return FALSE; } - iter->user_data2 = elt - 1; + + siter = g_sequence_iter_prev (elt->siter); + iter->user_data2 = GET_ELT (siter); return TRUE; } @@ -1244,14 +1435,14 @@ gtk_tree_model_sort_iter_children (GtkTreeModel *tree_model, if (parent == NULL) { if (priv->root == NULL) - gtk_tree_model_sort_build_level (tree_model_sort, NULL, -1); + gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL); if (priv->root == NULL) return FALSE; level = priv->root; iter->stamp = priv->stamp; iter->user_data = level; - iter->user_data2 = level->array->data; + iter->user_data2 = g_sequence_get (g_sequence_get_begin_iter (level->seq)); } else { @@ -1261,15 +1452,14 @@ gtk_tree_model_sort_iter_children (GtkTreeModel *tree_model, elt = SORT_ELT (parent->user_data2); if (elt->children == NULL) - gtk_tree_model_sort_build_level (tree_model_sort, level, - SORT_LEVEL_ELT_INDEX (level, elt)); + gtk_tree_model_sort_build_level (tree_model_sort, level, elt); if (elt->children == NULL) return FALSE; iter->stamp = priv->stamp; iter->user_data = elt->children; - iter->user_data2 = elt->children->array->data; + iter->user_data2 = g_sequence_get (g_sequence_get_begin_iter (elt->children->seq)); } return TRUE; @@ -1333,7 +1523,7 @@ gtk_tree_model_sort_iter_nth_child (GtkTreeModel *tree_model, } level = children.user_data; - if (n >= level->array->len) + if (n >= g_sequence_get_length (level->seq)) { iter->stamp = 0; return FALSE; @@ -1341,7 +1531,7 @@ gtk_tree_model_sort_iter_nth_child (GtkTreeModel *tree_model, iter->stamp = tree_model_sort->priv->stamp; iter->user_data = level; - iter->user_data2 = &g_array_index (level->array, SortElt, n); + iter->user_data2 = g_sequence_get (g_sequence_get_iter_at_pos (level->seq, n)); return TRUE; } @@ -1365,7 +1555,7 @@ gtk_tree_model_sort_iter_parent (GtkTreeModel *tree_model, { iter->stamp = priv->stamp; iter->user_data = level->parent_level; - iter->user_data2 = SORT_LEVEL_PARENT_ELT (level); + iter->user_data2 = level->parent_elt; return TRUE; } @@ -1400,14 +1590,14 @@ gtk_tree_model_sort_ref_node (GtkTreeModel *tree_model, if (level->ref_count == 1) { SortLevel *parent_level = level->parent_level; - gint parent_elt_index = level->parent_elt_index; + SortElt *parent_elt = level->parent_elt; /* We were at zero -- time to decrement the zero_ref_count val */ while (parent_level) { - g_array_index (parent_level->array, SortElt, parent_elt_index).zero_ref_count--; + parent_elt->zero_ref_count--; - parent_elt_index = parent_level->parent_elt_index; + parent_elt = parent_level->parent_elt; parent_level = parent_level->parent_level; } @@ -1448,14 +1638,14 @@ gtk_tree_model_sort_real_unref_node (GtkTreeModel *tree_model, if (level->ref_count == 0) { SortLevel *parent_level = level->parent_level; - gint parent_elt_index = level->parent_elt_index; + SortElt *parent_elt = level->parent_elt; /* We are at zero -- time to increment the zero_ref_count val */ while (parent_level) { - g_array_index (parent_level->array, SortElt, parent_elt_index).zero_ref_count++; + parent_elt->zero_ref_count++; - parent_elt_index = parent_level->parent_elt_index; + parent_elt = parent_level->parent_elt; parent_level = parent_level->parent_level; } @@ -1644,26 +1834,22 @@ gtk_tree_model_sort_compare_func (gconstpointer a, SortData *data = (SortData *)user_data; GtkTreeModelSort *tree_model_sort = data->tree_model_sort; GtkTreeModelSortPrivate *priv = tree_model_sort->priv; - SortTuple *sa = (SortTuple *)a; - SortTuple *sb = (SortTuple *)b; + const SortElt *sa = a; + const SortElt *sb = b; GtkTreeIter iter_a, iter_b; gint retval; - /* shortcut, if we've the same offsets here, they should be equal */ - if (sa->offset == sb->offset) - return 0; - if (GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort)) { - iter_a = sa->elt->iter; - iter_b = sb->elt->iter; + iter_a = sa->iter; + iter_b = sb->iter; } else { - data->parent_path_indices [data->parent_path_depth-1] = sa->elt->offset; + data->parent_path_indices [data->parent_path_depth-1] = sa->offset; gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->child_model), &iter_a, data->parent_path); - data->parent_path_indices [data->parent_path_depth-1] = sb->elt->offset; + data->parent_path_indices [data->parent_path_depth-1] = sb->offset; gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->child_model), &iter_b, data->parent_path); } @@ -1689,14 +1875,14 @@ gtk_tree_model_sort_offset_compare_func (gconstpointer a, { gint retval; - SortTuple *sa = (SortTuple *)a; - SortTuple *sb = (SortTuple *)b; + const SortElt *sa = (SortElt *)a; + const SortElt *sb = (SortElt *)b; SortData *data = (SortData *)user_data; - if (sa->elt->offset < sb->elt->offset) + if (sa->offset < sb->offset) retval = -1; - else if (sa->elt->offset > sb->elt->offset) + else if (sa->offset > sb->offset) retval = 1; else retval = 0; @@ -1720,9 +1906,8 @@ gtk_tree_model_sort_sort_level (GtkTreeModelSort *tree_model_sort, { GtkTreeModelSortPrivate *priv = tree_model_sort->priv; gint i; - gint ref_offset; - GArray *sort_array; - GArray *new_array; + GSequenceIter *begin_siter, *end_siter, *siter; + SortElt *begin_elt; gint *new_order; GtkTreeIter iter; @@ -1732,103 +1917,61 @@ gtk_tree_model_sort_sort_level (GtkTreeModelSort *tree_model_sort, g_return_if_fail (level != NULL); - if (level->array->len < 1 && !((SortElt *)level->array->data)->children) + begin_siter = g_sequence_get_begin_iter (level->seq); + begin_elt = g_sequence_get (begin_siter); + + if (g_sequence_get_length (level->seq) < 1 && !begin_elt->children) return; iter.stamp = priv->stamp; iter.user_data = level; - iter.user_data2 = &g_array_index (level->array, SortElt, 0); + iter.user_data2 = begin_elt; gtk_tree_model_sort_ref_node (GTK_TREE_MODEL (tree_model_sort), &iter); - ref_offset = g_array_index (level->array, SortElt, 0).offset; - /* Set up data */ - data.tree_model_sort = tree_model_sort; - if (level->parent_elt_index >= 0) + i = 0; + end_siter = g_sequence_get_end_iter (level->seq); + for (siter = g_sequence_get_begin_iter (level->seq); + siter != end_siter; + siter = g_sequence_iter_next (siter)) { - data.parent_path = gtk_tree_model_sort_elt_get_path (level->parent_level, - SORT_LEVEL_PARENT_ELT (level)); - gtk_tree_path_append_index (data.parent_path, 0); - } - else - { - data.parent_path = gtk_tree_path_new_first (); - } - data.parent_path_depth = gtk_tree_path_get_depth (data.parent_path); - data.parent_path_indices = gtk_tree_path_get_indices (data.parent_path); - - /* make the array to be sorted */ - sort_array = g_array_sized_new (FALSE, FALSE, sizeof (SortTuple), level->array->len); - for (i = 0; i < level->array->len; i++) - { - SortTuple tuple; + SortElt *elt = g_sequence_get (siter); - tuple.elt = &g_array_index (level->array, SortElt, i); - tuple.offset = i; - - g_array_append_val (sort_array, tuple); + elt->old_index = i; + i++; } - if (priv->sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) - { - GtkTreeDataSortHeader *header = NULL; - - header = _gtk_tree_data_list_get_header (priv->sort_list, - priv->sort_column_id); - - g_return_if_fail (header != NULL); - g_return_if_fail (header->func != NULL); - - data.sort_func = header->func; - data.sort_data = header->data; - } - else - { - /* absolutely SHOULD NOT happen: */ - g_return_if_fail (priv->default_sort_func != NULL); - - data.sort_func = priv->default_sort_func; - data.sort_data = priv->default_sort_data; - } + fill_sort_data (&data, tree_model_sort, level); if (data.sort_func == NO_SORT_FUNC) - g_array_sort_with_data (sort_array, - gtk_tree_model_sort_offset_compare_func, - &data); + g_sequence_sort (level->seq, gtk_tree_model_sort_offset_compare_func, + &data); else - g_array_sort_with_data (sort_array, - gtk_tree_model_sort_compare_func, - &data); + g_sequence_sort (level->seq, gtk_tree_model_sort_compare_func, &data); - gtk_tree_path_free (data.parent_path); + free_sort_data (&data); - new_array = g_array_sized_new (FALSE, FALSE, sizeof (SortElt), level->array->len); - new_order = g_new (gint, level->array->len); + new_order = g_new (gint, g_sequence_get_length (level->seq)); - for (i = 0; i < level->array->len; i++) + i = 0; + end_siter = g_sequence_get_end_iter (level->seq); + for (siter = g_sequence_get_begin_iter (level->seq); + siter != end_siter; + siter = g_sequence_iter_next (siter)) { - SortElt *elt; + SortElt *elt = g_sequence_get (siter); - elt = g_array_index (sort_array, SortTuple, i).elt; - new_order[i] = g_array_index (sort_array, SortTuple, i).offset; - - g_array_append_val (new_array, *elt); - if (elt->children) - elt->children->parent_elt_index = i; + new_order[i++] = elt->old_index; } - g_array_free (level->array, TRUE); - level->array = new_array; - g_array_free (sort_array, TRUE); - if (emit_reordered) { gtk_tree_model_sort_increment_stamp (tree_model_sort); - if (level->parent_elt_index >= 0) + if (level->parent_elt) { iter.stamp = priv->stamp; iter.user_data = level->parent_level; - iter.user_data2 = SORT_LEVEL_PARENT_ELT (level); + iter.user_data2 = level->parent_elt; path = gtk_tree_model_get_path (GTK_TREE_MODEL (tree_model_sort), &iter); @@ -1850,9 +1993,12 @@ gtk_tree_model_sort_sort_level (GtkTreeModelSort *tree_model_sort, /* recurse, if possible */ if (recurse) { - for (i = 0; i < level->array->len; i++) + end_siter = g_sequence_get_end_iter (level->seq); + for (siter = g_sequence_get_begin_iter (level->seq); + siter != end_siter; + siter = g_sequence_iter_next (siter)) { - SortElt *elt = &g_array_index (level->array, SortElt, i); + SortElt *elt = g_sequence_get (siter); if (elt->children) gtk_tree_model_sort_sort_level (tree_model_sort, @@ -1868,15 +2014,7 @@ gtk_tree_model_sort_sort_level (GtkTreeModelSort *tree_model_sort, */ iter.stamp = priv->stamp; iter.user_data = level; - - for (i = 0; i < level->array->len; i++) - { - if (g_array_index (level->array, SortElt, i).offset == ref_offset) - { - iter.user_data2 = &g_array_index (level->array, SortElt, i); - break; - } - } + iter.user_data2 = begin_elt; gtk_tree_model_sort_unref_node (GTK_TREE_MODEL (tree_model_sort), &iter); } @@ -1911,91 +2049,6 @@ gtk_tree_model_sort_sort (GtkTreeModelSort *tree_model_sort) } /* signal helpers */ -static gint -gtk_tree_model_sort_level_find_insert (GtkTreeModelSort *tree_model_sort, - SortLevel *level, - GtkTreeIter *iter, - gint skip_index) -{ - GtkTreeModelSortPrivate *priv = tree_model_sort->priv; - gint start, middle, end; - gint cmp; - SortElt *tmp_elt; - GtkTreeIter tmp_iter; - - GtkTreeIterCompareFunc func; - gpointer data; - - if (priv->sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) - { - GtkTreeDataSortHeader *header; - - header = _gtk_tree_data_list_get_header (priv->sort_list, - priv->sort_column_id); - - g_return_val_if_fail (header != NULL, 0); - - func = header->func; - data = header->data; - } - else - { - func = priv->default_sort_func; - data = priv->default_sort_data; - - g_return_val_if_fail (func != NO_SORT_FUNC, 0); - } - - g_return_val_if_fail (func != NULL, 0); - - start = 0; - end = level->array->len; - if (skip_index < 0) - skip_index = end; - else - end--; - - 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 (priv->child_model, - &tmp_iter, path); - gtk_tree_path_free (path); - } - else - tmp_iter = tmp_elt->iter; - - if (priv->order == GTK_SORT_ASCENDING) - cmp = (* func) (GTK_TREE_MODEL (priv->child_model), - &tmp_iter, iter, data); - else - cmp = (* func) (GTK_TREE_MODEL (priv->child_model), - iter, &tmp_iter, data); - - if (cmp <= 0) - start = middle + 1; - else - end = middle; - } - - if (cmp <= 0) - return middle + 1; - else - return middle; -} - static gboolean gtk_tree_model_sort_insert_value (GtkTreeModelSort *tree_model_sort, SortLevel *level, @@ -2003,39 +2056,41 @@ gtk_tree_model_sort_insert_value (GtkTreeModelSort *tree_model_sort, GtkTreeIter *s_iter) { GtkTreeModelSortPrivate *priv = tree_model_sort->priv; - gint offset, index, i; + SortElt *elt; + SortData data; + gint offset; - SortElt elt; - SortElt *tmp_elt; + elt = sort_elt_new (); offset = gtk_tree_path_get_indices (s_path)[gtk_tree_path_get_depth (s_path) - 1]; if (GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort)) - elt.iter = *s_iter; - elt.offset = offset; - elt.zero_ref_count = 0; - elt.ref_count = 0; - elt.children = NULL; + elt->iter = *s_iter; + elt->offset = offset; + elt->zero_ref_count = 0; + elt->ref_count = 0; + elt->children = NULL; /* update all larger offsets */ - tmp_elt = SORT_ELT (level->array->data); - for (i = 0; i < level->array->len; i++, tmp_elt++) - if (tmp_elt->offset >= offset) - tmp_elt->offset++; + g_sequence_foreach (level->seq, increase_offset_iter, GINT_TO_POINTER (offset)); + + fill_sort_data (&data, tree_model_sort, level); if (priv->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID && priv->default_sort_func == NO_SORT_FUNC) - index = offset; + { + elt->siter = g_sequence_insert_sorted (level->seq, elt, + gtk_tree_model_sort_offset_compare_func, + &data); + } else - index = gtk_tree_model_sort_level_find_insert (tree_model_sort, - level, s_iter, - -1); + { + elt->siter = g_sequence_insert_sorted (level->seq, elt, + gtk_tree_model_sort_compare_func, + &data); + } - g_array_insert_vals (level->array, index, &elt, 1); - tmp_elt = SORT_ELT (level->array->data); - for (i = 0; i < level->array->len; i++, tmp_elt++) - if (tmp_elt->children) - tmp_elt->children->parent_elt_index = i; + free_sort_data (&data); return TRUE; } @@ -2061,7 +2116,7 @@ gtk_tree_model_sort_elt_get_path (SortLevel *level, if (!walker->parent_level) break; - walker2 = SORT_LEVEL_PARENT_ELT (walker); + walker2 = walker->parent_elt; walker = walker->parent_level; } @@ -2187,12 +2242,13 @@ gtk_real_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_mode child_indices = gtk_tree_path_get_indices (child_path); if (priv->root == NULL && build_levels) - gtk_tree_model_sort_build_level (tree_model_sort, NULL, -1); + gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL); level = SORT_LEVEL (priv->root); for (i = 0; i < gtk_tree_path_get_depth (child_path); i++) { - gint j; + SortElt *tmp; + GSequenceIter *siter; gboolean found_child = FALSE; if (!level) @@ -2201,25 +2257,23 @@ gtk_real_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_mode return NULL; } - if (child_indices[i] >= level->array->len) + if (child_indices[i] >= g_sequence_get_length (level->seq)) { gtk_tree_path_free (retval); return NULL; } - for (j = 0; j < level->array->len; j++) - { - if ((g_array_index (level->array, SortElt, j)).offset == child_indices[i]) - { - gtk_tree_path_append_index (retval, j); - if (g_array_index (level->array, SortElt, j).children == NULL && build_levels) - { - gtk_tree_model_sort_build_level (tree_model_sort, level, j); - } - level = g_array_index (level->array, SortElt, j).children; - found_child = TRUE; - break; - } - } + tmp = lookup_elt_with_offset (tree_model_sort, level, + child_indices[i], &siter); + if (tmp) + { + gtk_tree_path_append_index (retval, g_sequence_iter_get_position (siter)); + if (tmp->children == NULL && build_levels) + gtk_tree_model_sort_build_level (tree_model_sort, level, tmp); + + level = tmp->children; + found_child = TRUE; + } + if (! found_child) { gtk_tree_path_free (retval); @@ -2333,22 +2387,31 @@ gtk_tree_model_sort_convert_path_to_child_path (GtkTreeModelSort *tree_model_sor retval = gtk_tree_path_new (); sorted_indices = gtk_tree_path_get_indices (sorted_path); if (priv->root == NULL) - gtk_tree_model_sort_build_level (tree_model_sort, NULL, -1); + gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL); level = SORT_LEVEL (priv->root); for (i = 0; i < gtk_tree_path_get_depth (sorted_path); i++) { - gint count = sorted_indices[i]; + SortElt *elt = NULL; + GSequenceIter *siter; if ((level == NULL) || - (level->array->len <= count)) + (g_sequence_get_length (level->seq) <= sorted_indices[i])) { gtk_tree_path_free (retval); return NULL; } - if (g_array_index (level->array, SortElt, count).children == NULL) - gtk_tree_model_sort_build_level (tree_model_sort, level, count); + siter = g_sequence_get_iter_at_pos (level->seq, sorted_indices[i]); + if (g_sequence_iter_is_end (siter)) + { + gtk_tree_path_free (retval); + return NULL; + } + + elt = GET_ELT (siter); + if (elt->children == NULL) + gtk_tree_model_sort_build_level (tree_model_sort, level, elt); if (level == NULL) { @@ -2356,8 +2419,8 @@ gtk_tree_model_sort_convert_path_to_child_path (GtkTreeModelSort *tree_model_sor break; } - gtk_tree_path_append_index (retval, g_array_index (level->array, SortElt, count).offset); - level = g_array_index (level->array, SortElt, count).children; + gtk_tree_path_append_index (retval, elt->offset); + level = elt->children; } return retval; @@ -2404,11 +2467,10 @@ gtk_tree_model_sort_convert_iter_to_child_iter (GtkTreeModelSort *tree_model_sor static void gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, SortLevel *parent_level, - gint parent_elt_index) + SortElt *parent_elt) { GtkTreeModelSortPrivate *priv = tree_model_sort->priv; GtkTreeIter iter; - SortElt *parent_elt = NULL; SortLevel *new_level; gint length = 0; gint i; @@ -2426,8 +2488,6 @@ gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, GtkTreeIter parent_iter; GtkTreeIter child_parent_iter; - parent_elt = &g_array_index (parent_level->array, SortElt, parent_elt_index); - parent_iter.stamp = priv->stamp; parent_iter.user_data = parent_level; parent_iter.user_data2 = parent_elt; @@ -2454,12 +2514,12 @@ gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, g_return_if_fail (length > 0); new_level = g_new (SortLevel, 1); - new_level->array = g_array_sized_new (FALSE, FALSE, sizeof (SortElt), length); + new_level->seq = g_sequence_new (sort_elt_free); new_level->ref_count = 0; new_level->parent_level = parent_level; - new_level->parent_elt_index = parent_elt_index; + new_level->parent_elt = parent_elt; - if (parent_elt_index >= 0) + if (parent_elt) parent_elt->children = new_level; else priv->root = new_level; @@ -2467,9 +2527,9 @@ gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, /* increase the count of zero ref_counts.*/ while (parent_level) { - g_array_index (parent_level->array, SortElt, parent_elt_index).zero_ref_count++; + parent_elt->zero_ref_count++; - parent_elt_index = parent_level->parent_elt_index; + parent_elt = parent_level->parent_elt; parent_level = parent_level->parent_level; } @@ -2478,15 +2538,17 @@ gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, for (i = 0; i < length; i++) { - SortElt sort_elt; - sort_elt.offset = i; - sort_elt.zero_ref_count = 0; - sort_elt.ref_count = 0; - sort_elt.children = NULL; + SortElt *sort_elt; + + sort_elt = sort_elt_new (); + sort_elt->offset = i; + sort_elt->zero_ref_count = 0; + sort_elt->ref_count = 0; + sort_elt->children = NULL; if (GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort)) { - sort_elt.iter = iter; + sort_elt->iter = iter; if (gtk_tree_model_iter_next (priv->child_model, &iter) == FALSE && i < length - 1) { @@ -2517,7 +2579,8 @@ gtk_tree_model_sort_build_level (GtkTreeModelSort *tree_model_sort, return; } } - g_array_append_val (new_level->array, sort_elt); + + sort_elt->siter = g_sequence_append (new_level->seq, sort_elt); } /* sort level */ @@ -2531,27 +2594,33 @@ gtk_tree_model_sort_free_level (GtkTreeModelSort *tree_model_sort, gboolean unref) { GtkTreeModelSortPrivate *priv = tree_model_sort->priv; - gint i; + GSequenceIter *siter; + GSequenceIter *end_siter; g_assert (sort_level); - for (i = 0; i < sort_level->array->len; i++) + end_siter = g_sequence_get_end_iter (sort_level->seq); + for (siter = g_sequence_get_begin_iter (sort_level->seq); + siter != end_siter; + siter = g_sequence_iter_next (siter)) { - if (g_array_index (sort_level->array, SortElt, i).children) - gtk_tree_model_sort_free_level (tree_model_sort, - SORT_LEVEL (g_array_index (sort_level->array, SortElt, i).children), unref); + SortElt *elt = g_sequence_get (siter); + + if (elt->children) + gtk_tree_model_sort_free_level (tree_model_sort, + elt->children, unref); } if (sort_level->ref_count == 0) { SortLevel *parent_level = sort_level->parent_level; - gint parent_elt_index = sort_level->parent_elt_index; + SortElt *parent_elt = sort_level->parent_elt; while (parent_level) { - g_array_index (parent_level->array, SortElt, parent_elt_index).zero_ref_count--; + parent_elt->zero_ref_count--; - parent_elt_index = parent_level->parent_elt_index; + parent_elt = parent_level->parent_elt; parent_level = parent_level->parent_level; } @@ -2559,7 +2628,7 @@ gtk_tree_model_sort_free_level (GtkTreeModelSort *tree_model_sort, priv->zero_ref_count--; } - if (sort_level->parent_elt_index >= 0) + if (sort_level->parent_elt) { if (unref) { @@ -2567,19 +2636,19 @@ gtk_tree_model_sort_free_level (GtkTreeModelSort *tree_model_sort, parent_iter.stamp = tree_model_sort->priv->stamp; parent_iter.user_data = sort_level->parent_level; - parent_iter.user_data2 = SORT_LEVEL_PARENT_ELT (sort_level); + parent_iter.user_data2 = sort_level->parent_elt; gtk_tree_model_sort_unref_node (GTK_TREE_MODEL (tree_model_sort), &parent_iter); } - SORT_LEVEL_PARENT_ELT (sort_level)->children = NULL; + sort_level->parent_elt->children = NULL; } else priv->root = NULL; - g_array_free (sort_level->array, TRUE); - sort_level->array = NULL; + g_sequence_free (sort_level->seq); + sort_level->seq = NULL; g_free (sort_level); sort_level = NULL; @@ -2599,19 +2668,25 @@ gtk_tree_model_sort_increment_stamp (GtkTreeModelSort *tree_model_sort) gtk_tree_model_sort_clear_cache (tree_model_sort); } +static void +gtk_tree_model_sort_clear_cache_helper_iter (gpointer data, + gpointer user_data) +{ + GtkTreeModelSort *tree_model_sort = user_data; + SortElt *elt = data; + + if (elt->zero_ref_count > 0) + gtk_tree_model_sort_clear_cache_helper (tree_model_sort, elt->children); +} + static void gtk_tree_model_sort_clear_cache_helper (GtkTreeModelSort *tree_model_sort, SortLevel *level) { - gint i; - g_assert (level != NULL); - for (i = 0; i < level->array->len; i++) - { - if (g_array_index (level->array, SortElt, i).zero_ref_count > 0) - gtk_tree_model_sort_clear_cache_helper (tree_model_sort, g_array_index (level->array, SortElt, i).children); - } + g_sequence_foreach (level->seq, gtk_tree_model_sort_clear_cache_helper_iter, + tree_model_sort); if (level->ref_count == 0 && level != tree_model_sort->priv->root) gtk_tree_model_sort_free_level (tree_model_sort, level, TRUE); @@ -2674,11 +2749,14 @@ static gboolean gtk_tree_model_sort_iter_is_valid_helper (GtkTreeIter *iter, SortLevel *level) { - gint i; + GSequenceIter *siter; + GSequenceIter *end_siter; - for (i = 0; i < level->array->len; i++) + end_siter = g_sequence_get_end_iter (level->seq); + for (siter = g_sequence_get_begin_iter (level->seq); + siter != end_siter; siter = g_sequence_iter_next (siter)) { - SortElt *elt = &g_array_index (level->array, SortElt, i); + SortElt *elt = g_sequence_get (siter); if (iter->user_data == level && iter->user_data2 == elt) return TRUE;