GtkTreeStore wrapper. not built yet

2002-12-11  Mike Kestner  <mkestner@ximian.com>

	* e-storage-set-store.[ch] : GtkTreeStore wrapper. not built yet

svn path=/trunk/; revision=19101

2 files changed, 1452 insertions, 0 deletions

diff --git a/shell/e-storage-set-store.c b/shell/e-storage-set-store.c
new file mode 100644
index 0000000000..e2816d87d2
--- /dev/null
+++ b/shell/e-storage-set-store.c
@@ -0,0 +1,1361 @@
+/* e-storage-set-store.c
+ * Copyright (C) 2002 Ximian, 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/gtktreemodel.h>
+#include <gtk/gtktreednd.h>
+
+#include "e-icon-factory.h"
+#include "e-storage-set-store.h"
+#include "e-shell-constants.h"
+
+struct _EStorageSetStorePrivate {
+	EStorageSet *storage_set;
+	GHashTable *checkboxes;
+	GHashTable *path_to_node;
+	GHashTable *type_name_to_pixbuf;
+	GNode *root;
+	gint stamp;
+	EStorageSetStoreHasCheckBoxFunc has_checkbox_func;
+	gpointer has_checkbox_func_data;
+};
+
+#define G_NODE(node) ((GNode *)(node))
+#define VALID_ITER(iter, store) ((iter) != NULL && (iter)->user_data != NULL && (store)->priv->stamp == (iter)->stamp)
+#define VALID_COL(col) ((col) >= 0 && (col) < E_STORAGE_SET_STORE_COLUMN_COUNT)
+
+static GObjectClass *parent_class = NULL;
+
+static gboolean
+has_checkbox (EStorageSetStore *store, const gchar *folder_path)
+{
+	EStorageSetStorePrivate *priv = store->priv;
+
+	g_return_val_if_fail (folder_path != NULL, FALSE);
+
+	if (strchr (folder_path + 1, '/') == NULL) {
+		/* If it's a toplevel, never allow checking it.  */
+		return FALSE;
+	}
+
+#if 0
+	if (priv->has_checkbox_func)
+		return (* priv->has_checkbox_func) (priv->storage_set,
+						    folder_path,
+						    priv->has_checkbox_func_data);
+#endif
+
+	return TRUE;
+}
+
+
+/* GtkTreeModel interface implementation */
+
+static guint
+esss_get_flags(GtkTreeModel *tree_model)
+{
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), 0);
+
+	return GTK_TREE_MODEL_ITERS_PERSIST;
+}
+
+static gint
+esss_get_n_columns(GtkTreeModel *tree_model)
+{
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), 0);
+
+	return E_STORAGE_SET_STORE_COLUMN_COUNT;
+}
+
+static GType
+esss_get_column_type(GtkTreeModel *tree_model, gint index)
+{
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+	GType retval;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), G_TYPE_INVALID);
+	g_return_val_if_fail(VALID_COL(index), G_TYPE_INVALID);
+
+	switch (index) {
+	case E_STORAGE_SET_STORE_COLUMN_NAME:
+		retval = G_TYPE_STRING;
+		break;
+	case E_STORAGE_SET_STORE_COLUMN_HIGHLIGHT:
+		retval = G_TYPE_INT;
+		break;
+	case E_STORAGE_SET_STORE_COLUMN_CHECKED:
+	case E_STORAGE_SET_STORE_COLUMN_CHECKABLE:
+		retval = G_TYPE_BOOLEAN;
+		break;
+	case E_STORAGE_SET_STORE_COLUMN_ICON:
+		retval = GDK_TYPE_PIXBUF;
+		break;
+	default:
+		g_assert_not_reached ();
+	}
+
+	return retval;
+}
+
+static gboolean
+esss_get_iter(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path)
+{
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+	GtkTreeIter parent;
+	gint *indices;
+	gint depth, i;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), FALSE);
+	g_return_val_if_fail(iter != NULL, FALSE);
+
+	indices = gtk_tree_path_get_indices(path);
+	depth = gtk_tree_path_get_depth(path);
+
+	g_return_val_if_fail(depth > 0, FALSE);
+
+	parent.stamp = store->priv->stamp;
+	parent.user_data = store->priv->root;
+
+	for (i = 0; i < depth; i++) {
+		if (!gtk_tree_model_iter_nth_child (tree_model, iter, &parent, indices[i]))
+			return FALSE;
+		parent = *iter;
+	}
+
+	return TRUE;
+}
+
+static GtkTreePath *
+tree_path_from_node (EStorageSetStore *store, GNode *node)
+{
+	GtkTreePath *retval;
+	GNode *tmp_node, *curr_node;
+	gint i = 0;
+
+	if (node == store->priv->root)
+		return NULL;
+
+	retval = gtk_tree_path_new();
+
+	for (curr_node = node; curr_node != store->priv->root; curr_node = curr_node->parent) {
+
+		if (curr_node->parent == NULL) {
+			gtk_tree_path_free(retval);
+			return NULL;
+		}
+
+		for (i = 0, tmp_node = curr_node->parent->children; 
+		     tmp_node && tmp_node != curr_node;
+		     i++, tmp_node = tmp_node->next);
+
+		if (tmp_node == NULL) {
+			gtk_tree_path_free(retval);
+			return NULL;
+		}
+
+		gtk_tree_path_prepend_index(retval, i);
+	}
+
+	return retval;
+}
+
+static GtkTreePath *
+esss_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter)
+{
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), NULL);
+	g_return_val_if_fail(VALID_ITER(iter, store), NULL);
+
+	if (iter->user_data == store->priv->root)
+		return NULL;
+
+	return tree_path_from_node (store, G_NODE (iter->user_data));
+}
+
+static GdkPixbuf *
+get_pixbuf_for_folder (EStorageSetStore *store, EFolder *folder)
+{
+	const char *type_name;
+	EStorageSetStorePrivate *priv;
+	EFolderTypeRegistry *folder_type_registry;
+	EStorageSet *storage_set;
+	GdkPixbuf *icon_pixbuf;
+	GdkPixbuf *scaled_pixbuf;
+	const char *custom_icon_name;
+	int icon_pixbuf_width, icon_pixbuf_height;
+
+	priv = store->priv;
+
+	custom_icon_name = e_folder_get_custom_icon_name (folder);
+	if (custom_icon_name != NULL)
+		return e_icon_factory_get_icon (custom_icon_name, TRUE);
+
+	type_name = e_folder_get_type_string (folder);
+
+	scaled_pixbuf = g_hash_table_lookup (priv->type_name_to_pixbuf, type_name);
+	if (scaled_pixbuf != NULL)
+		return scaled_pixbuf;
+
+	storage_set = priv->storage_set;
+	folder_type_registry = e_storage_set_get_folder_type_registry (storage_set);
+
+	icon_pixbuf = e_folder_type_registry_get_icon_for_type (folder_type_registry,
+								type_name, TRUE);
+
+	if (icon_pixbuf == NULL)
+		return NULL;
+
+	icon_pixbuf_width = gdk_pixbuf_get_width (icon_pixbuf);
+	icon_pixbuf_height = gdk_pixbuf_get_height (icon_pixbuf);
+
+	if (icon_pixbuf_width == E_SHELL_MINI_ICON_SIZE && icon_pixbuf_height == E_SHELL_MINI_ICON_SIZE) {
+		scaled_pixbuf = g_object_ref (icon_pixbuf);
+	} else {
+		scaled_pixbuf = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (icon_pixbuf),
+						gdk_pixbuf_get_has_alpha (icon_pixbuf),
+						gdk_pixbuf_get_bits_per_sample (icon_pixbuf),
+						E_SHELL_MINI_ICON_SIZE, E_SHELL_MINI_ICON_SIZE);
+
+		gdk_pixbuf_scale (icon_pixbuf, scaled_pixbuf,
+				  0, 0, E_SHELL_MINI_ICON_SIZE, E_SHELL_MINI_ICON_SIZE,
+				  0.0, 0.0,
+				  (double) E_SHELL_MINI_ICON_SIZE / gdk_pixbuf_get_width (icon_pixbuf),
+				  (double) E_SHELL_MINI_ICON_SIZE / gdk_pixbuf_get_height (icon_pixbuf),
+				  GDK_INTERP_HYPER);
+	}
+
+	g_hash_table_insert (priv->type_name_to_pixbuf, g_strdup (type_name), scaled_pixbuf);
+
+	return scaled_pixbuf;
+}
+
+static void
+esss_get_value(GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value)
+{
+	gchar *folder_path;
+	const gchar *folder_name;
+	int unread_count;
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+	EFolder *folder;
+	GNode *node;
+	gboolean is_storage;
+
+	g_return_if_fail(E_IS_STORAGE_SET_STORE(tree_model));
+	g_return_if_fail(VALID_ITER(iter, store));
+	g_return_if_fail(VALID_COL(column));
+
+	node = G_NODE (iter->user_data);
+	g_value_init(value, esss_get_column_type(tree_model, column));
+
+	is_storage = (node->parent == store->priv->root);
+
+	if (is_storage)
+		folder_path = g_strconcat ("/", node->data, NULL);
+	else
+		folder_path = g_strdup (node->data);
+
+	folder = e_storage_set_get_folder(store->priv->storage_set, folder_path);
+	g_free (folder_path);
+
+	switch (column) {
+	case E_STORAGE_SET_STORE_COLUMN_NAME:
+		if (!folder) {
+			g_value_set_string(value, "?");
+			return;
+		}
+		folder_name = e_folder_get_name(folder);
+		unread_count = e_folder_get_unread_count(folder);
+		if (unread_count > 0) {
+			gchar *with_unread = g_strdup_printf("%s (%d)", folder_name, unread_count);
+			g_object_set_data_full(G_OBJECT(folder), "name_with_unread", 
+					       with_unread, g_free);
+			g_value_set_string(value, with_unread);
+		} else
+			g_value_set_string(value, folder_name);
+		break;
+
+	case E_STORAGE_SET_STORE_COLUMN_HIGHLIGHT:
+		if (!folder) {
+			g_value_set_boolean(value, FALSE);
+			return;
+		}
+		g_value_set_int(value, is_storage || e_folder_get_highlighted(folder) ? PANGO_WEIGHT_BOLD : 0);
+		break;
+
+	case E_STORAGE_SET_STORE_COLUMN_CHECKED:
+		if (is_storage || !store->priv->checkboxes) {
+			g_value_set_boolean(value, FALSE);
+			return;
+		}
+		g_value_set_boolean(value, 
+			g_hash_table_lookup(store->priv->checkboxes, folder_path) ? TRUE : FALSE);
+		break;
+
+	case E_STORAGE_SET_STORE_COLUMN_CHECKABLE:
+		g_value_set_boolean(value, !is_storage && has_checkbox(store, (gchar *)node->data));
+		break;
+
+	case E_STORAGE_SET_STORE_COLUMN_ICON:
+		if (!is_storage)
+			g_value_set_object (value, get_pixbuf_for_folder (store, folder));
+		break;
+
+	default:
+		g_assert_not_reached ();
+		break;
+	}
+}
+
+static gboolean
+esss_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter)
+{
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), FALSE);
+	g_return_val_if_fail(VALID_ITER(iter, E_STORAGE_SET_STORE(tree_model)), FALSE);
+
+	if (G_NODE(iter->user_data)->next) {
+		iter->user_data = G_NODE(iter->user_data)->next;
+		return TRUE;
+	} else
+		return FALSE;
+}
+
+static gboolean
+esss_iter_children(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent)
+{
+	GNode *children;
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), FALSE);
+	g_return_val_if_fail(iter != NULL, FALSE);
+	g_return_val_if_fail(parent == NULL || parent->user_data != NULL, FALSE);
+	g_return_val_if_fail(parent == NULL || parent->stamp == store->priv->stamp, FALSE);
+
+	if (parent)
+		children = G_NODE(parent->user_data)->children;
+	else
+		children =
+		    G_NODE(store->priv->root)->children;
+
+	if (children) {
+		iter->stamp = store->priv->stamp;
+		iter->user_data = children;
+		return TRUE;
+	} else
+		return FALSE;
+}
+
+static gboolean
+esss_iter_has_child(GtkTreeModel *tree_model, GtkTreeIter *iter)
+{
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), FALSE);
+	g_return_val_if_fail(VALID_ITER(iter, store), FALSE);
+
+	return G_NODE(iter->user_data)->children != NULL;
+}
+
+static gint
+esss_iter_n_children(GtkTreeModel *tree_model, GtkTreeIter *iter)
+{
+	GNode *node;
+	gint i = 0;
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), 0);
+	g_return_val_if_fail(iter == NULL || iter->user_data != NULL, FALSE);
+
+	if (iter == NULL)
+		node = G_NODE(store->priv->root)->children;
+	else
+		node = G_NODE(iter->user_data)->children;
+
+	while (node) {
+		i++;
+		node = node->next;
+	}
+
+	return i;
+}
+
+static gboolean
+esss_iter_nth_child(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n)
+{
+	GNode *parent_node;
+	GNode *child;
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), FALSE);
+	g_return_val_if_fail(iter != NULL, FALSE);
+	g_return_val_if_fail(parent == NULL || parent->user_data != NULL, FALSE);
+
+	if (parent == NULL)
+		parent_node = store->priv->root;
+	else
+		parent_node = parent->user_data;
+
+	child = g_node_nth_child(parent_node, n);
+
+	if (child) {
+		iter->user_data = child;
+		iter->stamp = store->priv->stamp;
+		return TRUE;
+	} else
+		return FALSE;
+}
+
+static gboolean
+esss_iter_parent(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child)
+{
+	GNode *parent;
+	EStorageSetStore *store = (EStorageSetStore *) tree_model;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(tree_model), FALSE);
+	g_return_val_if_fail(iter != NULL, FALSE);
+	g_return_val_if_fail(VALID_ITER(child, store), FALSE);
+
+	parent = G_NODE(child->user_data)->parent;
+
+	g_assert(parent != NULL);
+
+	if (parent != store->priv->root) {
+		iter->user_data = parent;
+		iter->stamp = store->priv->stamp;
+		return TRUE;
+	} else
+		return FALSE;
+}
+
+static void
+esss_tree_model_init(GtkTreeModelIface *iface)
+{
+	iface->get_flags = esss_get_flags;
+	iface->get_n_columns = esss_get_n_columns;
+	iface->get_column_type = esss_get_column_type;
+	iface->get_iter = esss_get_iter;
+	iface->get_path = esss_get_path;
+	iface->get_value = esss_get_value;
+	iface->iter_next = esss_iter_next;
+	iface->iter_children = esss_iter_children;
+	iface->iter_has_child = esss_iter_has_child;
+	iface->iter_n_children = esss_iter_n_children;
+	iface->iter_nth_child = esss_iter_nth_child;
+	iface->iter_parent = esss_iter_parent;
+}
+
+/* GtkTreeDragSource interface implementation */
+
+static gboolean
+esss_drag_data_delete(GtkTreeDragSource *source, GtkTreePath *path)
+{
+	GtkTreeIter iter;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(source), FALSE);
+
+	if (gtk_tree_model_get_iter(GTK_TREE_MODEL(source), &iter, path)) {
+#if 0
+		e_storage_set_store_remove(E_STORAGE_SET_STORE(source), &iter);
+#endif
+		return TRUE;
+	} else {
+		return FALSE;
+	}
+}
+
+static gboolean
+esss_drag_data_get(GtkTreeDragSource *source, GtkTreePath *path, GtkSelectionData *selection_data)
+{
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(source), FALSE);
+
+	/* Note that we don't need to handle the GTK_TREE_MODEL_ROW
+	 * target, because the default handler does it for us, but
+	 * we do anyway for the convenience of someone maybe overriding the
+	 * default handler.
+	 */
+
+	if (gtk_tree_set_row_drag_data(selection_data, GTK_TREE_MODEL(source), path)) {
+		return TRUE;
+	} else {
+		/* FIXME handle text targets at least. */
+	}
+
+	return FALSE;
+}
+
+static void
+esss_drag_source_init(GtkTreeDragSourceIface * iface)
+{
+	iface->drag_data_delete = esss_drag_data_delete;
+	iface->drag_data_get = esss_drag_data_get;
+}
+
+/* GtkTreeDragDest interface implementation */
+
+static void
+copy_node_data(EStorageSetStore *store, GtkTreeIter *src_iter, GtkTreeIter *dest_iter)
+{
+}
+
+static void
+recursive_node_copy(EStorageSetStore * store,
+		    GtkTreeIter * src_iter, GtkTreeIter * dest_iter)
+{
+}
+
+static gboolean
+esss_drag_data_received(GtkTreeDragDest * drag_dest,
+				  GtkTreePath * dest,
+				  GtkSelectionData * selection_data)
+{
+#if 0
+	GtkTreeModel *tree_model;
+	EStorageSetStore *store;
+	GtkTreeModel *src_model = NULL;
+	GtkTreePath *src_path = NULL;
+	gboolean retval = FALSE;
+
+	g_return_val_if_fail(E_IS_STORAGE_SET_STORE(drag_dest), FALSE);
+
+	tree_model = GTK_TREE_MODEL(drag_dest);
+	store = E_STORAGE_SET_STORE(drag_dest);
+
+	validate_tree(store);
+
+	if (gtk_tree_get_row_drag_data(selection_data,
+				       &src_model,
+				       &src_path) &&
+	    src_model == tree_model) {
+		/* Copy the given row to a new position */
+		GtkTreeIter src_iter;
+		GtkTreeIter dest_iter;
+		GtkTreePath *prev;
+
+		if (!gtk_tree_model_get_iter(src_model,
+					     &src_iter, src_path)) {
+			goto out;
+		}
+
+		/* Get the path to insert _after_ (dest is the path to insert _before_) */
+		prev = gtk_tree_path_copy(dest);
+
+		if (!gtk_tree_path_prev(prev)) {
+			GtkTreeIter dest_parent;
+			GtkTreePath *parent;
+			GtkTreeIter *dest_parent_p;
+
+			/* dest was the first spot at the current depth; which means
+			 * we are supposed to prepend.
+			 */
+
+			/* Get the parent, NULL if parent is the root */
+			dest_parent_p = NULL;
+			parent = gtk_tree_path_copy(dest);
+			if (gtk_tree_path_up(parent) &&
+			    gtk_tree_path_get_depth(parent) > 0) {
+				gtk_tree_model_get_iter(tree_model,
+							&dest_parent,
+							parent);
+				dest_parent_p = &dest_parent;
+			}
+			gtk_tree_path_free(parent);
+			parent = NULL;
+
+			e_storage_set_store_prepend(E_STORAGE_SET_STORE(tree_model),
+					       &dest_iter, dest_parent_p);
+
+			retval = TRUE;
+		} else {
+			if (gtk_tree_model_get_iter
+			    (GTK_TREE_MODEL(tree_model), &dest_iter,
+			     prev)) {
+				GtkTreeIter tmp_iter = dest_iter;
+
+				if (GPOINTER_TO_INT
+				    (g_object_get_data
+				     (G_OBJECT(tree_model),
+				      "gtk-tree-model-drop-append"))) {
+					GtkTreeIter parent;
+
+					if (gtk_tree_model_iter_parent
+					    (GTK_TREE_MODEL(tree_model),
+					     &parent, &tmp_iter))
+						e_storage_set_store_append
+						    (E_STORAGE_SET_STORE
+						     (tree_model),
+						     &dest_iter, &parent);
+					else
+						e_storage_set_store_append
+						    (E_STORAGE_SET_STORE
+						     (tree_model),
+						     &dest_iter, NULL);
+				} else
+					e_storage_set_store_insert_after
+					    (E_STORAGE_SET_STORE(tree_model),
+					     &dest_iter, NULL, &tmp_iter);
+				retval = TRUE;
+
+			}
+		}
+
+		g_object_set_data(G_OBJECT(tree_model),
+				  "gtk-tree-model-drop-append", NULL);
+
+		gtk_tree_path_free(prev);
+
+		/* If we succeeded in creating dest_iter, walk src_iter tree branch,
+		 * duplicating it below dest_iter.
+		 */
+
+		if (retval) {
+			recursive_node_copy(store,
+					    &src_iter, &dest_iter);
+		}
+	} else {
+		/* FIXME maybe add some data targets eventually, or handle text
+		 * targets in the simple case.
+		 */
+
+	}
+
+      out:
+
+	if (src_path)
+		gtk_tree_path_free(src_path);
+
+	return retval;
+#else
+	return FALSE;
+#endif
+}
+
+static gboolean
+esss_row_drop_possible(GtkTreeDragDest * drag_dest,
+				 GtkTreePath * dest_path,
+				 GtkSelectionData * selection_data)
+{
+#if 0
+	GtkTreeModel *src_model = NULL;
+	GtkTreePath *src_path = NULL;
+	GtkTreePath *tmp = NULL;
+	gboolean retval = FALSE;
+
+	if (!gtk_tree_get_row_drag_data(selection_data,
+					&src_model, &src_path))
+		goto out;
+
+	/* can only drag to ourselves */
+	if (src_model != GTK_TREE_MODEL(drag_dest))
+		goto out;
+
+	/* Can't drop into ourself. */
+	if (gtk_tree_path_is_ancestor(src_path, dest_path))
+		goto out;
+
+	/* Can't drop if dest_path's parent doesn't exist */
+	{
+		GtkTreeIter iter;
+
+		if (gtk_tree_path_get_depth(dest_path) > 1) {
+			tmp = gtk_tree_path_copy(dest_path);
+			gtk_tree_path_up(tmp);
+
+			if (!gtk_tree_model_get_iter
+			    (GTK_TREE_MODEL(drag_dest), &iter, tmp))
+				goto out;
+		}
+	}
+
+	/* Can otherwise drop anywhere. */
+	retval = TRUE;
+
+      out:
+
+	if (src_path)
+		gtk_tree_path_free(src_path);
+	if (tmp)
+		gtk_tree_path_free(tmp);
+
+	return retval;
+#else
+	return FALSE;
+#endif
+}
+
+static void
+esss_drag_dest_init(GtkTreeDragDestIface * iface)
+{
+	iface->drag_data_received = esss_drag_data_received;
+	iface->row_drop_possible = esss_row_drop_possible;
+}
+
+typedef struct {
+	gint offset;
+	GNode *node;
+} SortTuple;
+
+static gint
+folder_sort_callback (gconstpointer a, gconstpointer b, gpointer user_data)
+{
+	EStorageSetStore *store = (EStorageSetStore *) user_data;
+        EStorageSetStorePrivate *priv = store->priv;
+        EFolder *folder_1, *folder_2;
+        char *folder_path_1, *folder_path_2;
+        int priority_1, priority_2;
+
+
+        folder_path_1 = (gchar *)((SortTuple *)a)->node->data;
+        folder_path_2 = (gchar *)((SortTuple *)b)->node->data;
+
+        folder_1 = e_storage_set_get_folder (priv->storage_set, folder_path_1);
+        folder_2 = e_storage_set_get_folder (priv->storage_set, folder_path_2);
+
+        priority_1 = e_folder_get_sorting_priority (folder_1);
+        priority_2 = e_folder_get_sorting_priority (folder_2);
+
+        if (priority_1 == priority_2)
+                return g_utf8_collate (e_folder_get_name (folder_1), e_folder_get_name (folder_2));
+        else if (priority_1 < priority_2)
+                return -1;
+        else                    /* priority_1 > priority_2 */
+                return +1;
+}
+
+static gint
+storage_sort_callback (gconstpointer a, gconstpointer b, gpointer user_data)
+{
+	char *folder_path_1;
+	char *folder_path_2;
+	gboolean path_1_local;
+	gboolean path_2_local;
+
+        folder_path_1 = (gchar *)((SortTuple *)a)->node->data;
+        folder_path_2 = (gchar *)((SortTuple *)b)->node->data;
+
+	/* FIXME bad hack to put the "my evolution" and "local" storages on
+	 *            top.  */
+
+	if (strcmp (folder_path_1, E_SUMMARY_STORAGE_NAME) == 0)
+		return -1;
+	if (strcmp (folder_path_2, E_SUMMARY_STORAGE_NAME) == 0)
+		return +1;
+
+	path_1_local = ! strcmp (folder_path_1, E_LOCAL_STORAGE_NAME);
+	path_2_local = ! strcmp (folder_path_2, E_LOCAL_STORAGE_NAME);
+
+	if (path_1_local && path_2_local)
+		return 0;
+	if (path_1_local)
+		return -1;
+	if (path_2_local)
+		return 1;
+
+	return g_utf8_collate (folder_path_1, folder_path_2);
+}
+
+static void
+esss_sort (EStorageSetStore *store, GNode *parent, GCompareDataFunc callback)
+{
+	GtkTreeIter iter;
+	GArray *sort_array;
+	GNode *node;
+	GNode *tmp_node;
+	gint list_length;
+	gint i;
+	gint *new_order;
+	GtkTreePath *path;
+
+	node = parent->children;
+	if (node == NULL || node->next == NULL)
+		return;
+
+	list_length = 0;
+	for (tmp_node = node; tmp_node; tmp_node = tmp_node->next)
+		list_length++;
+
+	sort_array = g_array_sized_new(FALSE, FALSE, sizeof(SortTuple), list_length);
+
+	i = 0;
+	for (tmp_node = node; tmp_node; tmp_node = tmp_node->next) {
+		SortTuple tuple;
+
+		tuple.offset = i;
+		tuple.node = tmp_node;
+		g_array_append_val(sort_array, tuple);
+		i++;
+	}
+
+	/* Sort the array */
+	g_array_sort_with_data(sort_array, callback, store);
+
+	for (i = 0; i < list_length - 1; i++) {
+		g_array_index(sort_array, SortTuple, i).node->next =
+		    g_array_index(sort_array, SortTuple, i + 1).node;
+		g_array_index(sort_array, SortTuple, i + 1).node->prev =
+		    g_array_index(sort_array, SortTuple, i).node;
+	}
+	g_array_index(sort_array, SortTuple, list_length - 1).node->next = NULL;
+	g_array_index(sort_array, SortTuple, 0).node->prev = NULL;
+	parent->children = g_array_index(sort_array, SortTuple, 0).node;
+
+	/* Let the world know about our new order */
+	new_order = g_new(gint, list_length);
+	for (i = 0; i < list_length; i++)
+		new_order[i] = g_array_index(sort_array, SortTuple, i).offset;
+
+	iter.stamp = store->priv->stamp;
+	iter.user_data = parent;
+	path = esss_get_path(GTK_TREE_MODEL(store), &iter);
+	gtk_tree_model_rows_reordered(GTK_TREE_MODEL(store), path, &iter, new_order);
+	if (path)
+		gtk_tree_path_free(path);
+	g_free(new_order);
+	g_array_free(sort_array, TRUE);
+}
+
+static void
+esss_init(EStorageSetStore *store)
+{
+	store->priv = g_new0(EStorageSetStorePrivate, 1);
+
+	store->priv->storage_set = NULL;
+	store->priv->checkboxes = NULL;
+	store->priv->root = g_node_new(NULL);
+	do {
+		store->priv->stamp = g_random_int();
+	} while (store->priv->stamp == 0);
+
+	store->priv->path_to_node = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+	store->priv->type_name_to_pixbuf = g_hash_table_new (g_str_hash, g_str_equal);
+}
+
+static void
+esss_dispose(GObject *object)
+{
+	EStorageSetStore *store = E_STORAGE_SET_STORE(object);
+
+	if (store->priv->storage_set)
+		g_object_unref(store->priv->storage_set);
+	store->priv->storage_set = NULL;
+
+	(*parent_class->dispose) (object);
+}
+
+static void
+node_free (GNode *node, gpointer data)
+{
+	g_free (node->data);
+}
+
+static void
+pixbuf_free_func (gpointer key, gpointer value, gpointer user_data)
+{
+	g_free (key);
+	g_object_unref (value);
+}
+
+static void
+esss_finalize(GObject *object)
+{
+	EStorageSetStore *store = E_STORAGE_SET_STORE(object);
+
+	g_node_children_foreach(store->priv->root, G_TRAVERSE_ALL, node_free, NULL);
+
+	g_hash_table_foreach (store->priv->type_name_to_pixbuf, pixbuf_free_func, NULL);
+	g_hash_table_destroy (store->priv->type_name_to_pixbuf);
+	g_hash_table_destroy (store->priv->path_to_node);
+	if (store->priv->checkboxes)
+		g_hash_table_destroy (store->priv->checkboxes);
+
+	g_free (store->priv);
+
+	(*parent_class->finalize) (object);
+}
+
+static void
+esss_class_init(EStorageSetStoreClass *class)
+{
+	GObjectClass *object_class;
+
+	parent_class = g_type_class_peek_parent(class);
+	object_class = (GObjectClass *) class;
+
+	object_class->dispose = esss_dispose;
+	object_class->finalize = esss_finalize;
+}
+
+GType
+e_storage_set_store_get_type(void)
+{
+	static GType store_type = 0;
+
+	if (!store_type) {
+		static const GTypeInfo store_info = {
+			sizeof(EStorageSetStoreClass),
+			NULL,	/* base_init */
+			NULL,	/* base_finalize */
+			(GClassInitFunc) esss_class_init,
+			NULL,	/* class_finalize */
+			NULL,	/* class_data */
+			sizeof(EStorageSetStore),
+			0,	/* n_preallocs */
+			(GInstanceInitFunc) esss_init
+		};
+
+		static const GInterfaceInfo tree_model_info = {
+			(GInterfaceInitFunc)
+			    esss_tree_model_init,
+			NULL,
+			NULL
+		};
+
+		static const GInterfaceInfo drag_source_info = {
+			(GInterfaceInitFunc)
+			    esss_drag_source_init,
+			NULL,
+			NULL
+		};
+
+		static const GInterfaceInfo drag_dest_info = {
+			(GInterfaceInitFunc) esss_drag_dest_init,
+			NULL,
+			NULL
+		};
+
+		store_type = g_type_register_static(G_TYPE_OBJECT, "EStorageSetStore", &store_info, 0);
+
+		g_type_add_interface_static(store_type, GTK_TYPE_TREE_MODEL, &tree_model_info);
+		g_type_add_interface_static(store_type, GTK_TYPE_TREE_DRAG_SOURCE, &drag_source_info);
+		g_type_add_interface_static(store_type, GTK_TYPE_TREE_DRAG_DEST, &drag_dest_info);
+	}
+
+	return store_type;
+}
+
+/* Handling of the "changed" signal in EFolders displayed in the EStorageSetStore.  */
+
+typedef struct {
+	EStorageSetStore *store;
+	GNode * node;
+} FolderChangedCallbackData;
+
+static void
+folder_changed_cb (EFolder *folder, void *data)
+{
+	FolderChangedCallbackData *callback_data;
+	GtkTreePath *path;
+	GtkTreeIter iter;
+
+	callback_data = (FolderChangedCallbackData *) data;
+	iter.user_data = callback_data->node;
+	iter.stamp = callback_data->store->priv->stamp;
+	path = esss_get_path (GTK_TREE_MODEL (callback_data->store), &iter);
+
+	gtk_tree_model_row_changed (GTK_TREE_MODEL (callback_data->store), path, &iter);
+	if (path)
+		gtk_tree_path_free (path);
+}
+
+static void
+folder_name_changed_cb (EFolder *folder, void *data)
+{
+	FolderChangedCallbackData *callback_data;
+
+	callback_data = (FolderChangedCallbackData *) data;
+
+	esss_sort (callback_data->store, callback_data->node->parent, folder_sort_callback);
+}
+
+static void
+setup_folder_changed_callbacks (EStorageSetStore *store, EFolder *folder, GNode *node)
+{
+	FolderChangedCallbackData *callback_data = g_new0 (FolderChangedCallbackData, 1);
+	callback_data->store = store;
+	callback_data->node = node;
+
+	g_signal_connect (G_OBJECT (folder), "changed",
+			  G_CALLBACK (folder_changed_cb), callback_data);
+
+	g_signal_connect_data (G_OBJECT (folder), "name_changed",
+			       G_CALLBACK (folder_name_changed_cb), 
+			       callback_data, (GClosureNotify)g_free, 0);
+}
+
+static void
+insert_folders (EStorageSetStore *store, GNode *parent, EStorage *storage, const gchar *path)
+{
+	EStorageSetStorePrivate *priv;
+	GList *folder_path_list, *p;
+	const gchar *storage_name = e_storage_get_name (storage);
+
+	priv = store->priv;
+
+	folder_path_list = e_storage_get_subfolder_paths (storage, path);
+	if (folder_path_list == NULL)
+		return;
+
+	for (p = folder_path_list; p != NULL; p = p->next) {
+		EFolder *folder;
+		const char *subpath = (const char *) p->data;
+		char *folder_path = g_strconcat ("/", storage_name, subpath, NULL);
+		gchar *key = g_strdup (folder_path+1);
+		GNode *node = g_node_new (folder_path);
+
+		g_node_append (parent, node);
+		g_hash_table_replace (priv->path_to_node, key, node);
+
+		folder = e_storage_get_folder (storage, subpath);
+		setup_folder_changed_callbacks (store, folder, node);
+
+		insert_folders (store, node, storage, subpath);
+	}
+
+	esss_sort (store, parent, folder_sort_callback);
+
+	e_free_string_list (folder_path_list);
+}
+
+/* StorageSet signal handling.  */
+
+static void
+new_storage_cb (EStorageSet *storage_set, EStorage *storage, void *data)
+{
+	EStorageSetStore *store = E_STORAGE_SET_STORE (data);
+	EStorageSetStorePrivate *priv = store->priv;
+	gchar *storage_name = g_strdup (e_storage_get_name (storage));
+	GNode *node = g_node_new (g_strdup (e_storage_get_name (storage)));
+	GtkTreePath *path;
+	GtkTreeIter iter;
+
+	g_hash_table_replace (priv->path_to_node, storage_name, node);
+	g_node_append (priv->root, node);
+	esss_sort (store, priv->root, storage_sort_callback);
+
+	iter.user_data = node;
+	iter.stamp = store->priv->stamp;
+	path = esss_get_path (GTK_TREE_MODEL (store), &iter);
+	gtk_tree_model_row_inserted (GTK_TREE_MODEL (store), path, &iter);
+	if (path)
+		gtk_tree_path_free (path);
+}
+
+static void
+removed_storage_cb (EStorageSet *storage_set, EStorage *storage, void *data)
+{
+	EStorageSetStore *store = E_STORAGE_SET_STORE (data);
+	EStorageSetStorePrivate *priv = store->priv;
+	const gchar *name = e_storage_get_name (storage);
+	GNode *node = g_hash_table_lookup (priv->path_to_node, name);
+	GtkTreePath *path;
+
+	if (node == NULL) {
+		g_warning ("EStorageSetStore: unknown storage removed -- %s", name);
+		return;
+	}
+
+	g_hash_table_remove (priv->path_to_node, name);
+	/* FIXME: subfolder hashtable entries might be leaked */
+
+	path = tree_path_from_node (store, node);
+	gtk_tree_model_row_deleted (GTK_TREE_MODEL (store), path);
+	if (path)
+		gtk_tree_path_free (path);
+	g_node_destroy (node);
+}
+
+static void
+new_folder_cb (EStorageSet *storage_set, const char *path, void *data)
+{
+	EStorageSetStore *store = E_STORAGE_SET_STORE (data);
+	EStorageSetStorePrivate *priv = store->priv;
+	GNode *parent_node, *new_node;
+	const char *last_separator;
+	char *parent_path;
+	char *copy_of_path;
+	GtkTreeIter iter;
+	GtkTreePath *treepath;
+
+	last_separator = strrchr (path, E_PATH_SEPARATOR);
+
+	parent_path = g_strndup (path + 1, last_separator - path - 1);
+	parent_node = g_hash_table_lookup (priv->path_to_node, parent_path);
+	g_free (parent_path);
+	if (parent_node == NULL) {
+		g_warning ("EStorageSetStore: EStorageSet reported new subfolder for non-existing folder -- %s", parent_path);
+		return;
+	}
+
+	copy_of_path = g_strdup (path);
+	new_node = g_node_new (copy_of_path);
+	g_node_append (parent_node, new_node);
+	iter.user_data = new_node;
+	iter.stamp = priv->stamp;
+	treepath = esss_get_path (GTK_TREE_MODEL (store), &iter);
+	gtk_tree_model_row_inserted (GTK_TREE_MODEL (store), treepath, &iter);
+	if (treepath)
+		gtk_tree_path_free (treepath);
+
+	g_hash_table_replace (priv->path_to_node, g_strdup (path + 1), new_node);
+
+	setup_folder_changed_callbacks (store, e_storage_set_get_folder (storage_set, path), new_node);
+	esss_sort (store, parent_node, folder_sort_callback);
+}
+
+static void
+updated_folder_cb (EStorageSet *storage_set, const char *path, void *data)
+{
+	EStorageSetStore *store = E_STORAGE_SET_STORE (data);
+	EStorageSetStorePrivate *priv = store->priv;
+	GNode *node;
+	GtkTreeIter iter;
+	GtkTreePath *treepath;
+
+	node = g_hash_table_lookup (priv->path_to_node, path+1);
+	if (node == NULL) {
+		g_warning ("EStorageSetStore: unknown folder updated -- %s", path);
+		return;
+	}
+
+	iter.user_data = node;
+	iter.stamp = priv->stamp;
+	treepath = esss_get_path (GTK_TREE_MODEL (store), &iter);
+	gtk_tree_model_row_changed (GTK_TREE_MODEL (store), treepath, &iter);
+	if (treepath)
+		gtk_tree_path_free (treepath);
+}
+
+static void
+removed_folder_cb (EStorageSet *storage_set, const char *path, void *data)
+{
+	EStorageSetStore *store = E_STORAGE_SET_STORE (data);
+	EStorageSetStorePrivate *priv = store->priv;
+	GNode *node;
+	GtkTreePath *treepath;
+
+	node = g_hash_table_lookup (priv->path_to_node, path+1);
+	if (node == NULL) {
+		g_warning ("EStorageSetStore: unknown folder removed -- %s", path);
+		return;
+	}
+
+	g_hash_table_remove (priv->path_to_node, path+1);
+	/* FIXME: subfolder hashtable entries might be leaked */
+
+	treepath = tree_path_from_node (store, node);
+	gtk_tree_model_row_deleted (GTK_TREE_MODEL (store), treepath);
+	if (treepath)
+		gtk_tree_path_free (treepath);
+	g_node_destroy (node);
+}
+
+static void
+close_folder_cb (EStorageSet *storage_set,
+		 const char *path,
+		 void *data)
+{
+	g_warning ("FIXME: EStorageSetStore: needs to handle close_folder properly");
+#if 0
+	EStorageSetStore *store;
+	EStorageSetStorePrivate *priv;
+	ETreeModel *etree;
+	ETreePath node;
+
+	store = E_STORAGE_SET_STORE (data);
+	priv = store->priv;
+	etree = priv->etree_model;
+
+	node = lookup_node_in_hash (store, path);
+	e_tree_model_node_request_collapse (priv->etree_model, node);
+#endif
+}
+
+static void
+connect_storage_set (EStorageSetStore *store, EStorageSet *storage_set, gboolean show_folders)
+{
+	EStorageSetStorePrivate *priv;
+	GList *storage_list;
+	GList *p;
+
+	priv = store->priv;
+	priv->storage_set = storage_set;
+	g_object_ref (storage_set);
+
+	storage_list = e_storage_set_get_storage_list (storage_set);
+
+	for (p = storage_list; p != NULL; p = p->next) {
+		EStorage *storage = E_STORAGE (p->data);
+		const char *name = e_storage_get_name (storage);
+		GNode *node = g_node_new (g_strdup (name));
+		g_node_append (priv->root, node);
+		g_hash_table_replace (priv->path_to_node, g_strdup (name), node);
+
+		if (show_folders)
+			insert_folders (store, node, storage, "/");
+	}
+
+	esss_sort (store, priv->root, storage_sort_callback);
+
+	e_free_object_list (storage_list);
+
+	g_signal_connect_object (storage_set, "new_storage", G_CALLBACK (new_storage_cb), store, 0);
+	g_signal_connect_object (storage_set, "removed_storage", G_CALLBACK (removed_storage_cb), store, 0);
+	if (!show_folders)
+		return;
+
+	g_signal_connect_object (storage_set, "new_folder", G_CALLBACK (new_folder_cb), store, 0);
+	g_signal_connect_object (storage_set, "updated_folder", G_CALLBACK (updated_folder_cb), store, 0);
+	g_signal_connect_object (storage_set, "removed_folder", G_CALLBACK (removed_folder_cb), store, 0);
+	g_signal_connect_object (storage_set, "close_folder", G_CALLBACK (close_folder_cb), store, 0);
+}
+
+/**
+ * e_storage_set_store_new:
+ * @storage_set: the #EStorageSet that the store exposes
+ * @show_folders: flag indicating if subfolders should be shown
+ *
+ * Creates a new tree store from the provided #EStorageSet.
+ *
+ * Return value: a new #EStorageSetStore
+ **/
+EStorageSetStore *
+e_storage_set_store_new(EStorageSet *storage_set, gboolean show_folders)
+{
+	EStorageSetStore *store;
+	g_return_val_if_fail (E_IS_STORAGE_SET(storage_set), NULL);
+
+	store = E_STORAGE_SET_STORE (g_object_new (E_STORAGE_SET_STORE_TYPE, NULL));
+	connect_storage_set (store, storage_set, show_folders);
+
+	return store;
+}
+
+static gboolean
+esss_real_set_value(EStorageSetStore *store, GtkTreeIter *iter, gint column, GValue *value)
+{
+	gchar *path;
+
+	if (column != E_STORAGE_SET_STORE_COLUMN_CHECKED)
+		return FALSE;
+
+	path = G_NODE (iter->user_data)->data;
+
+	if (g_value_get_boolean (value)) {
+		g_hash_table_insert (store->priv->checkboxes, path, path);
+	} else {
+		g_hash_table_remove (store->priv->checkboxes, path);
+	}
+
+	return TRUE;
+}
+
+/**
+ * e_storage_set_store_set_value:
+ * @store: a #EStorageSetStore
+ * @iter: A valid #GtkTreeIter for the row being modified
+ * @column: column number to modify
+ * @value: new value for the cell
+ *
+ * Sets the data in the cell specified by @iter and @column.
+ * The type of @value must be convertible to the type of the
+ * column.
+ *
+ **/
+void
+e_storage_set_store_set_value(EStorageSetStore *store, GtkTreeIter *iter, 
+			      gint column, GValue *value)
+{
+	g_return_if_fail(E_IS_STORAGE_SET_STORE(store));
+	g_return_if_fail(VALID_ITER(iter, store));
+	g_return_if_fail(VALID_COL(column));
+	g_return_if_fail(G_IS_VALUE(value));
+
+	if (esss_real_set_value (store, iter, column, value)) {
+		GtkTreePath *path;
+
+		path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), iter);
+		gtk_tree_model_row_changed(GTK_TREE_MODEL(store), path, iter);
+		if (path)
+			gtk_tree_path_free(path);
+	}
+}
+
+/**
+ * e_storage_set_store_get_tree_path:
+ * @store: a #EStorageSetStore
+ * @folder_path: a string representing the #EStorageSet folder path
+ * 
+ * Gets a #GtkTreePath corresponding to the folder path specified.
+ *
+ * Return value: the tree path of the folder
+ **/
+GtkTreePath *
+e_storage_set_store_get_tree_path (EStorageSetStore *store, const gchar *folder_path)
+{
+	GNode *node;
+
+	g_return_if_fail(E_IS_STORAGE_SET_STORE(store));
+
+	node = g_hash_table_lookup (store->priv->path_to_node, folder_path+1);
+	
+	return tree_path_from_node (store, node);
+}
+
+/**
+ * e_storage_set_store_get_folder_path:
+ * @store: a #EStorageSetStore
+ * @folder_path: a string representing the #EStorageSet folder path
+ * 
+ * Gets a #GtkTreePath corresponding to the folder path specified.
+ *
+ * Return value: the tree path of the folder
+ **/
+const gchar *
+e_storage_set_store_get_folder_path (EStorageSetStore *store, GtkTreePath *tree_path)
+{
+	GtkTreeIter iter;
+	GNode *node;
+
+	g_return_if_fail(E_IS_STORAGE_SET_STORE(store));
+
+	if (!esss_get_iter (GTK_TREE_MODEL (store), &iter, tree_path))
+		return NULL;
+
+	node = G_NODE (iter.user_data);
+
+	return (const gchar *)node->data;
+}
+
+/**
+ * e_storage_set_store_set_has_checkbox_func:
+ * @store: a #EStorageSetStore
+ * @func: a callback to determine if a row is checked
+ * @data: callback data
+ * 
+ * Sets a callback function for checkbox visibility determination
+ **/
+void
+e_storage_set_store_set_has_checkbox_func (EStorageSetStore *store, EStorageSetStoreHasCheckBoxFunc func, gpointer data)
+{
+	g_return_if_fail(E_IS_STORAGE_SET_STORE(store));
+
+	store->priv->has_checkbox_func = func;
+	store->priv->has_checkbox_func_data = data;
+}
+
diff --git a/shell/e-storage-set-store.h b/shell/e-storage-set-store.h
new file mode 100644
index 0000000000..251b61e519
--- /dev/null
+++ b/shell/e-storage-set-store.h
@@ -0,0 +1,91 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* e-storage-set-store.h
+ *
+ * Copyright (C) 2002  Ximian, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * Author: Mike Kestner
+ */
+
+#ifndef __E_STORAGE_SET_STORE_H__
+#define __E_STORAGE_SET_STORE_H__
+
+#include <gtk/gtktreemodel.h>
+#include "e-storage-set.h"
+#include "e-storage-set-store.h"
+
+G_BEGIN_DECLS
+
+#define E_STORAGE_SET_STORE_TYPE	    (e_storage_set_store_get_type ())
+#define E_STORAGE_SET_STORE(obj)	    (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_STORAGE_SET_STORE_TYPE, EStorageSetStore))
+#define E_STORAGE_SET_STORE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), E_STORAGE_SET_STORE_TYPE, EStorageSetStoreClass))
+#define E_IS_STORAGE_SET_STORE(obj)	    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_STORAGE_SET_STORE_TYPE))
+#define E_IS_STORAGE_SET_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_STORAGE_SET_STORE_TYPE))
+#define E_STORAGE_SET_STORE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), E_STORAGE_SET_STORE_TYPE, EStorageSetStoreClass))
+
+typedef gboolean (* EStorageSetStoreHasCheckBoxFunc)  (EStorageSet *storage_set,
+						       const char  *path,
+						       void        *data);
+
+typedef enum {
+	E_STORAGE_SET_STORE_COLUMN_NAME,
+	E_STORAGE_SET_STORE_COLUMN_HIGHLIGHT,
+	E_STORAGE_SET_STORE_COLUMN_CHECKED,
+	E_STORAGE_SET_STORE_COLUMN_CHECKABLE,
+	E_STORAGE_SET_STORE_COLUMN_ICON,
+	E_STORAGE_SET_STORE_COLUMN_COUNT
+} E_STORAGE_SET_STORE_COLUMN_TYPE;
+
+typedef struct _EStorageSetStore        EStorageSetStore;
+typedef struct _EStorageSetStorePrivate EStorageSetStorePrivate;
+typedef struct _EStorageSetStoreClass   EStorageSetStoreClass;
+
+struct _EStorageSetStore {
+	GObject parent;
+
+	EStorageSetStorePrivate *priv;
+};
+
+struct _EStorageSetStoreClass {
+	GObjectClass parent_class;
+};
+
+
+GType e_storage_set_store_get_type (void);
+
+EStorageSetStore *e_storage_set_store_new (EStorageSet *storage_set, gboolean show_folders);
+
+EStorageSet *e_storage_set_store_get_storage_set (EStorageSetStore *storage_set_store);
+
+void e_storage_set_store_set_checkboxes_list (EStorageSetStore *storage_set_store,
+					      GSList *checkboxes);
+GSList *e_storage_set_store_get_checkboxes_list (EStorageSetStore *storage_set_store);
+
+void e_storage_set_store_set_allow_dnd (EStorageSetStore *storage_set_store,
+					gboolean allow_dnd);
+gboolean e_storage_set_store_get_allow_dnd (EStorageSetStore *storage_set_store);
+						    
+GtkTreePath *e_storage_set_store_get_tree_path (EStorageSetStore *store, const gchar *folder_path);
+
+const gchar *e_storage_set_store_get_folder_path (EStorageSetStore *store, GtkTreePath *tree_path);
+
+void e_storage_set_store_set_has_checkbox_func (EStorageSetStore *storage_set_store,
+					        EStorageSetStoreHasCheckBoxFunc func,
+					        gpointer data);
+
+G_END_DECLS
+
+#endif /* __E_STORAGE_SET_STORE_H__ */