gint ext_ref_count;
gint visible_nodes;
- gint parent_elt_index;
+ FilterElt *parent_elt;
FilterLevel *parent_level;
};
#define FILTER_ELT(filter_elt) ((FilterElt *)filter_elt)
#define FILTER_LEVEL(filter_level) ((FilterLevel *)filter_level)
-#define FILTER_LEVEL_PARENT_ELT(level) (&g_array_index (FILTER_LEVEL ((level))->parent_level->array, FilterElt, FILTER_LEVEL ((level))->parent_elt_index))
-#define FILTER_LEVEL_ELT_INDEX(level, elt) (FILTER_ELT ((elt)) - FILTER_ELT (FILTER_LEVEL ((level))->array->data))
-
/* general code (object/interface init, properties, etc) */
static void gtk_tree_model_filter_tree_model_init (GtkTreeModelIface *iface);
static void gtk_tree_model_filter_drag_source_init (GtkTreeDragSourceIface *iface);
/* private functions */
static void gtk_tree_model_filter_build_level (GtkTreeModelFilter *filter,
FilterLevel *parent_level,
- gint parent_elt_index,
+ FilterElt *parent_elt,
gboolean emit_inserted);
static void gtk_tree_model_filter_free_level (GtkTreeModelFilter *filter,
static void
gtk_tree_model_filter_build_level (GtkTreeModelFilter *filter,
FilterLevel *parent_level,
- gint parent_elt_index,
+ FilterElt *parent_elt,
gboolean emit_inserted)
{
GtkTreeIter iter;
GtkTreeIter first_node;
GtkTreeIter root;
- FilterElt *parent_elt = NULL;
FilterLevel *new_level;
FilterLevel *tmp_level;
+ FilterElt *tmp_elt;
GtkTreeIter f_iter;
gint length = 0;
gint i;
- gint tmp_elt_index;
g_assert (filter->priv->child_model != NULL);
/* Avoid building a level that already exists */
if (parent_level)
- g_assert (g_array_index (parent_level->array, FilterElt, parent_elt_index).children == NULL);
+ g_assert (parent_elt->children == NULL);
else
g_assert (filter->priv->root == NULL);
GtkTreeIter parent_iter;
GtkTreeIter child_parent_iter;
- parent_elt = &g_array_index (parent_level->array, FilterElt, parent_elt_index);
-
parent_iter.stamp = filter->priv->stamp;
parent_iter.user_data = parent_level;
parent_iter.user_data2 = parent_elt;
new_level->ref_count = 0;
new_level->ext_ref_count = 0;
new_level->visible_nodes = 0;
- new_level->parent_elt_index = parent_elt_index;
+ new_level->parent_elt = parent_elt;
new_level->parent_level = parent_level;
- if (parent_elt_index >= 0)
+ if (parent_elt)
parent_elt->children = new_level;
else
filter->priv->root = new_level;
/* increase the count of zero ref_counts */
tmp_level = parent_level;
- tmp_elt_index = parent_elt_index;
+ tmp_elt = parent_elt;
while (tmp_level)
{
- g_array_index (tmp_level->array, FilterElt, tmp_elt_index).zero_ref_count++;
+ parent_elt->zero_ref_count++;
- tmp_elt_index = tmp_level->parent_elt_index;
+ tmp_elt = tmp_level->parent_elt;
tmp_level = tmp_level->parent_level;
}
if (new_level != filter->priv->root)
*/
if (new_level->array->len == 0 &&
(parent_level && parent_level->parent_level &&
- FILTER_LEVEL_PARENT_ELT (parent_level)->ext_ref_count == 0))
+ parent_level->parent_elt->ext_ref_count == 0))
{
gtk_tree_model_filter_free_level (filter, new_level, FALSE);
return;
if (filter_level->ext_ref_count == 0)
{
FilterLevel *parent_level = filter_level->parent_level;
- gint parent_elt_index = filter_level->parent_elt_index;
+ FilterElt *parent_elt = filter_level->parent_elt;
while (parent_level)
{
- g_array_index (parent_level->array, FilterElt, parent_elt_index).zero_ref_count--;
+ parent_elt->zero_ref_count--;
- parent_elt_index = parent_level->parent_elt_index;
- parent_level = parent_level->parent_level;
+ parent_elt = parent_level->parent_elt;
+ parent_level = parent_level->parent_level;
}
if (filter_level != filter->priv->root)
filter->priv->zero_ref_count--;
}
- if (filter_level->parent_elt_index >= 0)
+ if (filter_level->parent_elt)
{
/* Release reference on parent */
if (unref)
parent_iter.stamp = filter->priv->stamp;
parent_iter.user_data = filter_level->parent_level;
- parent_iter.user_data2 = FILTER_LEVEL_PARENT_ELT (filter_level);
+ parent_iter.user_data2 = filter_level->parent_elt;
gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (filter),
&parent_iter, FALSE, TRUE);
}
- FILTER_LEVEL_PARENT_ELT (filter_level)->children = NULL;
+ filter_level->parent_elt->children = NULL;
}
else
filter->priv->root = NULL;
{
gtk_tree_path_prepend_index (path, walker2->offset);
- if (!walker->parent_level)
- break;
-
- walker2 = FILTER_LEVEL_PARENT_ELT (walker);
+ walker2 = walker->parent_elt;
walker = walker->parent_level;
}
* not requested.
*/
if (level->ext_ref_count == 0 && level != filter->priv->root &&
- level->parent_level && FILTER_LEVEL_PARENT_ELT (level) &&
+ level->parent_level && level->parent_elt &&
level->parent_level->parent_level &&
- FILTER_LEVEL_PARENT_ELT (level->parent_level)->ext_ref_count == 0)
+ level->parent_level->parent_elt->ext_ref_count == 0)
{
gtk_tree_model_filter_free_level (filter, level, TRUE);
return;
gtk_tree_model_filter_elt_is_visible_in_target (FilterLevel *level,
FilterElt *elt)
{
- gint elt_index;
-
if (!elt->visible)
return FALSE;
- if (level->parent_elt_index == -1)
+ if (!level->parent_elt)
return TRUE;
do
{
- elt_index = level->parent_elt_index;
+ elt = level->parent_elt;
level = level->parent_level;
- if (elt_index >= 0
- && !g_array_index (level->array, FilterElt, elt_index).visible)
+ if (elt && !elt->visible)
return FALSE;
}
while (level);
f_iter.stamp = filter->priv->stamp;
f_iter.user_data = level->parent_level;
- f_iter.user_data2 = FILTER_LEVEL_PARENT_ELT(level);
+ f_iter.user_data2 = level->parent_elt;
f_path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter),
&f_iter);
{
FilterElt *e = &(g_array_index (level->array, FilterElt, i));
if (e->children)
- e->children->parent_elt_index = i;
+ e->children->parent_elt = e;
}
/* If the insert location is zero, we need to move our reference
GtkTreeIter c_parent_iter;
/* check if child exists and is visible */
- if (level->parent_elt_index >= 0)
+ if (level->parent_elt)
{
c_parent_path =
gtk_tree_model_filter_elt_get_path (level->parent_level,
- FILTER_LEVEL_PARENT_ELT (level),
+ level->parent_elt,
filter->priv->virtual_root);
if (!c_parent_path)
return NULL;
{
FilterElt *parent;
FilterLevel *parent_level;
- gint i, length, parent_elt_index, orig_level_ext_ref_count;
+ gint i, length, orig_level_ext_ref_count;
GtkTreeIter iter;
GtkTreePath *path = NULL;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);
- parent_elt_index = level->parent_elt_index;
- if (parent_elt_index >= 0)
- parent = FILTER_LEVEL_PARENT_ELT (level);
- else
- parent = NULL;
+ parent = level->parent_elt;
parent_level = level->parent_level;
length = level->array->len;
*/
elt = &g_array_index (level->array, FilterElt, i);
if (elt->children)
- elt->children->parent_elt_index = i;
+ elt->children->parent_elt = elt;
}
}
gtk_tree_model_filter_convert_iter_to_child_iter (filter, &c_iter, &iter);
- if ((!level->parent_level || FILTER_LEVEL_PARENT_ELT (level)->ext_ref_count > 0) &&
+ if ((!level->parent_level || level->parent_elt->ext_ref_count > 0) &&
gtk_tree_model_iter_has_child (filter->priv->child_model, &c_iter))
{
if (!elt->children)
- gtk_tree_model_filter_build_level (filter, level,
- FILTER_LEVEL_ELT_INDEX (level, elt),
- FALSE);
+ gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
if (elt->ext_ref_count > 0 && elt->children && elt->children->array->len)
{
/* The root level has not been exposed to the view yet, so we
* need to emit signals for any node that is being inserted.
*/
- gtk_tree_model_filter_build_level (filter, NULL, -1, TRUE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, TRUE);
/* Check if the root level was built. Then child levels
* that matter have also been built (due to update_children,
(!level->parent_level || level->ext_ref_count > 0))
gtk_tree_model_row_inserted (GTK_TREE_MODEL (filter), path, &iter);
- if (level->parent_level && FILTER_LEVEL_PARENT_ELT (level)->ext_ref_count > 0 &&
+ if (level->parent_level && level->parent_elt->ext_ref_count > 0 &&
level->visible_nodes == 1)
{
/* We know that this is the first visible node in this level, so
/* The root level has not been exposed to the view yet, so we
* need to emit signals for any node that is being inserted.
*/
- gtk_tree_model_filter_build_level (filter, NULL, -1, TRUE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, TRUE);
/* Check if the root level was built. Then child levels
* that matter have also been built (due to update_children,
if (filter->priv->virtual_root && !filter->priv->root
&& !gtk_tree_path_compare (c_path, filter->priv->virtual_root))
{
- gtk_tree_model_filter_build_level (filter, NULL, -1, TRUE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, TRUE);
return;
}
*/
if (elt->ref_count > 1 && !elt->children &&
gtk_tree_model_iter_has_child (c_model, c_iter))
- gtk_tree_model_filter_build_level (filter, level,
- FILTER_LEVEL_ELT_INDEX (level, elt),
- FALSE);
+ gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
/* get a path taking only visible nodes into account */
path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &iter);
if (elt->offset > offset)
elt->offset--;
if (elt->children)
- elt->children->parent_elt_index = i;
+ elt->children->parent_elt = elt;
}
}
GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (data);
GtkTreePath *path;
GtkTreeIter iter;
- FilterElt *elt;
+ FilterElt *elt, *parent_elt = NULL;
FilterLevel *level, *parent_level = NULL;
gboolean emit_child_toggled = FALSE;
gboolean emit_row_deleted = FALSE;
gint offset;
gint i;
- gint parent_elt_index = -1;
gint orig_level_ext_ref_count;
g_return_if_fail (c_path != NULL);
{
emit_child_toggled = TRUE;
parent_level = level->parent_level;
- parent_elt_index = level->parent_elt_index;
+ parent_elt = level->parent_elt;
}
emit_row_deleted = TRUE;
if (elt->offset > offset)
elt->offset--;
if (elt->children)
- elt->children->parent_elt_index = i;
+ elt->children->parent_elt = elt;
}
/* Take a reference on the new first node. The first node previously
/* emit row_deleted */
gtk_tree_model_filter_increment_stamp (filter);
- if (parent_elt_index == -1 || orig_level_ext_ref_count > 0)
+ if (!parent_elt || orig_level_ext_ref_count > 0)
gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
}
iter2.stamp = filter->priv->stamp;
iter2.user_data = parent_level;
- iter2.user_data2 = &g_array_index (parent_level->array, FilterElt, parent_elt_index);
+ iter2.user_data2 = parent_elt;
/* We set in_row_deleted to TRUE to avoid a level build triggered
* by row-has-child-toggled (parent model could call iter_has_child
{
FilterElt *e = &g_array_index (level->array, FilterElt, i);
if (e->children)
- e->children->parent_elt_index = i;
+ e->children->parent_elt = e;
}
/* Transfer the reference from the old item at position 0 to the
indices = gtk_tree_path_get_indices (path);
if (filter->priv->root == NULL)
- gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
level = FILTER_LEVEL (filter->priv->root);
depth = gtk_tree_path_get_depth (path);
elt = gtk_tree_model_filter_get_nth (filter, level, indices[i]);
if (!elt->children)
- gtk_tree_model_filter_build_level (filter, level,
- FILTER_LEVEL_ELT_INDEX (level, elt),
- FALSE);
+ gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
level = elt->children;
}
indices = gtk_tree_path_get_indices (path);
if (filter->priv->root == NULL)
- gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
level = FILTER_LEVEL (filter->priv->root);
depth = gtk_tree_path_get_depth (path);
elt = gtk_tree_model_filter_get_nth_visible (filter, level, indices[i]);
if (!elt->children)
- gtk_tree_model_filter_build_level (filter, level,
- FILTER_LEVEL_ELT_INDEX (level, elt),
- FALSE);
+ gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
level = elt->children;
}
GtkTreePath *retval;
FilterLevel *level;
FilterElt *elt;
- gint elt_index;
g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), NULL);
g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL, NULL);
level = iter->user_data;
elt = iter->user_data2;
- elt_index = FILTER_LEVEL_ELT_INDEX (level, elt);
if (!elt->visible)
return NULL;
{
int i = 0, index = 0;
- while (i < elt_index)
+ while (&g_array_index (level->array, FilterElt, i) != elt)
{
if (g_array_index (level->array, FilterElt, i).visible)
index++;
}
gtk_tree_path_prepend_index (retval, index);
- elt_index = level->parent_elt_index;
+ elt = level->parent_elt;
level = level->parent_level;
}
int i = 0;
if (!filter->priv->root)
- gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
if (!filter->priv->root)
return FALSE;
else
{
int i = 0;
- FilterElt *elt;
-
- elt = FILTER_ELT (parent->user_data2);
- if (elt->children == NULL)
+ if (FILTER_ELT (parent->user_data2)->children == NULL)
gtk_tree_model_filter_build_level (filter,
FILTER_LEVEL (parent->user_data),
- FILTER_LEVEL_ELT_INDEX (parent->user_data, elt),
+ FILTER_ELT (parent->user_data2),
FALSE);
-
- if (elt->children == NULL)
+ if (FILTER_ELT (parent->user_data2)->children == NULL)
return FALSE;
- if (elt->children->visible_nodes <= 0)
+ if (FILTER_ELT (parent->user_data2)->children->visible_nodes <= 0)
return FALSE;
iter->stamp = filter->priv->stamp;
- iter->user_data = elt->children;
+ iter->user_data = FILTER_ELT (parent->user_data2)->children;
level = FILTER_LEVEL (iter->user_data);
if (!elt->children
&& gtk_tree_model_iter_has_child (filter->priv->child_model, &child_iter))
gtk_tree_model_filter_build_level (filter, FILTER_LEVEL (iter->user_data),
- FILTER_LEVEL_ELT_INDEX (iter->user_data, elt),
- FALSE);
+ elt, FALSE);
if (elt->children && elt->children->visible_nodes > 0)
return TRUE;
if (!iter)
{
if (!filter->priv->root)
- gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
if (filter->priv->root)
return FILTER_LEVEL (filter->priv->root)->visible_nodes;
gtk_tree_model_iter_has_child (filter->priv->child_model, &child_iter))
gtk_tree_model_filter_build_level (filter,
FILTER_LEVEL (iter->user_data),
- FILTER_LEVEL_ELT_INDEX (iter->user_data, elt),
- FALSE);
+ elt, FALSE);
if (elt->children)
return elt->children->visible_nodes;
{
iter->stamp = GTK_TREE_MODEL_FILTER (model)->priv->stamp;
iter->user_data = level->parent_level;
- iter->user_data2 = FILTER_LEVEL_PARENT_ELT (level);
+ iter->user_data2 = level->parent_elt;
return TRUE;
}
if (level->ext_ref_count == 1)
{
FilterLevel *parent_level = level->parent_level;
- gint parent_elt_index = level->parent_elt_index;
+ FilterElt *parent_elt = level->parent_elt;
/* we were at zero -- time to decrease the zero_ref_count val */
while (parent_level)
{
- g_array_index (parent_level->array, FilterElt, 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;
}
if (level->ext_ref_count == 0)
{
FilterLevel *parent_level = level->parent_level;
- gint parent_elt_index = level->parent_elt_index;
+ FilterElt *parent_elt = level->parent_elt;
/* we are at zero -- time to increase the zero_ref_count val */
while (parent_level)
{
- g_array_index (parent_level->array, FilterElt, 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;
}
child_indices = gtk_tree_path_get_indices (real_path);
if (filter->priv->root == NULL && build_levels)
- gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
level = FILTER_LEVEL (filter->priv->root);
for (i = 0; i < gtk_tree_path_get_depth (real_path); i++)
{
gtk_tree_path_append_index (retval, j);
if (!tmp->children && build_levels)
- gtk_tree_model_filter_build_level (filter, level,
- FILTER_LEVEL_ELT_INDEX (level, tmp),
- FALSE);
+ gtk_tree_model_filter_build_level (filter, level, tmp, FALSE);
level = tmp->children;
found_child = TRUE;
}
gtk_tree_path_append_index (retval, j);
if (!tmp->children && build_levels)
- gtk_tree_model_filter_build_level (filter, level,
- FILTER_LEVEL_ELT_INDEX (level, tmp),
- FALSE);
+ gtk_tree_model_filter_build_level (filter, level, tmp, FALSE);
level = tmp->children;
found_child = TRUE;
}
retval = gtk_tree_path_new ();
filter_indices = gtk_tree_path_get_indices (filter_path);
if (!filter->priv->root)
- gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);
+ gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
level = FILTER_LEVEL (filter->priv->root);
for (i = 0; i < gtk_tree_path_get_depth (filter_path); i++)
filter_indices[i]);
if (elt->children == NULL)
- gtk_tree_model_filter_build_level (filter, level,
- FILTER_LEVEL_ELT_INDEX (level, elt),
- FALSE);
+ gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
if (!level || level->visible_nodes <= filter_indices[i])
{