aboutsummaryrefslogtreecommitdiffstats
path: root/lib/widgets
diff options
context:
space:
mode:
Diffstat (limited to 'lib/widgets')
-rw-r--r--lib/widgets/Makefile.am4
-rw-r--r--lib/widgets/eggtreemodelfilter.c2560
-rw-r--r--lib/widgets/eggtreemodelfilter.h123
-rw-r--r--lib/widgets/eggtreemultidnd.c425
-rw-r--r--lib/widgets/eggtreemultidnd.h78
-rw-r--r--lib/widgets/ephy-tree-model-sort.c6
6 files changed, 2 insertions, 3194 deletions
diff --git a/lib/widgets/Makefile.am b/lib/widgets/Makefile.am
index 23aad4b01..809041a49 100644
--- a/lib/widgets/Makefile.am
+++ b/lib/widgets/Makefile.am
@@ -13,10 +13,6 @@ INCLUDES = \
noinst_LTLIBRARIES = libephywidgets.la
libephywidgets_la_SOURCES = \
- eggtreemodelfilter.c \
- eggtreemodelfilter.h \
- eggtreemultidnd.c \
- eggtreemultidnd.h \
ephy-arrow-toolbutton.c \
ephy-arrow-toolbutton.h \
ephy-autocompletion-window.c \
diff --git a/lib/widgets/eggtreemodelfilter.c b/lib/widgets/eggtreemodelfilter.c
deleted file mode 100644
index b3b31a46d..000000000
--- a/lib/widgets/eggtreemodelfilter.c
+++ /dev/null
@@ -1,2560 +0,0 @@
-/* eggtreemodelfilter.c
- * Copyright (C) 2000,2001 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
- * Copyright (C) 2001,2002 Kristian Rietveld <kris@gtk.org>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#include "eggtreemodelfilter.h"
-#include <gtk/gtksignal.h>
-#include <string.h>
-
-/****** NOTE NOTE NOTE WARNING WARNING ******
- *
- * This is *unstable* code. Don't use it in any project. This warning
- * will be removed when this treemodel works.
- */
-
-/*#define VERBOSE 1*/
-
-/* removed this when you add support for i18n */
-#define _
-
-/* ITER FORMAT:
- *
- * iter->stamp = filter->stamp
- * iter->user_data = FilterLevel
- * iter->user_data2 = FilterElt
- */
-
-/* all paths, iters, etc prefixed with c_ are paths, iters, etc relative to the
- * child model.
- */
-
-typedef struct _FilterElt FilterElt;
-typedef struct _FilterLevel FilterLevel;
-
-struct _FilterElt
-{
- GtkTreeIter iter;
- FilterLevel *children;
- gint offset;
- gint ref_count;
- gint zero_ref_count;
- gboolean visible;
-};
-
-struct _FilterLevel
-{
- GArray *array;
- gint ref_count;
-
- FilterElt *parent_elt;
- FilterLevel *parent_level;
-};
-
-/* properties */
-enum
-{
- PROP_0,
- PROP_CHILD_MODEL,
- PROP_VIRTUAL_ROOT
-};
-
-#define EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS(filter) \
- (((EggTreeModelFilter *)filter)->child_flags & GTK_TREE_MODEL_ITERS_PERSIST)
-
-#define FILTER_ELT(filter_elt) ((FilterElt *)filter_elt)
-#define FILTER_LEVEL(filter_level) ((FilterLevel *)filter_level)
-
-/* general code (object/interface init, properties, etc) */
-static void egg_tree_model_filter_init (EggTreeModelFilter *filter);
-static void egg_tree_model_filter_class_init (EggTreeModelFilterClass *filter_class);
-static void egg_tree_model_filter_tree_model_init (GtkTreeModelIface *iface);
-static void egg_tree_model_filter_finalize (GObject *object);
-static void egg_tree_model_filter_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
-static void egg_tree_model_filter_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
-
-/* signal handlers */
-static void egg_tree_model_filter_row_changed (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gpointer data);
-static void egg_tree_model_filter_row_inserted (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gpointer data);
-static void egg_tree_model_filter_row_has_child_toggled (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gpointer data);
-static void egg_tree_model_filter_row_deleted (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- gpointer data);
-static void egg_tree_model_filter_rows_reordered (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gint *new_order,
- gpointer data);
-
-/* GtkTreeModel interface */
-static guint egg_tree_model_filter_get_flags (GtkTreeModel *model);
-static gint egg_tree_model_filter_get_n_columns (GtkTreeModel *model);
-static GType egg_tree_model_filter_get_column_type (GtkTreeModel *model,
- gint index);
-static gboolean egg_tree_model_filter_get_iter (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreePath *path);
-static GtkTreePath *egg_tree_model_filter_get_path (GtkTreeModel *model,
- GtkTreeIter *iter);
-static void egg_tree_model_filter_get_value (GtkTreeModel *model,
- GtkTreeIter *iter,
- gint column,
- GValue *value);
-static gboolean egg_tree_model_filter_iter_next (GtkTreeModel *model,
- GtkTreeIter *iter);
-static gboolean egg_tree_model_filter_iter_children (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreeIter *parent);
-static gboolean egg_tree_model_filter_iter_has_child (GtkTreeModel *model,
- GtkTreeIter *iter);
-static gint egg_tree_model_filter_iter_n_children (GtkTreeModel *model,
- GtkTreeIter *iter);
-static gboolean egg_tree_model_filter_iter_nth_child (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreeIter *parent,
- gint n);
-static gboolean egg_tree_model_filter_iter_parent (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreeIter *child);
-static void egg_tree_model_filter_ref_node (GtkTreeModel *model,
- GtkTreeIter *iter);
-static void egg_tree_model_filter_unref_node (GtkTreeModel *model,
- GtkTreeIter *iter);
-
-
-
-/* private functions */
-static void egg_tree_model_filter_build_level (EggTreeModelFilter *filter,
- FilterLevel *parent_level,
- FilterElt *parent_elt);
-static void egg_tree_model_filter_free_level (EggTreeModelFilter *filter,
- FilterLevel *filter_level);
-
-static GtkTreePath *egg_tree_model_filter_elt_get_path (FilterLevel *level,
- FilterElt *elt,
- GtkTreePath *root);
-
-static GtkTreePath *egg_tree_model_filter_add_root (GtkTreePath *src,
- GtkTreePath *root);
-static GtkTreePath *egg_tree_model_filter_remove_root (GtkTreePath *src,
- GtkTreePath *root);
-
-static void egg_tree_model_filter_increment_stamp (EggTreeModelFilter *filter);
-
-static gboolean egg_tree_model_filter_visible (EggTreeModelFilter *filter,
- GtkTreeIter *child_iter);
-static void egg_tree_model_filter_clear_cache_helper (EggTreeModelFilter *filter,
- FilterLevel *level);
-
-static void egg_tree_model_filter_real_unref_node (GtkTreeModel *model,
- GtkTreeIter *iter,
- gboolean propagate_unref);
-
-static void egg_tree_model_filter_set_model (EggTreeModelFilter *filter,
- GtkTreeModel *child_model);
-static void egg_tree_model_filter_set_root (EggTreeModelFilter *filter,
- GtkTreePath *root);
-
-static GtkTreePath *egg_real_tree_model_filter_convert_child_path_to_path (EggTreeModelFilter *filter,
- GtkTreePath *child_path,
- gboolean build_levels,
- gboolean fetch_childs);
-
-static gboolean egg_tree_model_filter_fetch_child (EggTreeModelFilter *filter,
- FilterLevel *level,
- gint offset);
-static void egg_tree_model_filter_remove_node (EggTreeModelFilter *filter,
- GtkTreeIter *iter,
- gboolean emit_signal);
-static void egg_tree_model_filter_update_childs (EggTreeModelFilter *filter,
- FilterLevel *level,
- FilterElt *elt);
-
-
-static GObjectClass *parent_class = NULL;
-
-GType
-egg_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 (EggTreeModelFilterClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) egg_tree_model_filter_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (EggTreeModelFilter),
- 0, /* n_preallocs */
- (GInstanceInitFunc) egg_tree_model_filter_init
- };
-
- static const GInterfaceInfo tree_model_info =
- {
- (GInterfaceInitFunc) egg_tree_model_filter_tree_model_init,
- NULL,
- NULL
- };
-
- tree_model_filter_type = g_type_register_static (G_TYPE_OBJECT,
- "EggTreeModelFilter",
- &tree_model_filter_info, 0);
-
- g_type_add_interface_static (tree_model_filter_type,
- GTK_TYPE_TREE_MODEL,
- &tree_model_info);
- }
-
- return tree_model_filter_type;
-}
-
-static void
-egg_tree_model_filter_init (EggTreeModelFilter *filter)
-{
- filter->visible_column = -1;
- filter->zero_ref_count = 0;
- filter->visible_method_set = FALSE;
- filter->modify_func_set = FALSE;
-}
-
-static void
-egg_tree_model_filter_class_init (EggTreeModelFilterClass *filter_class)
-{
- GObjectClass *object_class;
-
- object_class = (GObjectClass *) filter_class;
- parent_class = g_type_class_peek_parent (filter_class);
-
- object_class->set_property = egg_tree_model_filter_set_property;
- object_class->get_property = egg_tree_model_filter_get_property;
-
- object_class->finalize = egg_tree_model_filter_finalize;
-
- /* Properties -- FIXME: write a better description ... */
- g_object_class_install_property (object_class,
- PROP_CHILD_MODEL,
- g_param_spec_object ("child_model",
- "The child model",
- "The model for the TreeModelFilter to filter",
- GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
- g_object_class_install_property (object_class,
- PROP_VIRTUAL_ROOT,
- g_param_spec_boxed ("virtual_root",
- "The virtual root",
- "The virtual root (relative to the child model) for this filtermodel",
- GTK_TYPE_TREE_PATH,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-}
-
-static void
-egg_tree_model_filter_tree_model_init (GtkTreeModelIface *iface)
-{
- iface->get_flags = egg_tree_model_filter_get_flags;
- iface->get_n_columns = egg_tree_model_filter_get_n_columns;
- iface->get_column_type = egg_tree_model_filter_get_column_type;
- iface->get_iter = egg_tree_model_filter_get_iter;
- iface->get_path = egg_tree_model_filter_get_path;
- iface->get_value = egg_tree_model_filter_get_value;
- iface->iter_next = egg_tree_model_filter_iter_next;
- iface->iter_children = egg_tree_model_filter_iter_children;
- iface->iter_has_child = egg_tree_model_filter_iter_has_child;
- iface->iter_n_children = egg_tree_model_filter_iter_n_children;
- iface->iter_nth_child = egg_tree_model_filter_iter_nth_child;
- iface->iter_parent = egg_tree_model_filter_iter_parent;
- iface->ref_node = egg_tree_model_filter_ref_node;
- iface->unref_node = egg_tree_model_filter_unref_node;
-}
-
-
-static void
-egg_tree_model_filter_finalize (GObject *object)
-{
- EggTreeModelFilter *filter = (EggTreeModelFilter *) object;
-
- egg_tree_model_filter_set_model (filter, NULL);
-
- if (filter->virtual_root)
- gtk_tree_path_free (filter->virtual_root);
-
- if (filter->root)
- egg_tree_model_filter_free_level (filter, filter->root);
-
- if (filter->modify_types)
- g_free (filter->modify_types);
-
- /* must chain up */
- parent_class->finalize (object);
-}
-
-static void
-egg_tree_model_filter_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
-{
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (object);
-
- switch (prop_id)
- {
- case PROP_CHILD_MODEL:
- egg_tree_model_filter_set_model (filter, g_value_get_object (value));
- break;
- case PROP_VIRTUAL_ROOT:
- egg_tree_model_filter_set_root (filter, g_value_get_boxed (value));
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static void
-egg_tree_model_filter_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
-{
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (object);
-
- switch (prop_id)
- {
- case PROP_CHILD_MODEL:
- g_value_set_object (value, filter->child_model);
- break;
- case PROP_VIRTUAL_ROOT:
- g_value_set_boxed (value, filter->virtual_root);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-/* helpers */
-
-static void
-egg_tree_model_filter_build_level (EggTreeModelFilter *filter,
- FilterLevel *parent_level,
- FilterElt *parent_elt)
-{
- GtkTreeIter iter;
- GtkTreeIter root;
- FilterLevel *new_level;
- gint length = 0;
- gint i;
-
- g_assert (filter->child_model != NULL);
-
- if (!parent_level)
- {
- if (filter->virtual_root)
- {
- if (gtk_tree_model_get_iter (filter->child_model, &root, filter->virtual_root) == FALSE)
- return;
- length = gtk_tree_model_iter_n_children (filter->child_model, &root);
-
-#ifdef VERBOSE
- g_print ("-- vroot %d children\n", length);
-#endif
-
- if (gtk_tree_model_iter_children (filter->child_model, &iter, &root) == FALSE)
- return;
- }
- else
- {
- if (!gtk_tree_model_get_iter_first (filter->child_model, &iter))
- return;
- length = gtk_tree_model_iter_n_children (filter->child_model, NULL);
- }
- }
- else
- {
- GtkTreeIter parent_iter;
- GtkTreeIter child_parent_iter;
-
- parent_iter.stamp = filter->stamp;
- parent_iter.user_data = parent_level;
- parent_iter.user_data2 = parent_elt;
-
- egg_tree_model_filter_convert_iter_to_child_iter (filter,
- &child_parent_iter,
- &parent_iter);
- if (gtk_tree_model_iter_children (filter->child_model, &iter, &child_parent_iter) == FALSE)
- return;
-
- /* stamp may have changed */
- egg_tree_model_filter_convert_iter_to_child_iter (filter,
- &child_parent_iter,
- &parent_iter);
- length = gtk_tree_model_iter_n_children (filter->child_model, &child_parent_iter);
- }
-
- g_return_if_fail (length > 0);
-
-#ifdef VERBOSE
- g_print ("-- building new level with %d childs\n", length);
-#endif
-
- new_level = g_new (FilterLevel, 1);
- new_level->array = g_array_sized_new (FALSE, FALSE,
- sizeof (FilterElt),
- length);
- new_level->ref_count = 0;
- new_level->parent_elt = parent_elt;
- new_level->parent_level = parent_level;
-
- if (parent_elt)
- parent_elt->children = new_level;
- else
- filter->root = new_level;
-
- /* increase the count of zero ref_counts */
- while (parent_level)
- {
- parent_elt->zero_ref_count++;
-
- parent_elt = parent_level->parent_elt;
- parent_level = parent_level->parent_level;
- }
- filter->zero_ref_count++;
-
-#ifdef VERBOSE
- g_print ("_build_level: zero ref count on filter is now %d\n",
- filter->zero_ref_count);
-#endif
-
- i = 0;
- do
- {
- if (egg_tree_model_filter_visible (filter, &iter))
- {
- FilterElt filter_elt;
-
- filter_elt.offset = i;
- filter_elt.zero_ref_count = 0;
- filter_elt.ref_count = 0;
- filter_elt.children = NULL;
- filter_elt.visible = TRUE;
-
- if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
- filter_elt.iter = iter;
-
- g_array_append_val (new_level->array, filter_elt);
- }
- i++;
- }
- while (gtk_tree_model_iter_next (filter->child_model, &iter));
-}
-
-static void
-egg_tree_model_filter_free_level (EggTreeModelFilter *filter,
- FilterLevel *filter_level)
-{
- gint i;
-
- g_assert (filter_level);
-
- if (filter_level->ref_count == 0)
- {
- FilterLevel *parent_level = filter_level->parent_level;
- FilterElt *parent_elt = filter_level->parent_elt;
-
- do
- {
- if (parent_elt)
- parent_elt->zero_ref_count--;
-
- if (parent_level)
- {
- parent_elt = parent_level->parent_elt;
- parent_level = parent_level->parent_level;
- }
- }
- while (parent_level);
- filter->zero_ref_count--;
- }
-
-#ifdef VERBOSE
- g_print ("freeing level\n");
- g_print ("zero ref count is %d\n", filter->zero_ref_count);
-#endif
-
- for (i = 0; i < filter_level->array->len; i++)
- {
- if (g_array_index (filter_level->array, FilterElt, i).children)
- egg_tree_model_filter_free_level (filter,
- FILTER_LEVEL (g_array_index (filter_level->array, FilterElt, i).children));
- }
-
- if (filter_level->parent_elt)
- filter_level->parent_elt->children = NULL;
- else
- filter->root = NULL;
-
- g_array_free (filter_level->array, TRUE);
- filter_level->array = NULL;
-
- g_free (filter_level);
- filter_level = NULL;
-}
-
-static GtkTreePath *
-egg_tree_model_filter_elt_get_path (FilterLevel *level,
- FilterElt *elt,
- GtkTreePath *root)
-{
- FilterLevel *walker = level;
- FilterElt *walker2 = elt;
- GtkTreePath *path;
- GtkTreePath *real_path;
-
- g_return_val_if_fail (level != NULL, NULL);
- g_return_val_if_fail (elt != NULL, NULL);
-
- path = gtk_tree_path_new ();
-
- while (walker)
- {
- gtk_tree_path_prepend_index (path, walker2->offset);
-
- walker2 = walker->parent_elt;
- walker = walker->parent_level;
- }
-
- if (root)
- {
- real_path = gtk_tree_path_copy (root);
-
- egg_tree_model_filter_add_root (real_path, path);
- gtk_tree_path_free (path);
- return real_path;
- }
-
- return path;
-}
-
-static GtkTreePath *
-egg_tree_model_filter_add_root (GtkTreePath *src,
- GtkTreePath *root)
-{
- GtkTreePath *retval;
- gint i;
-
- retval = gtk_tree_path_copy (root);
-
- for (i = 0; i < gtk_tree_path_get_depth (src); i++)
- gtk_tree_path_append_index (retval, gtk_tree_path_get_indices (src)[i]);
-
- return retval;
-}
-
-static GtkTreePath *
-egg_tree_model_filter_remove_root (GtkTreePath *src,
- GtkTreePath *root)
-{
- GtkTreePath *retval;
- gint i;
- gint depth;
- gint *indices;
-
- if (gtk_tree_path_get_depth (src) <= gtk_tree_path_get_depth (root))
- return NULL;
-
- depth = gtk_tree_path_get_depth (src);
- indices = gtk_tree_path_get_indices (src);
-
- for (i = 0; i < gtk_tree_path_get_depth (root); i++)
- if (indices[i] != gtk_tree_path_get_indices (root)[i])
- return NULL;
-
- retval = gtk_tree_path_new ();
-
- for (; i < depth; i++)
- gtk_tree_path_append_index (retval, indices[i]);
-
- return retval;
-}
-
-static void
-egg_tree_model_filter_increment_stamp (EggTreeModelFilter *filter)
-{
- do
- {
- filter->stamp++;
- }
- while (filter->stamp == 0);
-
- egg_tree_model_filter_clear_cache (filter);
-}
-
-static gboolean
-egg_tree_model_filter_visible (EggTreeModelFilter *filter,
- GtkTreeIter *child_iter)
-{
- if (filter->visible_func)
- {
- return (filter->visible_func (filter->child_model,
- child_iter,
- filter->visible_data));
- }
- else if (filter->visible_column >= 0)
- {
- GValue val = {0, };
-
- gtk_tree_model_get_value (filter->child_model, child_iter,
- filter->visible_column, &val);
-
- if (g_value_get_boolean (&val))
- {
- g_value_unset (&val);
- return TRUE;
- }
-
- g_value_unset (&val);
- return FALSE;
- }
-
- /* no filter thing set, so always visible */
- return TRUE;
-}
-
-static void
-egg_tree_model_filter_clear_cache_helper (EggTreeModelFilter *filter,
- FilterLevel *level)
-{
- gint i;
-
- g_assert (level);
-
- for (i = 0; i < level->array->len; i++)
- {
- if (g_array_index (level->array, FilterElt, i).zero_ref_count > 0)
- egg_tree_model_filter_clear_cache_helper (filter, g_array_index (level->array, FilterElt, i).children);
- }
-
- if (level->ref_count == 0 && level != filter->root)
- {
- egg_tree_model_filter_free_level (filter, level);
- return;
- }
-}
-
-static gboolean
-egg_tree_model_filter_fetch_child (EggTreeModelFilter *filter,
- FilterLevel *level,
- gint offset)
-{
- gint i = 0;
- gint len;
- GtkTreePath *c_path = NULL;
- GtkTreeIter c_iter;
- GtkTreePath *c_parent_path = NULL;
- GtkTreeIter c_parent_iter;
- FilterElt elt;
-
-#ifdef VERBOSE
- g_print ("_fetch_child: for offset %d\n", offset);
-#endif
-
- /* check if child exists and is visible */
- if (level->parent_elt)
- {
- c_parent_path =
- egg_tree_model_filter_elt_get_path (level->parent_level,
- level->parent_elt,
- filter->virtual_root);
- if (!c_parent_path)
- return FALSE;
- }
- else
- {
- if (filter->virtual_root)
- c_parent_path = gtk_tree_path_copy (filter->virtual_root);
- else
- c_parent_path = NULL;
- }
-
- if (c_parent_path)
- {
- gtk_tree_model_get_iter (filter->child_model,
- &c_parent_iter,
- c_parent_path);
- len = gtk_tree_model_iter_n_children (filter->child_model,
- &c_parent_iter);
-
- c_path = gtk_tree_path_copy (c_parent_path);
- gtk_tree_path_free (c_parent_path);
- }
- else
- {
- len = gtk_tree_model_iter_n_children (filter->child_model, NULL);
- c_path = gtk_tree_path_new ();
- }
-
- gtk_tree_path_append_index (c_path, offset);
- gtk_tree_model_get_iter (filter->child_model, &c_iter, c_path);
- gtk_tree_path_free (c_path);
-
- if (offset >= len || !egg_tree_model_filter_visible (filter, &c_iter))
- return FALSE;
-
- /* add child */
- elt.offset = offset;
- elt.zero_ref_count = 0;
- elt.ref_count = 0;
- elt.children = NULL;
- /* visibility should be FALSE as we don't emit row_inserted */
- elt.visible = FALSE;
-
- if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
- elt.iter = c_iter;
-
- /* find index */
- for (i = 0; i < level->array->len; i++)
- if (g_array_index (level->array, FilterElt, i).offset > offset)
- break;
-
- g_array_insert_val (level->array, i, elt);
-
- for (i = 0; i < level->array->len; i++)
- {
- FilterElt *e = &(g_array_index (level->array, FilterElt, i));
- if (e->children)
- e->children->parent_elt = e;
- }
-
- return TRUE;
-}
-
-static void
-egg_tree_model_filter_remove_node (EggTreeModelFilter *filter,
- GtkTreeIter *iter,
- gboolean emit_signal)
-{
- FilterElt *elt, *parent;
- FilterLevel *level, *parent_level;
- gint offset, i, length, level_refcount;
-
- /* FIXME: this function is very ugly. I need to rethink and
- * rewrite it someday.
- */
-
- level = FILTER_LEVEL (iter->user_data);
- elt = FILTER_ELT (iter->user_data2);
-
- parent = level->parent_elt;
- parent_level = level->parent_level;
- length = level->array->len;
- offset = elt->offset;
-
-#ifdef VERBOSE
- g_print ("|___ removing node\n");
-#endif
-
- /* ref counting */
- while (elt->ref_count > 0)
- egg_tree_model_filter_real_unref_node (GTK_TREE_MODEL (filter),
- iter, FALSE);
-
- level_refcount = level->ref_count;
-
- /* do the ref counting first! this touches the stamp */
- if (emit_signal)
- {
- GtkTreePath *path;
-
- path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);
- egg_tree_model_filter_increment_stamp (filter);
- gtk_tree_model_row_deleted (GTK_TREE_MODEL (filter), path);
- gtk_tree_path_free (path);
- }
-
- if ((length == 1 || level_refcount == 0) &&
- emit_signal && iter->user_data != filter->root)
- {
- /* above code destroyed the level */
- goto emit_has_child_toggled;
- }
-
- if (length == 1)
- {
- /* kill the level */
-#ifdef VERBOSE
- g_print ("killing level ...\n");
-#endif
- egg_tree_model_filter_free_level (filter, level);
-
- if (!filter->root)
- /* we killed the root */
- return;
- }
- else
- {
-#ifdef VERBOSE
- g_print ("removing the node...\n");
-#endif
-
- /* remove the node */
- for (i = 0; i < level->array->len; i++)
- if (elt->offset == g_array_index (level->array, FilterElt, i).offset)
- break;
-
- g_array_remove_index (level->array, i);
-
- for (i = 0; i < level->array->len; i++)
- {
- /* NOTE: here we do *not* decrease offsets, because the node was
- * not removed from the child model
- */
- elt = &g_array_index (level->array, FilterElt, i);
- if (elt->children)
- elt->children->parent_elt = elt;
- }
- }
-
-emit_has_child_toggled:
- /* children are being handled first, so we can check it this way
- *
- * yes this if-statement is ugly
- */
- if ((parent && parent->children && parent->children->array->len <= 1) ||
- (length == 1 && emit_signal && iter->user_data != filter->root))
- {
- /* latest child has been removed, level has been destroyed */
- GtkTreeIter piter;
- GtkTreePath *ppath;
-
- piter.stamp = filter->stamp;
- piter.user_data = parent_level;
- piter.user_data2 = parent;
-
- ppath = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &piter);
-
-#ifdef VERBOSE
- g_print ("emitting has_child_toggled (by _filter_remove)\n");
-#endif
-
- gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),
- ppath, &piter);
- gtk_tree_path_free (ppath);
- }
-}
-
-static void
-egg_tree_model_filter_update_childs (EggTreeModelFilter *filter,
- FilterLevel *level,
- FilterElt *elt)
-{
- GtkTreeIter c_iter;
- GtkTreeIter iter;
-
-#ifdef VERBOSE
- g_print ("~~ a node came back, search childs\n");
-#endif
-
- if (!elt->visible)
- {
-#ifdef VERBOSE
- g_print (" + given elt not visible -- bailing out\n");
-#endif
- return;
- }
-
- iter.stamp = filter->stamp;
- iter.user_data = level;
- iter.user_data2 = elt;
-
- egg_tree_model_filter_convert_iter_to_child_iter (filter, &c_iter, &iter);
-
- if (gtk_tree_model_iter_has_child (filter->child_model, &c_iter))
- {
- GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter),
- &iter);
- gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),
- path,
- &iter);
- if (path)
- gtk_tree_path_free (path);
- }
-}
-
-/* TreeModel signals */
-static void
-egg_tree_model_filter_row_changed (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gpointer data)
-{
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
- GtkTreeIter iter;
- GtkTreeIter real_c_iter;
- GtkTreePath *path;
-
- FilterElt *elt;
- FilterLevel *level;
- gint offset;
-
- gboolean new;
- gboolean free_c_path = FALSE;
-
- g_return_if_fail (c_path != NULL || c_iter != NULL);
-
- if (!c_path)
- {
- c_path = gtk_tree_model_get_path (c_model, c_iter);
- free_c_path = TRUE;
- }
-
- if (c_iter)
- real_c_iter = *c_iter;
- else
- gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
-
- if (!filter->root)
- {
- gint i;
- FilterLevel *root;
-
- /* build root level */
- egg_tree_model_filter_build_level (filter, NULL, NULL);
-
- root = FILTER_LEVEL (filter->root);
-
- /* FIXME:
- * we set the visibilities to FALSE here, so we ever emit
- * a row_inserted. maybe it's even better to emit row_inserted
- * here, not sure.
- */
- if (root)
- for (i = 0; i < root->array->len; i++)
- g_array_index (root->array, FilterElt, i).visible = FALSE;
- }
-
- path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
- c_path,
- FALSE,
- TRUE);
- if (!path)
- goto done;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);
-
- level = FILTER_LEVEL (iter.user_data);
- elt = FILTER_ELT (iter.user_data2);
- offset = elt->offset;
- new = egg_tree_model_filter_visible (filter, c_iter);
-
- if (elt->visible == TRUE && new == FALSE)
- {
-#ifdef VERBOSE
- g_print ("visible to false -> delete row\n");
-#endif
- egg_tree_model_filter_remove_node (filter, &iter, TRUE);
- }
- else if (elt->visible == FALSE && new == TRUE)
- {
- GtkTreeIter childs;
-
-#ifdef VERBOSE
- g_print ("visible to true -> insert row\n");
-#endif
-
- elt->visible = TRUE;
-
- egg_tree_model_filter_increment_stamp (filter);
- /* update stamp */
- gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);
- gtk_tree_model_row_inserted (GTK_TREE_MODEL (filter), path, &iter);
-
- if (gtk_tree_model_iter_children (c_model, &childs, c_iter))
- egg_tree_model_filter_update_childs (filter, level, elt);
- }
- else if (elt->visible == FALSE && new == FALSE)
- {
-#ifdef VERBOSE
- g_print ("remove node in silence\n");
-#endif
- egg_tree_model_filter_remove_node (filter, &iter, FALSE);
- }
- else
- {
- GtkTreeIter childs;
-
-#ifdef VERBOSE
- g_print ("no change in visibility -- pass row_changed\n");
-#endif
-
- gtk_tree_model_row_changed (GTK_TREE_MODEL (filter), path, &iter);
-
- if (gtk_tree_model_iter_children (c_model, &childs, c_iter) &&
- elt->visible)
- egg_tree_model_filter_update_childs (filter, level, elt);
- }
-
- gtk_tree_path_free (path);
-
-done:
- if (free_c_path)
- gtk_tree_path_free (c_path);
-}
-
-static void
-egg_tree_model_filter_row_inserted (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gpointer data)
-{
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
- GtkTreePath *path;
- GtkTreePath *real_path;
- GtkTreeIter iter;
-
- GtkTreeIter real_c_iter;
-
- FilterElt *elt;
- FilterLevel *level;
- FilterLevel *parent_level;
-
- gint i = 0, offset, index = -1;
-
- gboolean free_c_path = FALSE;
-
- g_return_if_fail (c_path != NULL || c_iter != NULL);
-
- if (!c_path)
- {
- c_path = gtk_tree_model_get_path (c_model, c_iter);
- free_c_path = TRUE;
- }
-
- if (c_iter)
- real_c_iter = *c_iter;
- else
- gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
-
- /* the row has already been inserted. so we need to fixup the
- * virtual root here first
- */
- if (filter->virtual_root)
- {
- if (gtk_tree_path_get_depth (filter->virtual_root) >=
- gtk_tree_path_get_depth (c_path))
- {
- gint level;
- gint *v_indices, *c_indices;
-
- level = gtk_tree_path_get_depth (c_path) - 1;
- v_indices = gtk_tree_path_get_indices (filter->virtual_root);
- c_indices = gtk_tree_path_get_indices (c_path);
-
- if (v_indices[level] >= c_indices[level])
- (v_indices[level])++;
- }
- }
-
- if (!filter->root)
- {
- egg_tree_model_filter_build_level (filter, NULL, NULL);
- /* that already put the inserted iter in the level */
-
- goto done_and_emit;
- }
-
- parent_level = level = FILTER_LEVEL (filter->root);
-
- /* subtract virtual root if necessary */
- if (filter->virtual_root)
- {
- real_path = egg_tree_model_filter_remove_root (c_path,
- filter->virtual_root);
- /* not our kiddo */
- if (!real_path)
- goto done;
- }
- else
- real_path = gtk_tree_path_copy (c_path);
-
- if (gtk_tree_path_get_depth (real_path) - 1 >= 1)
- {
- /* find the parent level */
- while (i < gtk_tree_path_get_depth (real_path) - 1)
- {
- gint j;
-
- if (!level)
- /* we don't cover this signal */
- goto done;
-
- elt = NULL;
- for (j = 0; j < level->array->len; j++)
- if (g_array_index (level->array, FilterElt, j).offset ==
- gtk_tree_path_get_indices (real_path)[i])
- {
- elt = &g_array_index (level->array, FilterElt, j);
- break;
- }
-
- if (!elt)
- /* parent is probably being filtered out */
- goto done;
-
- if (!elt->children)
- {
- GtkTreePath *tmppath;
- GtkTreeIter tmpiter;
-
- tmpiter.stamp = filter->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;
- }
-
- level = elt->children;
- parent_level = level;
- i++;
- }
- }
-
- if (!parent_level)
- goto done;
-
- /* let's try to insert the value */
- offset = gtk_tree_path_get_indices (real_path)[gtk_tree_path_get_depth (real_path) - 1];
-
- /* only insert when visible */
- if (egg_tree_model_filter_visible (filter, &real_c_iter))
- {
- FilterElt felt;
-
- if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
- felt.iter = real_c_iter;
- felt.offset = offset;
- felt.zero_ref_count = 0;
- felt.ref_count = 0;
- felt.visible = TRUE;
- felt.children = NULL;
-
- for (i = 0; i < level->array->len; i++)
- if (g_array_index (level->array, FilterElt, i).offset > offset)
- break;
-
- g_array_insert_val (level->array, i, felt);
- index = i;
- }
-
- /* update the offsets, yes if we didn't insert the node above, there will
- * be a gap here. This will be filled with the node (via fetch_child) when
- * it becomes visible
- */
- for (i = 0; i < level->array->len; i++)
- {
- FilterElt *e = &g_array_index (level->array, FilterElt, i);
- if ((e->offset >= offset) && i != index)
- e->offset++;
- if (e->children)
- e->children->parent_elt = e;
- }
-
- /* don't emit the signal if we aren't visible */
- if (!egg_tree_model_filter_visible (filter, &real_c_iter))
- goto done;
-
-done_and_emit:
- /* NOTE: pass c_path here and NOT real_path. This function does
- * root subtraction itself
- */
- path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
- c_path,
- FALSE, TRUE);
-
- if (!path)
- return;
-
- egg_tree_model_filter_increment_stamp (filter);
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
- gtk_tree_model_row_inserted (GTK_TREE_MODEL (data), path, &iter);
-
-#ifdef VERBOSE
- g_print ("inserted row with offset %d\n", index);
-#endif
-
-done:
- if (free_c_path)
- gtk_tree_path_free (c_path);
-}
-
-static void
-egg_tree_model_filter_row_has_child_toggled (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gpointer data)
-{
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
- GtkTreePath *path;
- GtkTreeIter iter;
-
- g_return_if_fail (c_path != NULL && c_iter != NULL);
-
- /* FIXME: does this code work? */
-
- if (!egg_tree_model_filter_visible (filter, c_iter))
- return;
-
- path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
- c_path,
- FALSE,
- TRUE);
- if (!path)
- return;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
- gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path, &iter);
-
- gtk_tree_path_free (path);
-}
-
-static void
-egg_tree_model_filter_row_deleted (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- gpointer data)
-{
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
- GtkTreePath *path;
- GtkTreeIter iter;
- FilterElt *elt;
- FilterLevel *level;
- gint offset;
- gboolean emit_signal = TRUE;
- gint i;
-
- g_return_if_fail (c_path != NULL);
-
- /* special case the deletion of an ancestor of the virtual root */
- if (filter->virtual_root &&
- (gtk_tree_path_is_ancestor (c_path, filter->virtual_root) ||
- !gtk_tree_path_compare (c_path, filter->virtual_root)))
- {
- gint i;
- GtkTreePath *path;
- FilterLevel *level = FILTER_LEVEL (filter->root);
-
- if (!level)
- return;
-
- /* remove everything in the filter model
- *
- * For now, we just iterate over the root level and emit a
- * row_deleted for each FilterElt. Not sure if this is correct.
- */
-
- egg_tree_model_filter_increment_stamp (filter);
- path = gtk_tree_path_new ();
- gtk_tree_path_append_index (path, 0);
-
- for (i = 0; i < level->array->len; i++)
- gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
-
- gtk_tree_path_free (path);
- egg_tree_model_filter_free_level (filter, filter->root);
-
- return;
- }
-
- /* fixup virtual root */
- if (filter->virtual_root)
- {
- if (gtk_tree_path_get_depth (filter->virtual_root) >=
- gtk_tree_path_get_depth (c_path))
- {
- gint level;
- gint *v_indices, *c_indices;
-
- level = gtk_tree_path_get_depth (c_path) - 1;
- v_indices = gtk_tree_path_get_indices (filter->virtual_root);
- c_indices = gtk_tree_path_get_indices (c_path);
-
- if (v_indices[level] > c_indices[level])
- (v_indices[level])--;
- }
- }
-
- path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
- c_path,
- FALSE,
- FALSE);
- if (!path)
- {
- path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
- c_path,
- FALSE,
- TRUE);
-
- if (!path)
- {
- /* fixup the offsets */
- GtkTreePath *real_path;
-
- if (!filter->root)
- return;
-
- level = FILTER_LEVEL (filter->root);
-
- /* subtract vroot if necessary */
- if (filter->virtual_root)
- {
- real_path = egg_tree_model_filter_remove_root (c_path,
- filter->virtual_root);
- /* we don't handle this */
- if (!real_path)
- return;
- }
- else
- real_path = gtk_tree_path_copy (c_path);
-
- i = 0;
- if (gtk_tree_path_get_depth (real_path) - 1 >= 1)
- {
- while (i < gtk_tree_path_get_depth (real_path) - 1)
- {
- gint j;
-
- if (!level)
- {
- /* we don't cover this */
- gtk_tree_path_free (real_path);
- return;
- }
-
- elt = NULL;
- for (j = 0; j < level->array->len; j++)
- if (g_array_index (level->array, FilterElt, j).offset ==
- gtk_tree_path_get_indices (real_path)[i])
- {
- elt = &g_array_index (level->array, FilterElt, j);
- break;
- }
-
- if (!elt || !elt->children)
- {
- /* parent is filtered out, so no level */
- gtk_tree_path_free (real_path);
- return;
- }
-
- level = elt->children;
- i++;
- }
- }
-
- offset = gtk_tree_path_get_indices (real_path)[gtk_tree_path_get_depth (real_path) - 1];
- gtk_tree_path_free (real_path);
-
- if (!level)
- return;
-
- /* we need:
- * - the offset of the removed item
- * - the level
- */
- for (i = 0; i < level->array->len; i++)
- {
- elt = &g_array_index (level->array, FilterElt, i);
- if (elt->offset > offset)
- elt->offset--;
- if (elt->children)
- elt->children->parent_elt = elt;
- }
-
- return;
- }
-
- emit_signal = FALSE;
- }
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
-
- level = FILTER_LEVEL (iter.user_data);
- elt = FILTER_ELT (iter.user_data2);
- offset = elt->offset;
-
- if (emit_signal)
- {
- if (level->ref_count == 0 && level != filter->root)
- {
- egg_tree_model_filter_increment_stamp (filter);
- gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
-
- gtk_tree_path_free (path);
- return;
- }
-
- egg_tree_model_filter_increment_stamp (filter);
- gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
- iter.stamp = filter->stamp;
-
- while (elt->ref_count > 0)
- egg_tree_model_filter_real_unref_node (GTK_TREE_MODEL (data), &iter,
- FALSE);
- }
-
- if (level->array->len == 1)
- {
- /* kill level */
- egg_tree_model_filter_free_level (filter, level);
- }
- else
- {
- /* remove the row */
- for (i = 0; i < level->array->len; i++)
- if (elt->offset == g_array_index (level->array, FilterElt, i).offset)
- break;
-
- offset = g_array_index (level->array, FilterElt, i).offset;
- g_array_remove_index (level->array, i);
-
- for (i = 0; i < level->array->len; i++)
- {
- elt = &g_array_index (level->array, FilterElt, i);
- if (elt->offset > offset)
- elt->offset--;
- if (elt->children)
- elt->children->parent_elt = elt;
- }
- }
-
- gtk_tree_path_free (path);
-}
-
-static void
-egg_tree_model_filter_rows_reordered (GtkTreeModel *c_model,
- GtkTreePath *c_path,
- GtkTreeIter *c_iter,
- gint *new_order,
- gpointer data)
-{
- FilterElt *elt;
- FilterLevel *level;
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
-
- GtkTreePath *path;
- GtkTreeIter iter;
-
- gint *tmp_array;
- gint i, j, elt_count;
- gint length;
-
- GArray *new_array;
-
- g_return_if_fail (new_order != NULL);
-
-#ifdef VERBOSE
- g_print ("filter: reordering\n");
-#endif
-
- if (c_path == NULL || gtk_tree_path_get_indices (c_path) == NULL)
- {
- if (!filter->root)
- return;
-
- length = gtk_tree_model_iter_n_children (c_model, NULL);
-
- if (filter->virtual_root)
- {
- gint new_pos = -1;
-
- /* reorder root level of path */
- for (i = 0; i < length; i++)
- if (new_order[i] == gtk_tree_path_get_indices (filter->virtual_root)[0])
- new_pos = i;
-
- if (new_pos < 0)
- return;
-
- gtk_tree_path_get_indices (filter->virtual_root)[0] = new_pos;
- return;
- }
-
- path = gtk_tree_path_new ();
- level = FILTER_LEVEL (filter->root);
- }
- else
- {
- GtkTreeIter child_iter;
-
- /* virtual root anchor reordering */
- if (filter->virtual_root &&
- gtk_tree_path_get_depth (c_path) <
- gtk_tree_path_get_depth (filter->virtual_root))
- {
- gint new_pos = -1;
- gint length;
- gint level;
- GtkTreeIter real_c_iter;
-
- level = gtk_tree_path_get_depth (c_path);
-
- if (c_iter)
- real_c_iter = *c_iter;
- else
- gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
-
- length = gtk_tree_model_iter_n_children (c_model, &real_c_iter);
-
- for (i = 0; i < length; i++)
- if (new_order[i] == gtk_tree_path_get_indices (filter->virtual_root)[level])
- new_pos = i;
-
- if (new_pos < 0)
- return;
-
- gtk_tree_path_get_indices (filter->virtual_root)[level] = new_pos;
- return;
- }
-
- path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
- c_path,
- FALSE,
- FALSE);
- if (!path && filter->virtual_root &&
- gtk_tree_path_compare (c_path, filter->virtual_root))
- return;
-
- if (!path && !filter->virtual_root)
- return;
-
- if (!path)
- {
- /* root level mode */
- if (!c_iter)
- gtk_tree_model_get_iter (c_model, c_iter, c_path);
- length = gtk_tree_model_iter_n_children (c_model, c_iter);
- path = gtk_tree_path_new ();
- level = FILTER_LEVEL (filter->root);
- }
- else
- {
- gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
-
- level = FILTER_LEVEL (iter.user_data);
- elt = FILTER_ELT (iter.user_data2);
-
- if (!elt->children)
- {
- gtk_tree_path_free (path);
- return;
- }
-
- level = elt->children;
-
- egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (filter), &child_iter, &iter);
- length = gtk_tree_model_iter_n_children (c_model, &child_iter);
- }
- }
-
- if (level->array->len < 1)
- return;
-
- /* NOTE: we do not bail out here if level->array->len < 2 like
- * GtkTreeModelSort does. This because we do some special tricky
- * reordering.
- */
-
- /* construct a new array */
- new_array = g_array_sized_new (FALSE, FALSE, sizeof (FilterElt),
- level->array->len);
- tmp_array = g_new (gint, level->array->len);
-
- for (i = 0, elt_count = 0; i < length; i++)
- {
- FilterElt *e = NULL;
- gint old_offset = -1;
-
- for (j = 0; j < level->array->len; j++)
- if (g_array_index (level->array, FilterElt, j).offset == new_order[i])
- {
- e = &g_array_index (level->array, FilterElt, j);
- old_offset = j;
- break;
- }
-
- if (!e)
- continue;
-
- tmp_array[elt_count] = old_offset;
- g_array_append_val (new_array, *e);
- g_array_index (new_array, FilterElt, elt_count).offset = i;
- elt_count++;
- }
-
- g_array_free (level->array, TRUE);
- level->array = new_array;
-
- /* fix up stuff */
- for (i = 0; i < level->array->len; i++)
- {
- FilterElt *e = &g_array_index (level->array, FilterElt, i);
- if (e->children)
- e->children->parent_elt = e;
- }
-
- /* emit rows_reordered */
- if (!gtk_tree_path_get_indices (path))
- gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), path, NULL,
- tmp_array);
- else
- gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), path, &iter,
- tmp_array);
-
- /* done */
- g_free (tmp_array);
- gtk_tree_path_free (path);
-}
-
-/* TreeModelIface implementation */
-static guint
-egg_tree_model_filter_get_flags (GtkTreeModel *model)
-{
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), 0);
-
- return 0;
-}
-
-static gint
-egg_tree_model_filter_get_n_columns (GtkTreeModel *model)
-{
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), 0);
- g_return_val_if_fail (filter->child_model != NULL, 0);
-
- if (filter->child_model == NULL)
- return 0;
-
- /* so we can't modify the modify func after this ... */
- filter->modify_func_set = TRUE;
-
- if (filter->modify_n_columns > 0)
- return filter->modify_n_columns;
-
- return gtk_tree_model_get_n_columns (filter->child_model);
-}
-
-static GType
-egg_tree_model_filter_get_column_type (GtkTreeModel *model,
- gint index)
-{
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), G_TYPE_INVALID);
- g_return_val_if_fail (filter->child_model != NULL, G_TYPE_INVALID);
-
- /* so we can't modify the modify func after this ... */
- filter->modify_func_set = TRUE;
-
- if (filter->modify_types)
- {
- g_return_val_if_fail (index < filter->modify_n_columns, G_TYPE_INVALID);
-
- return filter->modify_types[index];
- }
-
- return gtk_tree_model_get_column_type (filter->child_model, index);
-}
-
-static gboolean
-egg_tree_model_filter_get_iter (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreePath *path)
-{
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
- gint *indices;
- FilterLevel *level;
- gint depth, i;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
- g_return_val_if_fail (filter->child_model != NULL, FALSE);
-
- indices = gtk_tree_path_get_indices (path);
-
- if (filter->root == NULL)
- egg_tree_model_filter_build_level (filter, NULL, NULL);
- level = FILTER_LEVEL (filter->root);
-
- depth = gtk_tree_path_get_depth (path);
- if (!depth)
- {
- iter->stamp = 0;
- return FALSE;
- }
-
- for (i = 0; i < depth - 1; i++)
- {
- if (!level || indices[i] >= level->array->len)
- {
- return FALSE;
- }
-
- if (!g_array_index (level->array, FilterElt, indices[i]).children)
- egg_tree_model_filter_build_level (filter, level,
- &g_array_index (level->array,
- FilterElt,
- indices[i]));
- level = g_array_index (level->array, FilterElt, indices[i]).children;
- }
-
- if (!level || indices[i] >= level->array->len)
- {
- iter->stamp = 0;
- return FALSE;
- }
-
- iter->stamp = filter->stamp;
- iter->user_data = level;
- iter->user_data2 = &g_array_index (level->array, FilterElt,
- indices[depth - 1]);
-
- return TRUE;
-}
-
-static GtkTreePath *
-egg_tree_model_filter_get_path (GtkTreeModel *model,
- GtkTreeIter *iter)
-{
- GtkTreePath *retval;
- FilterLevel *level;
- FilterElt *elt;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), NULL);
- g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL, NULL);
- g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp, NULL);
-
- retval = gtk_tree_path_new ();
- level = iter->user_data;
- elt = iter->user_data2;
-
- while (level)
- {
- gtk_tree_path_prepend_index (retval,
- elt - FILTER_ELT (level->array->data));
- elt = level->parent_elt;
- level = level->parent_level;
- }
-
- return retval;
-}
-
-static void
-egg_tree_model_filter_get_value (GtkTreeModel *model,
- GtkTreeIter *iter,
- gint column,
- GValue *value)
-{
- GtkTreeIter child_iter;
- EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (model);
-
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (model));
- g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL);
- g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp);
-
- if (filter->modify_func)
- {
- g_return_if_fail (column < filter->modify_n_columns);
-
- g_value_init (value, filter->modify_types[column]);
- filter->modify_func (model,
- iter,
- value,
- column,
- filter->modify_data);
-
- return;
- }
-
- egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
- gtk_tree_model_get_value (EGG_TREE_MODEL_FILTER (model)->child_model,
- &child_iter, column, value);
-}
-
-static gboolean
-egg_tree_model_filter_iter_next (GtkTreeModel *model,
- GtkTreeIter *iter)
-{
- FilterLevel *level;
- FilterElt *elt;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
- g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL, FALSE);
- g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp, FALSE);
-
- level = iter->user_data;
- elt = iter->user_data2;
-
- if (elt - FILTER_ELT (level->array->data) >= level->array->len - 1)
- {
- iter->stamp = 0;
- return FALSE;
- }
-
- iter->user_data2 = elt + 1;
-
- return TRUE;
-}
-
-static gboolean
-egg_tree_model_filter_iter_children (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreeIter *parent)
-{
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
- FilterLevel *level;
-
- iter->stamp = 0;
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
- g_return_val_if_fail (filter->child_model != NULL, FALSE);
- if (parent)
- g_return_val_if_fail (filter->stamp == parent->stamp, FALSE);
-
- if (!parent)
- {
- if (!filter->root)
- egg_tree_model_filter_build_level (filter, NULL, NULL);
- if (!filter->root)
- return FALSE;
-
- level = filter->root;
- iter->stamp = filter->stamp;
- iter->user_data = level;
- iter->user_data2 = level->array->data;
- }
- else
- {
- if (FILTER_ELT (parent->user_data2)->children == NULL)
- egg_tree_model_filter_build_level (filter,
- FILTER_LEVEL (parent->user_data),
- FILTER_ELT (parent->user_data2));
- if (FILTER_ELT (parent->user_data2)->children == NULL)
- return FALSE;
-
- iter->stamp = filter->stamp;
- iter->user_data = FILTER_ELT (parent->user_data2)->children;
- iter->user_data2 = FILTER_LEVEL (iter->user_data)->array->data;
- }
-
- return TRUE;
-}
-
-static gboolean
-egg_tree_model_filter_iter_has_child (GtkTreeModel *model,
- GtkTreeIter *iter)
-{
- GtkTreeIter child_iter;
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
- FilterElt *elt;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
- g_return_val_if_fail (filter->child_model != NULL, FALSE);
- g_return_val_if_fail (filter->stamp == iter->stamp, FALSE);
-
- filter = EGG_TREE_MODEL_FILTER (model);
-
- egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
- elt = FILTER_ELT (iter->user_data2);
-
- /* we need to build the level to check if not all children are filtered
- * out
- */
- if (!elt->children
- && gtk_tree_model_iter_has_child (filter->child_model, &child_iter))
- egg_tree_model_filter_build_level (filter, FILTER_LEVEL (iter->user_data),
- elt);
-
- if (elt->children && elt->children->array->len > 0)
- return TRUE;
-
- return FALSE;
-}
-
-static gint
-egg_tree_model_filter_iter_n_children (GtkTreeModel *model,
- GtkTreeIter *iter)
-{
- GtkTreeIter child_iter;
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
- FilterElt *elt;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), 0);
- g_return_val_if_fail (filter->child_model != NULL, 0);
- if (iter)
- g_return_val_if_fail (filter->stamp == iter->stamp, 0);
-
- if (!iter)
- {
- int i = 0;
- int count = 0;
- GArray *a;
-
- if (!filter->root)
- egg_tree_model_filter_build_level (filter, NULL, NULL);
-
- a = FILTER_LEVEL (filter->root)->array;
-
- /* count visible nodes */
-
- for (i = 0; i < a->len; i++)
- if (g_array_index (a, FilterElt, i).visible)
- count++;
-
- return count;
- }
-
- elt = FILTER_ELT (iter->user_data2);
- egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
-
- if (!elt->children &&
- gtk_tree_model_iter_has_child (filter->child_model, &child_iter))
- egg_tree_model_filter_build_level (filter,
- FILTER_LEVEL (iter->user_data),
- elt);
-
- if (elt->children && elt->children->array->len)
- {
- int i = 0;
- int count = 0;
- GArray *a = elt->children->array;
-
- /* count visible nodes */
-
- for (i = 0; i < a->len; i++)
- if (g_array_index (a, FilterElt, i).visible)
- count++;
-
- return count;
- }
-
- return 0;
-}
-
-static gboolean
-egg_tree_model_filter_iter_nth_child (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreeIter *parent,
- gint n)
-{
- FilterLevel *level;
- GtkTreeIter children;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
- if (parent)
- g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == parent->stamp, FALSE);
-
- /* use this instead of has_Child to force us to build the level, if needed */
- if (egg_tree_model_filter_iter_children (model, &children, parent) == FALSE)
- {
- iter->stamp = 0;
- return FALSE;
- }
-
- level = children.user_data;
- if (n >= level->array->len)
- {
- iter->stamp = 0;
- return FALSE;
- }
-
- iter->stamp = EGG_TREE_MODEL_FILTER (model)->stamp;
- iter->user_data = level;
- iter->user_data2 = &g_array_index (level->array, FilterElt, n);
-
- return TRUE;
-}
-
-static gboolean
-egg_tree_model_filter_iter_parent (GtkTreeModel *model,
- GtkTreeIter *iter,
- GtkTreeIter *child)
-{
- FilterLevel *level;
-
- iter->stamp = 0;
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
- g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL, FALSE);
- g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == child->stamp, FALSE);
-
- level = child->user_data;
-
- if (level->parent_level)
- {
- iter->stamp = EGG_TREE_MODEL_FILTER (model)->stamp;
- iter->user_data = level->parent_level;
- iter->user_data2 = level->parent_elt;
-
- return TRUE;
- }
-
- return FALSE;
-}
-
-static void
-egg_tree_model_filter_ref_node (GtkTreeModel *model,
- GtkTreeIter *iter)
-{
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
- GtkTreeIter child_iter;
- FilterLevel *level;
- FilterElt *elt;
-
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (model));
- g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL);
- g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp);
-
- egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
-
- gtk_tree_model_ref_node (filter->child_model, &child_iter);
-
- level = iter->user_data;
- elt = iter->user_data2;
-
- elt->ref_count++;
- level->ref_count++;
- if (level->ref_count == 1)
- {
- FilterLevel *parent_level = level->parent_level;
- FilterElt *parent_elt = level->parent_elt;
-
- /* we were at zero -- time to decrease the zero_ref_count val */
- do
- {
- if (parent_elt)
- parent_elt->zero_ref_count--;
-
- if (parent_level)
- {
- parent_elt = parent_level->parent_elt;
- parent_level = parent_level->parent_level;
- }
- }
- while (parent_level);
- filter->zero_ref_count--;
- }
-
-#ifdef VERBOSE
- g_print ("reffed %p\n", iter->user_data2);
- g_print ("zero ref count is now %d\n", filter->zero_ref_count);
- if (filter->zero_ref_count < 0)
- g_warning ("zero_ref_count < 0.");
-#endif
-}
-
-static void
-egg_tree_model_filter_unref_node (GtkTreeModel *model,
- GtkTreeIter *iter)
-{
- egg_tree_model_filter_real_unref_node (model, iter, TRUE);
-}
-
-static void
-egg_tree_model_filter_real_unref_node (GtkTreeModel *model,
- GtkTreeIter *iter,
- gboolean propagate_unref)
-{
- EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
- FilterLevel *level;
- FilterElt *elt;
-
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (model));
- g_return_if_fail (filter->child_model != NULL);
- g_return_if_fail (filter->stamp == iter->stamp);
-
- if (propagate_unref)
- {
- GtkTreeIter child_iter;
- egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
- gtk_tree_model_unref_node (filter->child_model, &child_iter);
- }
-
- level = iter->user_data;
- elt = iter->user_data2;
-
- g_return_if_fail (elt->ref_count > 0);
-
- elt->ref_count--;
- level->ref_count--;
- if (level->ref_count == 0)
- {
- FilterLevel *parent_level = level->parent_level;
- FilterElt *parent_elt = level->parent_elt;
-
- /* we are at zero -- time to increase the zero_ref_count val */
- while (parent_level)
- {
- parent_elt->zero_ref_count++;
-
- parent_elt = parent_level->parent_elt;
- parent_level = parent_level->parent_level;
- }
- filter->zero_ref_count++;
- }
-
-#ifdef VERBOSE
- g_print ("unreffed %p\n", iter->user_data2);
- g_print ("zero ref count is now %d\n", filter->zero_ref_count);
-#endif
-}
-
-/* bits and pieces */
-static void
-egg_tree_model_filter_set_model (EggTreeModelFilter *filter,
- GtkTreeModel *child_model)
-{
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
-
- if (filter->child_model)
- {
- g_signal_handler_disconnect (G_OBJECT (filter->child_model),
- filter->changed_id);
- g_signal_handler_disconnect (G_OBJECT (filter->child_model),
- filter->inserted_id);
- g_signal_handler_disconnect (G_OBJECT (filter->child_model),
- filter->has_child_toggled_id);
- g_signal_handler_disconnect (G_OBJECT (filter->child_model),
- filter->deleted_id);
- g_signal_handler_disconnect (G_OBJECT (filter->child_model),
- filter->reordered_id);
-
- /* reset our state */
- if (filter->root)
- egg_tree_model_filter_free_level (filter, filter->root);
-
- filter->root = NULL;
- g_object_unref (G_OBJECT (filter->child_model));
- filter->visible_column = -1;
- /* FIXME: destroy more crack here? the funcs? */
- }
-
- filter->child_model = child_model;
-
- if (child_model)
- {
- g_object_ref (G_OBJECT (filter->child_model));
- filter->changed_id =
- g_signal_connect (child_model, "row_changed",
- G_CALLBACK (egg_tree_model_filter_row_changed),
- filter);
- filter->inserted_id =
- g_signal_connect (child_model, "row_inserted",
- G_CALLBACK (egg_tree_model_filter_row_inserted),
- filter);
- filter->has_child_toggled_id =
- g_signal_connect (child_model, "row_has_child_toggled",
- G_CALLBACK (egg_tree_model_filter_row_has_child_toggled),
- filter);
- filter->deleted_id =
- g_signal_connect (child_model, "row_deleted",
- G_CALLBACK (egg_tree_model_filter_row_deleted),
- filter);
- filter->reordered_id =
- g_signal_connect (child_model, "rows_reordered",
- G_CALLBACK (egg_tree_model_filter_rows_reordered),
- filter);
-
- filter->child_flags = gtk_tree_model_get_flags (child_model);
- filter->stamp = g_random_int ();
- }
-}
-
-static void
-egg_tree_model_filter_set_root (EggTreeModelFilter *filter,
- GtkTreePath *root)
-{
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
-
- if (!root)
- filter->virtual_root = NULL;
- else
- filter->virtual_root = gtk_tree_path_copy (root);
-}
-
-/* public API */
-
-GtkTreeModel *
-egg_tree_model_filter_new (GtkTreeModel *child_model,
- GtkTreePath *root)
-{
- GtkTreeModel *retval;
-
- g_return_val_if_fail (GTK_IS_TREE_MODEL (child_model), NULL);
-
- retval = GTK_TREE_MODEL (g_object_new (egg_tree_model_filter_get_type (), NULL));
-
- egg_tree_model_filter_set_model (EGG_TREE_MODEL_FILTER (retval),
- child_model);
- egg_tree_model_filter_set_root (EGG_TREE_MODEL_FILTER (retval), root);
-
- return retval;
-}
-
-GtkTreeModel *
-egg_tree_model_filter_get_model (EggTreeModelFilter *filter)
-{
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (filter), NULL);
-
- return filter->child_model;
-}
-
-void
-egg_tree_model_filter_set_visible_func (EggTreeModelFilter *filter,
- EggTreeModelFilterVisibleFunc func,
- gpointer data,
- GtkDestroyNotify destroy)
-{
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
- g_return_if_fail (func != NULL);
- g_return_if_fail (filter->visible_method_set == FALSE);
-
- if (filter->visible_func)
- {
- GtkDestroyNotify d = filter->visible_destroy;
-
- filter->visible_destroy = NULL;
- d (filter->visible_data);
- }
-
- filter->visible_func = func;
- filter->visible_data = data;
- filter->visible_destroy = destroy;
-
- filter->visible_method_set = TRUE;
-}
-
-void
-egg_tree_model_filter_set_modify_func (EggTreeModelFilter *filter,
- gint n_columns,
- GType *types,
- EggTreeModelFilterModifyFunc func,
- gpointer data,
- GtkDestroyNotify destroy)
-{
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
- g_return_if_fail (func != NULL);
- g_return_if_fail (filter->modify_func_set == FALSE);
-
- if (filter->modify_destroy)
- {
- GtkDestroyNotify d = filter->modify_destroy;
-
- filter->modify_destroy = NULL;
- d (filter->modify_data);
- }
-
- filter->modify_n_columns = n_columns;
- filter->modify_types = g_new0 (GType, n_columns);
- memcpy (filter->modify_types, types, sizeof (GType) * n_columns);
- filter->modify_func = func;
- filter->modify_data = data;
- filter->modify_destroy = destroy;
-
- filter->modify_func_set = TRUE;
-}
-
-void
-egg_tree_model_filter_set_visible_column (EggTreeModelFilter *filter,
- gint column)
-{
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
- g_return_if_fail (column >= 0);
- g_return_if_fail (filter->visible_method_set == FALSE);
-
- filter->visible_column = column;
-
- filter->visible_method_set = TRUE;
-}
-
-/* conversion */
-void
-egg_tree_model_filter_convert_child_iter_to_iter (EggTreeModelFilter *filter,
- GtkTreeIter *filter_iter,
- GtkTreeIter *child_iter)
-{
- GtkTreePath *child_path, *path;
-
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
- g_return_if_fail (filter->child_model != NULL);
- g_return_if_fail (filter_iter != NULL);
- g_return_if_fail (child_iter != NULL);
-
- filter_iter->stamp = 0;
-
- child_path = gtk_tree_model_get_path (filter->child_model, child_iter);
- g_return_if_fail (child_path != NULL);
-
- path = egg_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);
- gtk_tree_path_free (path);
-}
-
-void
-egg_tree_model_filter_convert_iter_to_child_iter (EggTreeModelFilter *filter,
- GtkTreeIter *child_iter,
- GtkTreeIter *filter_iter)
-{
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
- g_return_if_fail (filter->child_model != NULL);
- g_return_if_fail (child_iter != NULL);
- g_return_if_fail (filter_iter != NULL);
- g_return_if_fail (filter_iter->stamp == filter->stamp);
-
- if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
- {
- *child_iter = FILTER_ELT (filter_iter->user_data2)->iter;
- }
- else
- {
- GtkTreePath *path;
-
- path = egg_tree_model_filter_elt_get_path (filter_iter->user_data,
- filter_iter->user_data2,
- NULL);
- gtk_tree_model_get_iter (filter->child_model, child_iter, path);
- gtk_tree_path_free (path);
- }
-}
-
-static GtkTreePath *
-egg_real_tree_model_filter_convert_child_path_to_path (EggTreeModelFilter *filter,
- GtkTreePath *child_path,
- gboolean build_levels,
- gboolean fetch_childs)
-{
- gint *child_indices;
- GtkTreePath *retval;
- GtkTreePath *real_path;
- FilterLevel *level;
- gint i;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (filter), NULL);
- g_return_val_if_fail (filter->child_model != NULL, NULL);
- g_return_val_if_fail (child_path != NULL, NULL);
-
- if (!filter->virtual_root)
- real_path = gtk_tree_path_copy (child_path);
- else
- real_path = egg_tree_model_filter_remove_root (child_path,
- filter->virtual_root);
-
- if (!real_path)
- return NULL;
-
- retval = gtk_tree_path_new ();
- child_indices = gtk_tree_path_get_indices (real_path);
-
- if (filter->root == NULL && build_levels)
- egg_tree_model_filter_build_level (filter, NULL, NULL);
- level = FILTER_LEVEL (filter->root);
-
- for (i = 0; i < gtk_tree_path_get_depth (real_path); i++)
- {
- gint j;
- gboolean found_child = FALSE;
-
- if (!level)
- {
- gtk_tree_path_free (real_path);
- gtk_tree_path_free (retval);
- return NULL;
- }
-
- for (j = 0; j < level->array->len; j++)
- {
- if ((g_array_index (level->array, FilterElt, j)).offset == child_indices[i])
- {
- gtk_tree_path_append_index (retval, j);
- if (g_array_index (level->array, FilterElt, j).children == NULL && build_levels)
- egg_tree_model_filter_build_level (filter,
- level,
- &g_array_index (level->array, FilterElt, j));
- level = g_array_index (level->array, FilterElt, j).children;
- found_child = TRUE;
- break;
- }
- }
-
- if (!found_child && fetch_childs)
- {
- /* didn't find the child, let's try to bring it back */
- if (!egg_tree_model_filter_fetch_child (filter, level, child_indices[i]))
- {
- /* not there */
- gtk_tree_path_free (real_path);
- gtk_tree_path_free (retval);
- return NULL;
- }
-
- /* yay, let's search for the child again */
- for (j = 0; j < level->array->len; j++)
- {
- if ((g_array_index (level->array, FilterElt, j)).offset == child_indices[i])
- {
- gtk_tree_path_append_index (retval, j);
- if (g_array_index (level->array, FilterElt, j).children == NULL && build_levels)
- egg_tree_model_filter_build_level (filter,
- level,
- &g_array_index (level->array, FilterElt, j));
- level = g_array_index (level->array, FilterElt, j).children;
- found_child = TRUE;
- break;
- }
- }
-
- if (!found_child)
- {
- /* our happy fun fetch attempt failed ?!?!?! no child! */
- gtk_tree_path_free (real_path);
- gtk_tree_path_free (retval);
- return NULL;
- }
- }
- else if (!found_child && !fetch_childs)
- {
- /* no path */
- gtk_tree_path_free (real_path);
- gtk_tree_path_free (retval);
- return NULL;
- }
- }
-
- gtk_tree_path_free (real_path);
- return retval;
-}
-
-GtkTreePath *
-egg_tree_model_filter_convert_child_path_to_path (EggTreeModelFilter *filter,
- GtkTreePath *child_path)
-{
- /* this function does the sanity checks */
- return egg_real_tree_model_filter_convert_child_path_to_path (filter,
- child_path,
- TRUE,
- TRUE);
-}
-
-GtkTreePath *
-egg_tree_model_filter_convert_path_to_child_path (EggTreeModelFilter *filter,
- GtkTreePath *filter_path)
-{
- gint *filter_indices;
- GtkTreePath *retval;
- FilterLevel *level;
- gint i;
-
- g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (filter), NULL);
- g_return_val_if_fail (filter->child_model != NULL, NULL);
- g_return_val_if_fail (filter_path != NULL, NULL);
-
- /* convert path */
- retval = gtk_tree_path_new ();
- filter_indices = gtk_tree_path_get_indices (filter_path);
- if (!filter->root)
- egg_tree_model_filter_build_level (filter, NULL, NULL);
- level = FILTER_LEVEL (filter->root);
-
- for (i = 0; i < gtk_tree_path_get_depth (filter_path); i++)
- {
- gint count = filter_indices[i];
-
- if (!level || level->array->len <= filter_indices[i])
- {
- gtk_tree_path_free (retval);
- return NULL;
- }
-
- if (g_array_index (level->array, FilterElt, count).children == NULL)
- egg_tree_model_filter_build_level (filter, level, &g_array_index (level->array, FilterElt, count));
-
- if (!level || level->array->len <= filter_indices[i])
- {
- gtk_tree_path_free (retval);
- return NULL;
- }
-
- gtk_tree_path_append_index (retval, g_array_index (level->array, FilterElt, count).offset);
- level = g_array_index (level->array, FilterElt, count).children;
- }
-
- /* apply vroot */
-
- if (filter->virtual_root)
- {
- GtkTreePath *real_retval;
-
- real_retval = egg_tree_model_filter_add_root (retval,
- filter->virtual_root);
- gtk_tree_path_free (retval);
-
- return real_retval;
- }
-
- return retval;
-}
-
-void
-egg_tree_model_filter_clear_cache (EggTreeModelFilter *filter)
-{
- g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
-
- if (filter->zero_ref_count)
- egg_tree_model_filter_clear_cache_helper (filter,
- FILTER_LEVEL (filter->root));
-}
diff --git a/lib/widgets/eggtreemodelfilter.h b/lib/widgets/eggtreemodelfilter.h
deleted file mode 100644
index ada78c1be..000000000
--- a/lib/widgets/eggtreemodelfilter.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/* eggtreemodelfilter.h
- * Copyright (C) 2000,2001 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
- * Copyright (C) 2001,2002 Kristian Rietveld <kris@gtk.org>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#ifndef __EGG_TREE_MODEL_FILTER_H__
-#define __EGG_TREE_MODEL_FILTER_H__
-
-#include <gtk/gtktreemodel.h>
-
-G_BEGIN_DECLS
-
-#define EGG_TYPE_TREE_MODEL_FILTER (egg_tree_model_filter_get_type ())
-#define EGG_TREE_MODEL_FILTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EGG_TYPE_TREE_MODEL_FILTER, EggTreeModelFilter))
-#define EGG_TREE_MODEL_FILTER_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), EGG_TYPE_TREE_MODEL_FILTER, EggTreeModelFilterClass))
-#define EGG_IS_TREE_MODEL_FILTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EGG_TYPE_TREE_MODEL_FILTER))
-#define EGG_IS_TREE_MODEL_FILTER_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), EGG_TYPE_TREE_MODEL_FILTER))
-#define EGG_TREE_MODEL_FILTER_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((obj), EGG_TYPE_TREE_MODEL_FILTER, EggTreeModelFilterClass))
-
-typedef gboolean (* EggTreeModelFilterVisibleFunc) (GtkTreeModel *model,
- GtkTreeIter *iter,
- gpointer data);
-typedef void (* EggTreeModelFilterModifyFunc) (GtkTreeModel *model,
- GtkTreeIter *iter,
- GValue *value,
- gint column,
- gpointer data);
-
-typedef struct _EggTreeModelFilter EggTreeModelFilter;
-typedef struct _EggTreeModelFilterClass EggTreeModelFilterClass;
-
-struct _EggTreeModelFilter
-{
- GObject parent;
-
- /*< private >*/
- gpointer root;
- gint stamp;
- guint child_flags;
- GtkTreeModel *child_model;
- gint zero_ref_count;
-
- GtkTreePath *virtual_root;
-
- EggTreeModelFilterVisibleFunc visible_func;
- gpointer visible_data;
- GtkDestroyNotify visible_destroy;
-
- gint modify_n_columns;
- GType *modify_types;
- EggTreeModelFilterModifyFunc modify_func;
- gpointer modify_data;
- gpointer modify_destroy;
-
- gint visible_column;
-
- gboolean visible_method_set;
- gboolean modify_func_set;
-
- /* signal ids */
- guint changed_id;
- guint inserted_id;
- guint has_child_toggled_id;
- guint deleted_id;
- guint reordered_id;
-};
-
-struct _EggTreeModelFilterClass
-{
- GObjectClass parent_class;
-};
-
-GType egg_tree_model_filter_get_type (void);
-GtkTreeModel * egg_tree_model_filter_new (GtkTreeModel *child_model,
- GtkTreePath *root);
-void egg_tree_model_filter_set_visible_func (EggTreeModelFilter *filter,
- EggTreeModelFilterVisibleFunc func,
- gpointer data,
- GtkDestroyNotify destroy);
-void egg_tree_model_filter_set_modify_func (EggTreeModelFilter *filter,
- gint n_columns,
- GType *types,
- EggTreeModelFilterModifyFunc func,
- gpointer data,
- GtkDestroyNotify destroy);
-void egg_tree_model_filter_set_visible_column (EggTreeModelFilter *filter,
- gint column);
-
-GtkTreeModel *egg_tree_model_filter_get_model (EggTreeModelFilter *filter);
-
-/* conversion */
-void egg_tree_model_filter_convert_child_iter_to_iter (EggTreeModelFilter *filter,
- GtkTreeIter *filter_iter,
- GtkTreeIter *child_iter);
-void egg_tree_model_filter_convert_iter_to_child_iter (EggTreeModelFilter *filter,
- GtkTreeIter *child_iter,
- GtkTreeIter *filter_iter);
-GtkTreePath *egg_tree_model_filter_convert_child_path_to_path (EggTreeModelFilter *filter,
- GtkTreePath *child_path);
-GtkTreePath *egg_tree_model_filter_convert_path_to_child_path (EggTreeModelFilter *path,
- GtkTreePath *filter_path);
-
-
-void egg_tree_model_filter_clear_cache (EggTreeModelFilter *filter);
-
-G_END_DECLS
-
-#endif /* __EGG_TREE_MODEL_FILTER_H__ */
diff --git a/lib/widgets/eggtreemultidnd.c b/lib/widgets/eggtreemultidnd.c
deleted file mode 100644
index 5215a7bfc..000000000
--- a/lib/widgets/eggtreemultidnd.c
+++ /dev/null
@@ -1,425 +0,0 @@
-/* eggtreemultidnd.c
- * Copyright (C) 2001 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * 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.
- */
-
-#include <string.h>
-#include <gtk/gtktreeselection.h>
-#include <gtk/gtksignal.h>
-#include <gtk/gtkwidget.h>
-#include <gtk/gtkmain.h>
-#include <gtk/gtkstock.h>
-#include "eggtreemultidnd.h"
-
-#define EGG_TREE_MULTI_DND_STRING "EggTreeMultiDndString"
-
-typedef struct
-{
- guint pressed_button;
- gint x;
- gint y;
- guint motion_notify_handler;
- guint button_release_handler;
- guint drag_data_get_handler;
- GSList *event_list;
-} EggTreeMultiDndData;
-
-/* CUT-N-PASTE from gtktreeview.c */
-typedef struct _TreeViewDragInfo TreeViewDragInfo;
-struct _TreeViewDragInfo
-{
- GdkModifierType start_button_mask;
- GtkTargetList *source_target_list;
- GdkDragAction source_actions;
-
- GtkTargetList *dest_target_list;
-
- guint source_set : 1;
- guint dest_set : 1;
-};
-
-
-GType
-egg_tree_multi_drag_source_get_type (void)
-{
- static GType our_type = 0;
-
- if (!our_type)
- {
- static const GTypeInfo our_info =
- {
- sizeof (EggTreeMultiDragSourceIface), /* class_size */
- NULL, /* base_init */
- NULL, /* base_finalize */
- NULL,
- NULL, /* class_finalize */
- NULL, /* class_data */
- 0,
- 0, /* n_preallocs */
- NULL
- };
-
- our_type = g_type_register_static (G_TYPE_INTERFACE, "EggTreeMultiDragSource", &our_info, 0);
- }
-
- return our_type;
-}
-
-
-/**
- * egg_tree_multi_drag_source_row_draggable:
- * @drag_source: a #EggTreeMultiDragSource
- * @path: row on which user is initiating a drag
- *
- * Asks the #EggTreeMultiDragSource whether a particular row can be used as
- * the source of a DND operation. If the source doesn't implement
- * this interface, the row is assumed draggable.
- *
- * Return value: %TRUE if the row can be dragged
- **/
-gboolean
-egg_tree_multi_drag_source_row_draggable (EggTreeMultiDragSource *drag_source,
- GList *path_list)
-{
- EggTreeMultiDragSourceIface *iface = EGG_TREE_MULTI_DRAG_SOURCE_GET_IFACE (drag_source);
-
- g_return_val_if_fail (EGG_IS_TREE_MULTI_DRAG_SOURCE (drag_source), FALSE);
- g_return_val_if_fail (iface->row_draggable != NULL, FALSE);
- g_return_val_if_fail (path_list != NULL, FALSE);
-
- if (iface->row_draggable)
- return (* iface->row_draggable) (drag_source, path_list);
- else
- return TRUE;
-}
-
-
-/**
- * egg_tree_multi_drag_source_drag_data_delete:
- * @drag_source: a #EggTreeMultiDragSource
- * @path: row that was being dragged
- *
- * Asks the #EggTreeMultiDragSource to delete the row at @path, because
- * it was moved somewhere else via drag-and-drop. Returns %FALSE
- * if the deletion fails because @path no longer exists, or for
- * some model-specific reason. Should robustly handle a @path no
- * longer found in the model!
- *
- * Return value: %TRUE if the row was successfully deleted
- **/
-gboolean
-egg_tree_multi_drag_source_drag_data_delete (EggTreeMultiDragSource *drag_source,
- GList *path_list)
-{
- EggTreeMultiDragSourceIface *iface = EGG_TREE_MULTI_DRAG_SOURCE_GET_IFACE (drag_source);
-
- g_return_val_if_fail (EGG_IS_TREE_MULTI_DRAG_SOURCE (drag_source), FALSE);
- g_return_val_if_fail (iface->drag_data_delete != NULL, FALSE);
- g_return_val_if_fail (path_list != NULL, FALSE);
-
- return (* iface->drag_data_delete) (drag_source, path_list);
-}
-
-/**
- * egg_tree_multi_drag_source_drag_data_get:
- * @drag_source: a #EggTreeMultiDragSource
- * @path: row that was dragged
- * @selection_data: a #EggSelectionData to fill with data from the dragged row
- *
- * Asks the #EggTreeMultiDragSource to fill in @selection_data with a
- * representation of the row at @path. @selection_data->target gives
- * the required type of the data. Should robustly handle a @path no
- * longer found in the model!
- *
- * Return value: %TRUE if data of the required type was provided
- **/
-gboolean
-egg_tree_multi_drag_source_drag_data_get (EggTreeMultiDragSource *drag_source,
- GList *path_list,
- guint info,
- GtkSelectionData *selection_data)
-{
- EggTreeMultiDragSourceIface *iface = EGG_TREE_MULTI_DRAG_SOURCE_GET_IFACE (drag_source);
-
- g_return_val_if_fail (EGG_IS_TREE_MULTI_DRAG_SOURCE (drag_source), FALSE);
- g_return_val_if_fail (iface->drag_data_get != NULL, FALSE);
- g_return_val_if_fail (path_list != NULL, FALSE);
- g_return_val_if_fail (selection_data != NULL, FALSE);
-
- return (* iface->drag_data_get) (drag_source, path_list, info, selection_data);
-}
-
-static void
-stop_drag_check (GtkWidget *widget)
-{
- EggTreeMultiDndData *priv_data;
- GSList *l;
-
- priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING);
-
- for (l = priv_data->event_list; l != NULL; l = l->next)
- gdk_event_free (l->data);
-
- g_slist_free (priv_data->event_list);
- priv_data->event_list = NULL;
- g_signal_handler_disconnect (widget, priv_data->motion_notify_handler);
- g_signal_handler_disconnect (widget, priv_data->button_release_handler);
-}
-
-static gboolean
-egg_tree_multi_drag_button_release_event (GtkWidget *widget,
- GdkEventButton *event,
- gpointer data)
-{
- EggTreeMultiDndData *priv_data;
- GSList *l;
-
- priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING);
-
- for (l = priv_data->event_list; l != NULL; l = l->next)
- gtk_propagate_event (widget, l->data);
-
- stop_drag_check (widget);
-
- return FALSE;
-}
-
-static void
-selection_foreach (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer data)
-{
- GList **list_ptr;
-
- list_ptr = (GList **) data;
-
- *list_ptr = g_list_prepend (*list_ptr, gtk_tree_row_reference_new (model, path));
-}
-
-static void
-path_list_free (GList *path_list)
-{
- g_list_foreach (path_list, (GFunc) gtk_tree_row_reference_free, NULL);
- g_list_free (path_list);
-}
-
-static void
-set_context_data (GdkDragContext *context,
- GList *path_list)
-{
- g_object_set_data_full (G_OBJECT (context),
- "egg-tree-view-multi-source-row",
- path_list,
- (GDestroyNotify) path_list_free);
-}
-
-static GList *
-get_context_data (GdkDragContext *context)
-{
- return g_object_get_data (G_OBJECT (context),
- "egg-tree-view-multi-source-row");
-}
-
-/* CUT-N-PASTE from gtktreeview.c */
-static TreeViewDragInfo*
-get_info (GtkTreeView *tree_view)
-{
- return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
-}
-
-
-static void
-egg_tree_multi_drag_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
- GtkSelectionData *selection_data,
- guint info,
- guint time)
-{
- GtkTreeView *tree_view;
- GtkTreeModel *model;
- TreeViewDragInfo *di;
- GList *path_list;
-
- tree_view = GTK_TREE_VIEW (widget);
-
- model = gtk_tree_view_get_model (tree_view);
-
- if (model == NULL)
- return;
-
- di = get_info (GTK_TREE_VIEW (widget));
-
- if (di == NULL)
- return;
-
- path_list = get_context_data (context);
-
- if (path_list == NULL)
- return;
-
- /* We can implement the GTK_TREE_MODEL_ROW target generically for
- * any model; for DragSource models there are some other targets
- * we also support.
- */
-
- if (EGG_IS_TREE_MULTI_DRAG_SOURCE (model))
- {
- egg_tree_multi_drag_source_drag_data_get (EGG_TREE_MULTI_DRAG_SOURCE (model),
- path_list,
- info,
- selection_data);
- }
-}
-
-static gboolean
-egg_tree_multi_drag_motion_event (GtkWidget *widget,
- GdkEventMotion *event,
- gpointer data)
-{
- EggTreeMultiDndData *priv_data;
-
- priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING);
-
- if (gtk_drag_check_threshold (widget,
- priv_data->x,
- priv_data->y,
- event->x,
- event->y))
- {
- GList *path_list = NULL;
- GtkTreeSelection *selection;
- GtkTreeModel *model;
- GdkDragContext *context;
- TreeViewDragInfo *di;
-
- di = get_info (GTK_TREE_VIEW (widget));
-
- if (di == NULL)
- return FALSE;
-
- selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
- stop_drag_check (widget);
- gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list);
- path_list = g_list_reverse (path_list);
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
-
- if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list))
- {
- context = gtk_drag_begin (widget,
- di->source_target_list,
- di->source_actions,
- priv_data->pressed_button,
- (GdkEvent*)event);
- set_context_data (context, path_list);
-
- if (g_list_length (path_list) > 1)
- {
- gtk_drag_set_icon_stock (context, GTK_STOCK_DND_MULTIPLE, -2, -2);
- }
- else
- {
- gtk_drag_set_icon_stock (context, GTK_STOCK_DND, -2, -2);
- }
- }
- else
- {
- path_list_free (path_list);
- }
- }
-
- return TRUE;
-}
-
-static gboolean
-egg_tree_multi_drag_button_press_event (GtkWidget *widget,
- GdkEventButton *event,
- gpointer data)
-{
- GtkTreeView *tree_view;
- GtkTreePath *path = NULL;
- GtkTreeViewColumn *column = NULL;
- gint cell_x, cell_y;
- GtkTreeSelection *selection;
- EggTreeMultiDndData *priv_data;
-
- if (event->button == 3)
- return FALSE;
-
- tree_view = GTK_TREE_VIEW (widget);
- priv_data = g_object_get_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING);
- if (priv_data == NULL)
- {
- priv_data = g_new0 (EggTreeMultiDndData, 1);
- g_object_set_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING, priv_data);
- }
-
- if (g_slist_find (priv_data->event_list, event))
- return FALSE;
-
- if (priv_data->event_list)
- {
- /* save the event to be propagated in order */
- priv_data->event_list = g_slist_append (priv_data->event_list, gdk_event_copy ((GdkEvent*)event));
- return TRUE;
- }
-
- if (event->type == GDK_2BUTTON_PRESS)
- return FALSE;
-
- gtk_tree_view_get_path_at_pos (tree_view,
- event->x, event->y,
- &path, &column,
- &cell_x, &cell_y);
-
- selection = gtk_tree_view_get_selection (tree_view);
-
- if (path && gtk_tree_selection_path_is_selected (selection, path))
- {
- priv_data->pressed_button = event->button;
- priv_data->x = event->x;
- priv_data->y = event->y;
- priv_data->event_list = g_slist_append (priv_data->event_list, gdk_event_copy ((GdkEvent*)event));
- priv_data->motion_notify_handler =
- g_signal_connect (G_OBJECT (tree_view), "motion_notify_event", G_CALLBACK (egg_tree_multi_drag_motion_event), NULL);
- priv_data->button_release_handler =
- g_signal_connect (G_OBJECT (tree_view), "button_release_event", G_CALLBACK (egg_tree_multi_drag_button_release_event), NULL);
-
- if (priv_data->drag_data_get_handler == 0)
- {
- priv_data->drag_data_get_handler =
- g_signal_connect (G_OBJECT (tree_view), "drag_data_get", G_CALLBACK (egg_tree_multi_drag_drag_data_get), NULL);
- }
-
- return TRUE;
- }
-
- if (path)
- {
- gtk_tree_path_free (path);
- }
-
- return FALSE;
-}
-
-void
-egg_tree_multi_drag_add_drag_support (GtkTreeView *tree_view)
-{
- g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
- g_signal_connect (G_OBJECT (tree_view), "button_press_event", G_CALLBACK (egg_tree_multi_drag_button_press_event), NULL);
-}
-
diff --git a/lib/widgets/eggtreemultidnd.h b/lib/widgets/eggtreemultidnd.h
deleted file mode 100644
index 460e60239..000000000
--- a/lib/widgets/eggtreemultidnd.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/* eggtreednd.h
- * Copyright (C) 2001 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * 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.
- */
-
-#ifndef __EGG_TREE_MULTI_DND_H__
-#define __EGG_TREE_MULTI_DND_H__
-
-#include <gtk/gtktreemodel.h>
-#include <gtk/gtktreeview.h>
-#include <gtk/gtkdnd.h>
-
-G_BEGIN_DECLS
-
-#define EGG_TYPE_TREE_MULTI_DRAG_SOURCE (egg_tree_multi_drag_source_get_type ())
-#define EGG_TREE_MULTI_DRAG_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EGG_TYPE_TREE_MULTI_DRAG_SOURCE, EggTreeMultiDragSource))
-#define EGG_IS_TREE_MULTI_DRAG_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EGG_TYPE_TREE_MULTI_DRAG_SOURCE))
-#define EGG_TREE_MULTI_DRAG_SOURCE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EGG_TYPE_TREE_MULTI_DRAG_SOURCE, EggTreeMultiDragSourceIface))
-
-typedef struct _EggTreeMultiDragSource EggTreeMultiDragSource; /* Dummy typedef */
-typedef struct _EggTreeMultiDragSourceIface EggTreeMultiDragSourceIface;
-
-struct _EggTreeMultiDragSourceIface
-{
- GTypeInterface g_iface;
-
- /* VTable - not signals */
- gboolean (* row_draggable) (EggTreeMultiDragSource *drag_source,
- GList *path_list);
-
- gboolean (* drag_data_get) (EggTreeMultiDragSource *drag_source,
- GList *path_list,
- guint info,
- GtkSelectionData *selection_data);
-
- gboolean (* drag_data_delete) (EggTreeMultiDragSource *drag_source,
- GList *path_list);
-};
-
-GType egg_tree_multi_drag_source_get_type (void) G_GNUC_CONST;
-
-/* Returns whether the given row can be dragged */
-gboolean egg_tree_multi_drag_source_row_draggable (EggTreeMultiDragSource *drag_source,
- GList *path_list);
-
-/* Deletes the given row, or returns FALSE if it can't */
-gboolean egg_tree_multi_drag_source_drag_data_delete (EggTreeMultiDragSource *drag_source,
- GList *path_list);
-
-
-/* Fills in selection_data with type selection_data->target based on the row
- * denoted by path, returns TRUE if it does anything
- */
-gboolean egg_tree_multi_drag_source_drag_data_get (EggTreeMultiDragSource *drag_source,
- GList *path_list,
- guint info,
- GtkSelectionData *selection_data);
-void egg_tree_multi_drag_add_drag_support (GtkTreeView *tree_view);
-
-
-
-G_END_DECLS
-
-#endif /* __EGG_TREE_MULTI_DND_H__ */
diff --git a/lib/widgets/ephy-tree-model-sort.c b/lib/widgets/ephy-tree-model-sort.c
index bc32131f3..1d03effb8 100644
--- a/lib/widgets/ephy-tree-model-sort.c
+++ b/lib/widgets/ephy-tree-model-sort.c
@@ -37,7 +37,6 @@ static gboolean ephy_tree_model_sort_multi_row_draggable (EggTreeMultiDragSource
GList *path_list);
static gboolean ephy_tree_model_sort_multi_drag_data_get (EggTreeMultiDragSource *drag_source,
GList *path_list,
- guint info,
GtkSelectionData *selection_data);
static gboolean ephy_tree_model_sort_multi_drag_data_delete (EggTreeMultiDragSource *drag_source,
GList *path_list);
@@ -269,7 +268,6 @@ each_node_get_data_binder (EphyDragEachSelectedItemDataGet iteratee,
static gboolean
ephy_tree_model_sort_multi_drag_data_get (EggTreeMultiDragSource *drag_source,
GList *path_list,
- guint info,
GtkSelectionData *selection_data)
{
GdkAtom target;
@@ -285,7 +283,7 @@ ephy_tree_model_sort_multi_drag_data_get (EggTreeMultiDragSource *drag_source,
icontext[1] = drag_source;
ephy_dnd_drag_data_get (NULL, NULL, selection_data,
- info, 0, &icontext, each_node_get_data_binder);
+ 0, &icontext, each_node_get_data_binder);
}
else
@@ -296,7 +294,7 @@ ephy_tree_model_sort_multi_drag_data_get (EggTreeMultiDragSource *drag_source,
icontext[1] = drag_source;
ephy_dnd_drag_data_get (NULL, NULL, selection_data,
- info, 0, &icontext, each_url_get_data_binder);
+ 0, &icontext, each_url_get_data_binder);
}
return TRUE;