GType *modify_types;
GtkTreeModelFilterModifyFunc modify_func;
gpointer modify_data;
- gpointer modify_destroy;
+ GtkDestroyNotify modify_destroy;
gint visible_column;
#define FILTER_LEVEL(filter_level) ((FilterLevel *)filter_level)
/* general code (object/interface init, properties, etc) */
-static void gtk_tree_model_filter_init (GtkTreeModelFilter *filter);
-static void gtk_tree_model_filter_class_init (GtkTreeModelFilterClass *filter_class);
static void gtk_tree_model_filter_tree_model_init (GtkTreeModelIface *iface);
static void gtk_tree_model_filter_drag_source_init (GtkTreeDragSourceIface *iface);
static void gtk_tree_model_filter_finalize (GObject *object);
gint *index);
-static GObjectClass *parent_class = NULL;
-
-GType
-gtk_tree_model_filter_get_type (void)
-{
- static GType tree_model_filter_type = 0;
-
- if (!tree_model_filter_type)
- {
- static const GTypeInfo tree_model_filter_info =
- {
- sizeof (GtkTreeModelFilterClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_tree_model_filter_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkTreeModelFilter),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gtk_tree_model_filter_init
- };
-
- static const GInterfaceInfo tree_model_info =
- {
- (GInterfaceInitFunc) gtk_tree_model_filter_tree_model_init,
- NULL,
- NULL
- };
-
- static const GInterfaceInfo drag_source_info =
- {
- (GInterfaceInitFunc) gtk_tree_model_filter_drag_source_init,
- NULL,
- NULL
- };
-
- tree_model_filter_type = g_type_register_static (G_TYPE_OBJECT,
- I_("GtkTreeModelFilter"),
- &tree_model_filter_info, 0);
-
- g_type_add_interface_static (tree_model_filter_type,
- GTK_TYPE_TREE_MODEL,
- &tree_model_info);
-
- g_type_add_interface_static (tree_model_filter_type,
- GTK_TYPE_TREE_DRAG_SOURCE,
- &drag_source_info);
- }
-
- return tree_model_filter_type;
-}
+G_DEFINE_TYPE_WITH_CODE (GtkTreeModelFilter, gtk_tree_model_filter, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
+ gtk_tree_model_filter_tree_model_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
+ gtk_tree_model_filter_drag_source_init))
static void
gtk_tree_model_filter_init (GtkTreeModelFilter *filter)
GObjectClass *object_class;
object_class = (GObjectClass *) filter_class;
- parent_class = g_type_class_peek_parent (filter_class);
object_class->set_property = gtk_tree_model_filter_set_property;
object_class->get_property = gtk_tree_model_filter_get_property;
if (filter->priv->modify_types)
g_free (filter->priv->modify_types);
+
+ if (filter->priv->modify_destroy)
+ filter->priv->modify_destroy (filter->priv->modify_data);
+
+ if (filter->priv->visible_destroy)
+ filter->priv->visible_destroy (filter->priv->visible_data);
/* must chain up */
- parent_class->finalize (object);
+ G_OBJECT_CLASS (gtk_tree_model_filter_parent_class)->finalize (object);
}
static void
if (parent_level || filter->priv->virtual_root)
gtk_tree_model_filter_unref_node (GTK_TREE_MODEL (filter), iter);
- else
+ else if (elt->ref_count > 0)
gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (filter),
iter, FALSE);
break;
}
- if (v_indices[level] > c_indices[level])
+ if (common_prefix && v_indices[level] > c_indices[level])
(v_indices[level])--;
}
}
/* release the filter model's reference on the node */
if (level->parent_level || filter->priv->virtual_root)
gtk_tree_model_filter_unref_node (GTK_TREE_MODEL (filter), &iter);
- else
+ else if (elt->ref_count > 0)
gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (data), &iter,
FALSE);
if (c_path == NULL || gtk_tree_path_get_indices (c_path) == NULL)
{
- if (!filter->priv->root)
- return;
-
length = gtk_tree_model_iter_n_children (c_model, NULL);
if (filter->priv->virtual_root)
/* virtual root anchor reordering */
if (filter->priv->virtual_root &&
- gtk_tree_path_get_depth (c_path) <
- gtk_tree_path_get_depth (filter->priv->virtual_root))
+ gtk_tree_path_is_ancestor (c_path, filter->priv->virtual_root))
{
gint new_pos = -1;
gint length;
}
}
- if (level->array->len < 1)
+ if (!level || level->array->len < 1)
{
gtk_tree_path_free (path);
return;
gtk_tree_model_ref_node (GTK_TREE_MODEL (filter->priv->child_model), &iter);
gtk_tree_path_up (p);
}
+
+ gtk_tree_path_free (p);
}
static void
gtk_tree_model_unref_node (GTK_TREE_MODEL (filter->priv->child_model), &iter);
gtk_tree_path_up (p);
}
+
+ gtk_tree_path_free (p);
}
static void
* @child_iter: A valid #GtkTreeIter pointing to a row on the child model.
*
* Sets @filter_iter to point to the row in @filter that corresponds to the
- * row pointed at by @child_iter.
+ * row pointed at by @child_iter. If @filter_iter was not set, %FALSE is
+ * returned.
+ *
+ * Return value: %TRUE, if @filter_iter was set, i.e. if @child_iter is a
+ * valid iterator pointing to a visible row in child model.
*
* Since: 2.4
*/
-void
+gboolean
gtk_tree_model_filter_convert_child_iter_to_iter (GtkTreeModelFilter *filter,
GtkTreeIter *filter_iter,
GtkTreeIter *child_iter)
{
+ gboolean ret;
GtkTreePath *child_path, *path;
- g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
- g_return_if_fail (filter->priv->child_model != NULL);
- g_return_if_fail (filter_iter != NULL);
- g_return_if_fail (child_iter != NULL);
+ g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter), FALSE);
+ g_return_val_if_fail (filter->priv->child_model != NULL, FALSE);
+ g_return_val_if_fail (filter_iter != NULL, FALSE);
+ g_return_val_if_fail (child_iter != NULL, FALSE);
filter_iter->stamp = 0;
child_path = gtk_tree_model_get_path (filter->priv->child_model, child_iter);
- g_return_if_fail (child_path != NULL);
+ g_return_val_if_fail (child_path != NULL, FALSE);
path = gtk_tree_model_filter_convert_child_path_to_path (filter,
child_path);
gtk_tree_path_free (child_path);
- g_return_if_fail (path != NULL);
- gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), filter_iter, path);
+ if (!path)
+ return FALSE;
+
+ ret = gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), filter_iter, path);
gtk_tree_path_free (path);
+
+ return ret;
}
/**
* Converts @child_path to a path relative to @filter. That is, @child_path
* points to a path in the child model. The rerturned path will point to the
* same row in the filtered model. If @child_path isn't a valid path on the
- * child model, then %NULL is returned.
+ * child model or points to a row which is not visible in @filter, then %NULL
+ * is returned.
*
* Return value: A newly allocated #GtkTreePath, or %NULL.
*
TRUE,
TRUE);
+ if (!path)
+ return NULL;
+
/* get a new path which only takes visible nodes into account.
* -- if this gives any performance issues, we can write a special
* version of convert_child_path_to_path immediately returning
* a visible-nodes-only path.
*/
- gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);
+ gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (filter), &iter, path);
gtk_tree_path_free (path);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);
* gtk_tree_model_ref_node(). This might be useful if the child model
* being filtered is static (and doesn't change often) and there has been
* a lot of unreffed access to nodes. As a side effect of this function,
- * all unreffed itters will be invalid.
+ * all unreffed iters will be invalid.
*
* Since: 2.4
*/
projects / ~andy / gtk / blobdiff