evolution/mail/mail-component.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* mail-component.c
 *
 * Copyright (C) 2003  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: Ettore Perazzoli <ettore@ximian.com>
 */


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>

#include "e-storage.h"
#include "e-storage-set.h"
#include "e-storage-browser.h"
#include "e-storage-set-view.h"
#include "em-folder-selector.h"
#include "em-folder-selection.h"

#include "folder-browser-factory.h"
#include "mail-config.h"
#include "mail-component.h"
#include "mail-folder-cache.h"
#include "mail-vfolder.h"
#include "mail-mt.h"
#include "mail-ops.h"
#include "mail-send-recv.h"
#include "mail-session.h"

#include "em-popup.h"

#include <gtk/gtklabel.h>

#include <gal/e-table/e-tree.h>
#include <gal/e-table/e-tree-memory.h>

#include <camel/camel.h>

#include <bonobo/bonobo-control.h>
#include <bonobo/bonobo-widget.h>


#define PARENT_TYPE bonobo_object_get_type ()
static BonoboObjectClass *parent_class = NULL;

struct _MailComponentPrivate {
	char *base_directory;

	MailAsyncEvent *async_event;
	GHashTable *storages_hash; /* storage by store */

	EFolderTypeRegistry *folder_type_registry;
	EStorageSet *storage_set;

	RuleContext *search_context;

	char *context_path;	/* current path for right-click menu */

	CamelStore *local_store;
};

static int emc_tree_right_click(ETree *tree, gint row, ETreePath path, gint col, GdkEvent *event, MailComponent *component);

/* Utility functions.  */

/* EPFIXME: Eeek, this totally sucks.  See comment in e-storage.h,
   async_open_folder() should NOT be a signal.  */

struct _StorageConnectedData {
	EStorage *storage;
	char *path;
	EStorageDiscoveryCallback callback;
	void *callback_data;
};
typedef struct _StorageConnectedData StorageConnectedData;

static void
storage_connected_callback (CamelStore *store,
			    CamelFolderInfo *info,
			    StorageConnectedData *data)
{
	EStorageResult result;

	if (info != NULL)
		result = E_STORAGE_OK;
	else
		result = E_STORAGE_GENERICERROR;

	(* data->callback) (data->storage, result, data->path, data->callback_data);

	g_object_unref (data->storage);
	g_free (data->path);
	g_free (data);
}

static void
storage_async_open_folder_callback (EStorage *storage,
				    const char *path,
				    EStorageDiscoveryCallback callback,
				    void *callback_data,
				    CamelStore *store)
{
	StorageConnectedData *storage_connected_data = g_new0 (StorageConnectedData, 1);

	g_object_ref (storage);

	storage_connected_data->storage = storage;
	storage_connected_data->path = g_strdup (path);
	storage_connected_data->callback = callback;
	storage_connected_data->callback_data = callback_data;

	mail_note_store (store, NULL, storage,
			 (void *) storage_connected_callback, storage_connected_data);
}

static void
add_storage (MailComponent *component,
	     const char *name,
	     CamelService *store,
	     CamelException *ex)
{
	EStorage *storage;
	EFolder *root_folder;

	root_folder = e_folder_new (name, "noselect", "");
	storage = e_storage_new (name, root_folder);
	e_storage_declare_has_subfolders(storage, "/", _("Connecting..."));

	camel_object_ref(store);

	g_object_set_data((GObject *)storage, "em-store", store);
	g_hash_table_insert (component->priv->storages_hash, store, storage);

	g_signal_connect(storage, "async_open_folder",
			 G_CALLBACK (storage_async_open_folder_callback), store);

#if 0
	/* EPFIXME these are not needed anymore.  */
	g_signal_connect(storage, "create_folder", G_CALLBACK(storage_create_folder), store);
	g_signal_connect(storage, "remove_folder", G_CALLBACK(storage_remove_folder), store);
	g_signal_connect(storage, "xfer_folder", G_CALLBACK(storage_xfer_folder), store);
#endif

	e_storage_set_add_storage (component->priv->storage_set, storage);

	mail_note_store ((CamelStore *) store, NULL, storage, NULL, NULL);

	g_object_unref (storage);
}

static void
load_accounts(MailComponent *component, EAccountList *accounts)
{
	EIterator *iter;
	
	/* Load each service (don't connect!). Check its provider and
	 * see if this belongs in the shell's folder list. If so, add
	 * it.
	 */
	
	iter = e_list_get_iterator ((EList *) accounts);
	while (e_iterator_is_valid (iter)) {
		EAccountService *service;
		EAccount *account;
		const char *name;
		
		account = (EAccount *) e_iterator_get (iter);
		service = account->source;
		name = account->name;

		if (account->enabled && service->url != NULL)
			mail_component_load_storage_by_uri (component, service->url, name);
		
		e_iterator_next (iter);
	}
	
	g_object_unref (iter);
}

static inline gboolean
type_is_mail (const char *type)
{
	return !strcmp (type, "mail") || !strcmp (type, "mail/public");
}

static inline gboolean
type_is_vtrash (const char *type)
{
	return !strcmp (type, "vtrash");
}

static void
storage_go_online (gpointer key, gpointer value, gpointer data)
{
	CamelStore *store = key;
	CamelService *service = CAMEL_SERVICE (store);

	if (! (service->provider->flags & CAMEL_PROVIDER_IS_REMOTE)
	    || (service->provider->flags & CAMEL_PROVIDER_IS_EXTERNAL))
		return;

	if ((CAMEL_IS_DISCO_STORE (service)
	     && camel_disco_store_status (CAMEL_DISCO_STORE (service)) == CAMEL_DISCO_STORE_OFFLINE)
	    || service->status != CAMEL_SERVICE_DISCONNECTED) {
		mail_store_set_offline (store, FALSE, NULL, NULL);
		mail_note_store (store, NULL, NULL, NULL, NULL);
	}
}

static void
go_online (MailComponent *component)
{
	camel_session_set_online(session, TRUE);
	mail_session_set_interactive(TRUE);
	mail_component_storages_foreach(component, storage_go_online, NULL);
}

static void
setup_search_context (MailComponent *component)
{
	MailComponentPrivate *priv = component->priv;
	char *user = g_strdup_printf ("%s/evolution/searches.xml", g_get_home_dir ()); /* EPFIXME should be somewhere else. */
	char *system = g_strdup (EVOLUTION_PRIVDATADIR "/vfoldertypes.xml");
	
	priv->search_context = rule_context_new ();
	g_object_set_data_full (G_OBJECT (priv->search_context), "user", user, g_free);
	g_object_set_data_full (G_OBJECT (priv->search_context), "system", system, g_free);
	
	rule_context_add_part_set (priv->search_context, "partset", filter_part_get_type (),
				   rule_context_add_part, rule_context_next_part);
	
	rule_context_add_rule_set (priv->search_context, "ruleset", filter_rule_get_type (),
				   rule_context_add_rule, rule_context_next_rule);
	
	rule_context_load (priv->search_context, system, user);
}

/* Local store setup.  */
char *default_drafts_folder_uri;
CamelFolder *drafts_folder = NULL;
char *default_sent_folder_uri;
CamelFolder *sent_folder = NULL;
char *default_outbox_folder_uri;
CamelFolder *outbox_folder = NULL;
char *default_inbox_folder_uri;
CamelFolder *inbox_folder = NULL;

static struct {
	char *base;
	char **uri;
	CamelFolder **folder;
} default_folders[] = {
	{ "Inbox", &default_inbox_folder_uri, &inbox_folder },
	{ "Drafts", &default_drafts_folder_uri, &drafts_folder },
	{ "Outbox", &default_outbox_folder_uri, &outbox_folder },
	{ "Sent", &default_sent_folder_uri, &sent_folder },
};

static void
setup_local_store(MailComponent *component)
{
	MailComponentPrivate *p = component->priv;
	CamelException ex;
	char *store_uri;
	int i;

	g_assert(p->local_store == NULL);

	/* EPFIXME It should use base_directory once we have moved it.  */
	store_uri = g_strconcat("mbox:", g_get_home_dir(), "/.evolution/mail/local", NULL);
	p->local_store = mail_component_load_storage_by_uri(component, store_uri, _("On this Computer"));
	camel_object_ref(p->local_store);
	
	camel_exception_init (&ex);
	for (i=0;i<sizeof(default_folders)/sizeof(default_folders[0]);i++) {
		/* FIXME: should this uri be account relative? */
		*default_folders[i].uri = g_strdup_printf("%s#%s", store_uri, default_folders[i].base);
		*default_folders[i].folder = camel_store_get_folder(p->local_store, default_folders[i].base,
								    CAMEL_STORE_FOLDER_CREATE, &ex);
		camel_exception_clear(&ex);
	}

	g_free(store_uri);
}

/* EStorageBrowser callbacks.  */

static BonoboControl *
create_noselect_control (void)
{
	GtkWidget *label;

	label = gtk_label_new (_("This folder cannot contain messages."));
	gtk_widget_show (label);
	return bonobo_control_new (label);
}

static GtkWidget *
create_view_callback (EStorageBrowser *browser,
		      const char *path,
		      void *unused_data)
{
	BonoboControl *control;
	EFolder *folder;
	const char *folder_type;
	const char *physical_uri;

	folder = e_storage_set_get_folder (e_storage_browser_peek_storage_set (browser), path);
	if (folder == NULL) {
		g_warning ("No folder at %s", path);
		return gtk_label_new ("(You should not be seeing this label)");
	}

	folder_type  = e_folder_get_type_string (folder);
	physical_uri = e_folder_get_physical_uri (folder);

	if (type_is_mail (folder_type)) {
		const char *noselect;
		CamelURL *url;
		
		url = camel_url_new (physical_uri, NULL);
		noselect = url ? camel_url_get_param (url, "noselect") : NULL;
		if (noselect && !strcasecmp (noselect, "yes"))
			control = create_noselect_control ();
		else
			control = folder_browser_factory_new_control (physical_uri);
		camel_url_free (url);
	} else if (type_is_vtrash (folder_type)) {
		if (!strncasecmp (physical_uri, "file:", 5))
			control = folder_browser_factory_new_control ("vtrash:file:/");
		else
			control = folder_browser_factory_new_control (physical_uri);
	} else
		return NULL;
	
	if (!control)
		return NULL;

	/* EPFIXME: This leaks the control.  */
	return bonobo_widget_new_control_from_objref (BONOBO_OBJREF (control), CORBA_OBJECT_NIL);
}

static void
browser_page_switched_callback (EStorageBrowser *browser,
				GtkWidget *old_page,
				GtkWidget *new_page,
				BonoboControl *parent_control)
{
	if (BONOBO_IS_WIDGET (old_page)) {
		BonoboControlFrame *control_frame = bonobo_widget_get_control_frame (BONOBO_WIDGET (old_page));

		bonobo_control_frame_control_deactivate (control_frame);
	}

	if (BONOBO_IS_WIDGET (new_page)) {
		BonoboControlFrame *control_frame = bonobo_widget_get_control_frame (BONOBO_WIDGET (new_page));
		Bonobo_UIContainer ui_container = bonobo_control_get_remote_ui_container (parent_control, NULL);

		/* This is necessary because we are not embedding the folder browser control
		   directly; we are putting the folder browser control into a notebook which
		   is then exported to the shell as a control.  So we need to forward the
		   notebook's UIContainer to the folder browser.  */
		bonobo_control_frame_set_ui_container (control_frame, ui_container, NULL);

		bonobo_control_frame_control_activate (control_frame);
	}
}

/* GObject methods.  */

static void
impl_dispose (GObject *object)
{
	MailComponentPrivate *priv = MAIL_COMPONENT (object)->priv;

	if (priv->storage_set != NULL) {
		g_object_unref (priv->storage_set);
		priv->storage_set = NULL;
	}

	if (priv->folder_type_registry != NULL) {
		g_object_unref (priv->folder_type_registry);
		priv->folder_type_registry = NULL;
	}

	if (priv->search_context != NULL) {
		g_object_unref (priv->search_context);
		priv->search_context = NULL;
	}

	if (priv->local_store != NULL) {
		camel_object_unref (CAMEL_OBJECT (priv->local_store));
		priv->local_store = NULL;
	}

	(* G_OBJECT_CLASS (parent_class)->dispose) (object);
}

static void
impl_finalize (GObject *object)
{
	MailComponentPrivate *priv = MAIL_COMPONENT (object)->priv;

	g_free (priv->base_directory);

	mail_async_event_destroy (priv->async_event);

	g_hash_table_destroy (priv->storages_hash); /* EPFIXME free the data within? */

	if (mail_async_event_destroy (priv->async_event) == -1) {
		g_warning("Cannot destroy async event: would deadlock");
		g_warning(" system may be unstable at exit");
	}

	g_free(priv->context_path);
	g_free (priv);

	(* G_OBJECT_CLASS (parent_class)->finalize) (object);
}


/* Evolution::Component CORBA methods.  */

static void
impl_createControls (PortableServer_Servant servant,
		     Bonobo_Control *corba_sidebar_control,
		     Bonobo_Control *corba_view_control,
		     CORBA_Environment *ev)
{
	MailComponent *mail_component = MAIL_COMPONENT (bonobo_object_from_servant (servant));
	MailComponentPrivate *priv = mail_component->priv;
	EStorageBrowser *browser;
	GtkWidget *tree_widget;
	GtkWidget *view_widget;
	BonoboControl *sidebar_control;
	BonoboControl *view_control;

	browser = e_storage_browser_new (priv->storage_set, "/", create_view_callback, NULL);

	tree_widget = e_storage_browser_peek_tree_widget (browser);
	view_widget = e_storage_browser_peek_view_widget (browser);
	
	gtk_widget_show (tree_widget);
	gtk_widget_show (view_widget);

	sidebar_control = bonobo_control_new (tree_widget);
	view_control = bonobo_control_new (view_widget);

	*corba_sidebar_control = CORBA_Object_duplicate (BONOBO_OBJREF (sidebar_control), ev);
	*corba_view_control = CORBA_Object_duplicate (BONOBO_OBJREF (view_control), ev);

	g_signal_connect_object (browser, "page_switched",
				 G_CALLBACK (browser_page_switched_callback), view_control, 0);

	g_signal_connect(tree_widget, "right_click", G_CALLBACK(emc_tree_right_click), mail_component);
}


/* Initialization.  */

static void
mail_component_class_init (MailComponentClass *class)
{
	POA_GNOME_Evolution_Component__epv *epv = &class->epv;
	GObjectClass *object_class = G_OBJECT_CLASS (class);

	parent_class = g_type_class_peek_parent (class);

	object_class->dispose  = impl_dispose;
	object_class->finalize = impl_finalize;

	epv->createControls = impl_createControls;
}

static void
mail_component_init (MailComponent *component)
{
	MailComponentPrivate *priv;
	EAccountList *accounts;

	priv = g_new0 (MailComponentPrivate, 1);
	component->priv = priv;

	/* EPFIXME: Move to a private directory.  */
	/* EPFIXME: Create the directory.  */
	priv->base_directory = g_build_filename (g_get_home_dir (), "evolution", NULL);

	/* EPFIXME: Turn into an object?  */
	mail_session_init (priv->base_directory);

	priv->async_event = mail_async_event_new();
	priv->storages_hash = g_hash_table_new (NULL, NULL);

	priv->folder_type_registry = e_folder_type_registry_new ();
	priv->storage_set = e_storage_set_new (priv->folder_type_registry);

#if 0				/* EPFIXME TODO somehow */
	for (i = 0; i < sizeof (standard_folders) / sizeof (standard_folders[0]); i++)
		*standard_folders[i].uri = g_strdup_printf ("file://%s/local/%s", evolution_dir, standard_folders[i].name);
#endif
	setup_local_store (component);

	accounts = mail_config_get_accounts ();
	load_accounts(component, accounts);

#if 0
	/* EPFIXME?  */
	mail_local_storage_startup (shell_client, evolution_dir);
	mail_importer_init (shell_client);

	for (i = 0; i < sizeof (standard_folders) / sizeof (standard_folders[0]); i++) {
		mail_msg_wait (mail_get_folder (*standard_folders[i].uri, CAMEL_STORE_FOLDER_CREATE,
						got_folder, standard_folders[i].folder, mail_thread_new));
	}
#endif
	
	/* mail_autoreceive_setup (); EPFIXME keep it off for testing */

	setup_search_context (component);

#if 0
	/* EPFIXME this shouldn't be here.  */
	if (mail_config_is_corrupt ()) {
		GtkWidget *dialog;
		
		dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
						 _("Some of your mail settings seem corrupt, "
						   "please check that everything is in order."));
		g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog);
		gtk_widget_show (dialog);
	}
#endif

#if 0
	/* EPFIXME if we nuke the summary this is not necessary anymore.  */

	/* Everything should be ready now */
	evolution_folder_info_notify_ready ();
#endif

	/* EPFIXME not sure about this.  */
	go_online (component);
}


/* Public API.  */

MailComponent *
mail_component_peek (void)
{
	static MailComponent *component = NULL;

	if (component == NULL) {
		component = g_object_new (mail_component_get_type (), NULL);

		/* FIXME: this should all be initialised in a starutp routine, not from the peek function,
		   this covers much of the ::init method's content too */
		vfolder_load_storage();
	}

	return component;
}


const char *
mail_component_peek_base_directory (MailComponent *component)
{
	return component->priv->base_directory;
}

RuleContext *
mail_component_peek_search_context (MailComponent *component)
{
	return component->priv->search_context;
}


void
mail_component_add_store (MailComponent *component,
			  CamelStore *store,
			  const char *name)
{
	CamelException ex;

	camel_exception_init (&ex);
	
	if (name == NULL) {
		char *service_name;
		
		service_name = camel_service_get_name ((CamelService *) store, TRUE);
		add_storage (component, service_name, (CamelService *) store, &ex);
		g_free (service_name);
	} else {
		add_storage (component, name, (CamelService *) store, &ex);
	}
	
	camel_exception_clear (&ex);
}


/**
 * mail_component_load_storage_by_uri:
 * @component: 
 * @uri: 
 * @name: 
 * 
 * 
 * 
 * Return value: Pointer to the newly added CamelStore.  The caller is supposed
 * to ref the object if it wants to store it.
 **/
CamelStore *
mail_component_load_storage_by_uri (MailComponent *component,
				    const char *uri,
				    const char *name)
{
	CamelException ex;
	CamelService *store;
	CamelProvider *prov;
	
	camel_exception_init (&ex);
	
	/* Load the service (don't connect!). Check its provider and
	 * see if this belongs in the shell's folder list. If so, add
	 * it.
	 */
	
	prov = camel_session_get_provider (session, uri, &ex);
	if (prov == NULL) {
		/* EPFIXME: real error dialog */
		g_warning ("couldn't get service %s: %s\n", uri,
			   camel_exception_get_description (&ex));
		camel_exception_clear (&ex);
		return NULL;
	}
	
	if (!(prov->flags & CAMEL_PROVIDER_IS_STORAGE) ||
	    (prov->flags & CAMEL_PROVIDER_IS_EXTERNAL))
		return NULL;
	
	store = camel_session_get_service (session, uri, CAMEL_PROVIDER_STORE, &ex);
	if (store == NULL) {
		/* EPFIXME: real error dialog */
		g_warning ("couldn't get service %s: %s\n", uri,
			   camel_exception_get_description (&ex));
		camel_exception_clear (&ex);
		return NULL;
	}
	
	if (name != NULL) {
		add_storage (component, name, store, &ex);
	} else {
		char *service_name;
		
		service_name = camel_service_get_name (store, TRUE);
		add_storage (component, service_name, store, &ex);
		g_free (service_name);
	}
	
	if (camel_exception_is_set (&ex)) {
		/* EPFIXME: real error dialog */
		g_warning ("Cannot load storage: %s",
			   camel_exception_get_description (&ex));
		camel_exception_clear (&ex);
	}
	
	camel_object_unref (CAMEL_OBJECT (store));
	return CAMEL_STORE (store);		/* (Still has one ref in the hash.)  */
}


static void
store_disconnect (CamelStore *store,
		  void *event_data,
		  void *data)
{
	camel_service_disconnect (CAMEL_SERVICE (store), TRUE, NULL);
	camel_object_unref (CAMEL_OBJECT (store));
}

void
mail_component_remove_storage (MailComponent *component,
			       CamelStore *store)
{
	MailComponentPrivate *priv = component->priv;
	EStorage *storage;
	
	/* Because the storages_hash holds a reference to each store
	 * used as a key in it, none of them will ever be gc'ed, meaning
	 * any call to camel_session_get_{service,store} with the same
	 * URL will always return the same object. So this works.
	 */
	
	storage = g_hash_table_lookup (priv->storages_hash, store);
	if (!storage)
		return;
	
	g_hash_table_remove (priv->storages_hash, store);
	
	/* so i guess potentially we could have a race, add a store while one
	   being removed.  ?? */
	mail_note_store_remove (store);

	e_storage_set_remove_storage (priv->storage_set, storage);
	
	mail_async_event_emit(priv->async_event, MAIL_ASYNC_THREAD, (MailAsyncFunc) store_disconnect, store, NULL, NULL);
}


void
mail_component_remove_storage_by_uri (MailComponent *component,
				      const char *uri)
{
	CamelProvider *prov;
	CamelService *store;

	prov = camel_session_get_provider (session, uri, NULL);
	if (!prov)
		return;
	if (!(prov->flags & CAMEL_PROVIDER_IS_STORAGE) ||
	    (prov->flags & CAMEL_PROVIDER_IS_EXTERNAL))
		return;

	store = camel_session_get_service (session, uri, CAMEL_PROVIDER_STORE, NULL);
	if (store != NULL) {
		mail_component_remove_storage (component, CAMEL_STORE (store));
		camel_object_unref (CAMEL_OBJECT (store));
	}
}


EStorage *
mail_component_lookup_storage (MailComponent *component,
			       CamelStore *store)
{
	EStorage *storage;
	
	/* Because the storages_hash holds a reference to each store
	 * used as a key in it, none of them will ever be gc'ed, meaning
	 * any call to camel_session_get_{service,store} with the same
	 * URL will always return the same object. So this works.
	 */
	
	storage = g_hash_table_lookup (component->priv->storages_hash, store);
	if (storage)
		g_object_ref (storage);
	
	return storage;
}


int
mail_component_get_storage_count (MailComponent *component)
{
	return g_hash_table_size (component->priv->storages_hash);
}


EStorageSet *
mail_component_peek_storage_set (MailComponent *component)
{
	return component->priv->storage_set;
}


void
mail_component_storages_foreach (MailComponent *component,
				 GHFunc func,
				 void *data)
{
	g_hash_table_foreach (component->priv->storages_hash, func, data);
}

extern struct _CamelSession *session;

char *em_uri_from_camel(const char *curi)
{
	CamelURL *curl;
	EAccount *account;
	const char *uid, *path;
	char *euri;
	CamelProvider *provider;

	provider = camel_session_get_provider(session, curi, NULL);
	if (provider == NULL)
		return g_strdup(curi);

	curl = camel_url_new(curi, NULL);
	if (curl == NULL)
		return g_strdup(curi);

	account = mail_config_get_account_by_source_url(curi);
	uid = (account == NULL)?"local@local":account->uid;
	path = (provider->url_flags & CAMEL_URL_FRAGMENT_IS_PATH)?curl->fragment:curl->path;
	if (path[0] == '/')
		path++;
	euri = g_strdup_printf("email://%s/%s", uid, path);
	printf("em uri from camel '%s' -> '%s'\n", curi, euri);

	return euri;
}

char *em_uri_to_camel(const char *euri)
{
	EAccountList *accounts;
	const EAccount *account;
	EAccountService *service;
	CamelProvider *provider;
	CamelURL *eurl, *curl;
	char *uid, *curi;

	eurl = camel_url_new(euri, NULL);
	if (eurl == NULL)
		return g_strdup(euri);

	if (strcmp(eurl->protocol, "email") != 0) {
		camel_url_free(eurl);
		return g_strdup(euri);
	}

	g_assert(eurl->user != NULL);
	g_assert(eurl->host != NULL);

	if (strcmp(eurl->user, "local") == 0 && strcmp(eurl->host, "local") == 0) {
		/* FIXME: needs to track real local store location */
		curi = g_strdup_printf("mbox:%s/.evolution/mail/local#%s", g_get_home_dir(), eurl->path);
		camel_url_free(eurl);
		return curi;
	}

	uid = g_strdup_printf("%s@%s", eurl->user, eurl->host);

	accounts = mail_config_get_accounts();
	account = e_account_list_find(accounts, E_ACCOUNT_FIND_UID, uid);
	g_free(uid);

	if (account == NULL) {
		camel_url_free(eurl);
		return g_strdup(euri);
	}

	service = account->source;
	provider = camel_session_get_provider(session, service->url, NULL);

	curl = camel_url_new(service->url, NULL);
	if (provider->url_flags & CAMEL_URL_FRAGMENT_IS_PATH)
		camel_url_set_fragment(curl, eurl->path);
	else
		camel_url_set_path(curl, eurl->path);

	curi = camel_url_to_string(curl, 0);

	camel_url_free(eurl);
	camel_url_free(curl);

	printf("em uri to camel '%s' -> '%s'\n", euri, curi);

	return curi;
}


CamelFolder *
mail_component_get_folder_from_evomail_uri (MailComponent *component,
					    guint32 flags,
					    const char *evomail_uri,
					    CamelException *ex)
{
	CamelException local_ex;
	EAccountList *accounts;
	EIterator *iter;
	const char *p;
	const char *q;
	const char *folder_name;
	char *uid;

	camel_exception_init (&local_ex);

	if (strncmp (evomail_uri, "evomail:", 8) != 0)
		return NULL;

	p = evomail_uri + 8;
	while (*p == '/')
		p ++;

	q = strchr (p, '/');
	if (q == NULL)
		return NULL;

	uid = g_strndup (p, q - p);
	folder_name = q + 1;

	/* since we have no explicit account for 'local' folders, make one up */
	if (strcmp(uid, "local") == 0) {
		g_free(uid);
		return camel_store_get_folder(component->priv->local_store, folder_name, flags, ex);
	}

	accounts = mail_config_get_accounts ();
	iter = e_list_get_iterator ((EList *) accounts);
	while (e_iterator_is_valid (iter)) {
		EAccount *account = (EAccount *) e_iterator_get (iter);
		EAccountService *service = account->source;
		CamelProvider *provider;
		CamelStore *store;

		if (strcmp (account->uid, uid) != 0)
			continue;

		provider = camel_session_get_provider (session, service->url, &local_ex);
		if (provider == NULL)
			goto fail;

		store = (CamelStore *) camel_session_get_service (session, service->url, CAMEL_PROVIDER_STORE, &local_ex);
		if (store == NULL)
			goto fail;

		g_free (uid);
		return camel_store_get_folder (store, folder_name, flags, ex);
	}

 fail:
	camel_exception_clear (&local_ex);
	g_free (uid);
	return NULL;
}


char *
mail_component_evomail_uri_from_folder (MailComponent *component,
					CamelFolder *folder)
{
	CamelStore *store = camel_folder_get_parent_store (folder);
	EAccount *account;
	char *service_url;
	char *evomail_uri;
	const char *uid;

	if (store == NULL)
		return NULL;

	service_url = camel_service_get_url (CAMEL_SERVICE (store));
	account = mail_config_get_account_by_source_url (service_url);

	if (account == NULL) {
		/* since we have no explicit account for 'local' folders, make one up */
		/* TODO: check the folder is really a local one, folder->parent_store == local_store? */
		uid = "local";
		/*g_free (service_url);
		return NULL;*/
	} else {
		uid = account->uid;
	}

	evomail_uri = g_strconcat ("evomail:///", uid, "/", camel_folder_get_full_name (folder), NULL);
	g_free (service_url);

	return evomail_uri;
}


BONOBO_TYPE_FUNC_FULL (MailComponent, GNOME_Evolution_Component, PARENT_TYPE, mail_component)


/* ********************************************************************** */
#if 0
static void
emc_popup_view(GtkWidget *w, MailComponent *mc)
{

}

static void
emc_popup_open_new(GtkWidget *w, MailComponent *mc)
{
}
#endif

static void
em_copy_folders(CamelStore *tostore, const char *tobase, CamelStore *fromstore, const char *frombase, int delete)
{
	GString *toname, *fromname;
	CamelFolderInfo *fi;
	GList *pending = NULL;
	guint32 flags = CAMEL_STORE_FOLDER_INFO_RECURSIVE;
	CamelException *ex = camel_exception_new();
	int fromlen;
	const char *tmp;

	if (camel_store_supports_subscriptions(fromstore))
		flags |= CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;

	fi = camel_store_get_folder_info(fromstore, frombase, flags, ex);
	if (camel_exception_is_set(ex))
		goto done;

	pending = g_list_append(pending, fi);

	toname = g_string_new("");
	fromname = g_string_new("");

	tmp = strrchr(frombase, '/');
	if (tmp == NULL)
		fromlen = 0;
	else
		fromlen = tmp-frombase;

	printf("top name is '%s'\n", fi->full_name);

	while (pending) {
		CamelFolderInfo *info = pending->data;

		pending = g_list_remove_link(pending, pending);
		while (info) {
			CamelFolder *fromfolder, *tofolder;
			GPtrArray *uids;

			if (info->child)
				pending = g_list_append(pending, info->child);
			g_string_printf(toname, "%s/%s", tobase, info->full_name + fromlen);

			printf("Copying from '%s' to '%s'\n", info->full_name, toname->str);

			/* This makes sure we create the same tree, e.g. from a nonselectable source */
			/* Not sure if this is really the 'right thing', e.g. for spool stores, but it makes the ui work */
			fromfolder = camel_store_get_folder(fromstore, info->full_name, 0, ex);
			tofolder = camel_store_get_folder(tostore, toname->str, CAMEL_STORE_FOLDER_CREATE, ex);
			if (tofolder == NULL) {
				if (fromfolder)
					camel_object_unref(fromfolder);
				goto exception;
			}

			if (fromfolder) {
				uids = camel_folder_get_uids(fromfolder);
				camel_folder_transfer_messages_to(fromfolder, uids, tofolder, NULL, FALSE, ex);
				camel_folder_free_uids(fromfolder, uids);

				camel_object_unref(fromfolder);
			}
			camel_object_unref(tofolder);
			if (camel_exception_is_set(ex))
				goto exception;
			info = info->sibling;
		}
	}

	camel_store_free_folder_info(fromstore, fi);

exception:
	g_string_free(toname, TRUE);
	g_string_free(fromname, TRUE);
done:
	printf("exception: %s\n", ex->desc?ex->desc:"<none>");
	camel_exception_free(ex);
}

struct _copy_folder_data {
	MailComponent *mc;
	int delete;
};

static void
emc_popup_copy_folder_selected(const char *uri, void *data)
{
	struct _copy_folder_data *d = data;

	if (uri == NULL) {
		g_free(d);
		return;
	}

	if (uri) {
		EFolder *folder = e_storage_set_get_folder(d->mc->priv->storage_set, d->mc->priv->context_path);
		CamelException *ex = camel_exception_new();
		CamelStore *fromstore, *tostore;
		char *tobase, *frombase;
		CamelURL *url;

		printf("copying folder '%s' to '%s'\n", d->mc->priv->context_path, uri);

		fromstore = camel_session_get_store(session, e_folder_get_physical_uri(folder), ex);
		frombase = strchr(d->mc->priv->context_path+1, '/')+1;

		tostore = camel_session_get_store(session, uri, ex);
		url = camel_url_new(uri, NULL);
		if (url->fragment)
			tobase = url->fragment;
		else
			tobase = url->path;

		em_copy_folders(tostore, tobase, fromstore, frombase, d->delete);

		camel_url_free(url);
		camel_exception_free(ex);
	}
	g_free(d);
}

static void
emc_popup_copy(GtkWidget *w, MailComponent *mc)
{
	struct _copy_folder_data *d;

	d = g_malloc(sizeof(*d));
	d->mc = mc;
	d->delete = 0;
	em_select_folder(NULL, _("Select folder"), _("Select destination to copy folder into"), NULL, emc_popup_copy_folder_selected, d);
}

static void
emc_popup_move(GtkWidget *w, MailComponent *mc)
{
	struct _copy_folder_data *d;

	d = g_malloc(sizeof(*d));
	d->mc = mc;
	d->delete = 1;
	em_select_folder(NULL, _("Select folder"), _("Select destination to move folder into"), NULL, emc_popup_copy_folder_selected, d);
}
static void
emc_popup_new_folder_create(EStorageSet *ess, EStorageResult result, void *data)
{
	printf("folder created %s\n", result == E_STORAGE_OK?"ok":"failed");
}

static void
emc_popup_new_folder_response(EMFolderSelector *emfs, guint response, MailComponent *mc)
{
	if (response == GTK_RESPONSE_OK) {
		char *path, *tmp, *name, *full;
		EStorage *storage;
		CamelStore *store;
		CamelException *ex;

		printf("Creating folder: %s (%s)\n", em_folder_selector_get_selected(emfs),
		       em_folder_selector_get_selected_uri(emfs));

		path = g_strdup(em_folder_selector_get_selected(emfs));
		tmp = strchr(path+1, '/');
		*tmp++ = 0;
		/* FIXME: camel_store_create_folder should just take full path names */
		full = g_strdup(tmp);
		name = strrchr(tmp, '/');
		if (name == NULL) {
			name = tmp;
			tmp = "";
		} else
			*name++  = 0;

		storage = e_storage_set_get_storage(mc->priv->storage_set, path+1);
		store = g_object_get_data((GObject *)storage, "em-store");

		printf("creating folder '%s' / '%s' on '%s'\n", tmp, name, path+1);

		ex = camel_exception_new();
		camel_store_create_folder(store, tmp, name, ex);
		if (camel_exception_is_set(ex)) {
			printf("Create failed: %s\n", ex->desc);
		} else if (camel_store_supports_subscriptions(store)) {
			camel_store_subscribe_folder(store, full, ex);
			if (camel_exception_is_set(ex)) {
				printf("Subscribe failed: %s\n", ex->desc);
			}
		}

		camel_exception_free(ex);

		g_free(full);
		g_free(path);

		/* Blah, this should just use camel, we get better error reporting if we do too */
		/*e_storage_set_async_create_folder(mc->priv->storage_set, path, "mail", "", emc_popup_new_folder_create, mc);*/
	}
	gtk_widget_destroy((GtkWidget *)emfs);
}

static void
emc_popup_new_folder (GtkWidget *w, MailComponent *mc)
{
	GtkWidget *dialog;

	dialog = em_folder_selector_create_new(mc->priv->storage_set, 0, _("Create folder"), _("Specify where to create the folder:"));
	em_folder_selector_set_selected((EMFolderSelector *)dialog, mc->priv->context_path);
	g_signal_connect(dialog, "response", G_CALLBACK(emc_popup_new_folder_response), mc);
	gtk_widget_show(dialog);
}

static void
em_delete_rec(CamelStore *store, CamelFolderInfo *fi, CamelException *ex)
{
	while (fi) {
		CamelFolder *folder;

		if (fi->child)
			em_delete_rec(store, fi->child, ex);
		if (camel_exception_is_set(ex))
			return;

		printf("deleting folder '%s'\n", fi->full_name);

		if (camel_store_supports_subscriptions(store))
			camel_store_unsubscribe_folder(store, fi->full_name, NULL);

		folder = camel_store_get_folder(store, fi->full_name, 0, NULL);
		if (folder) {
			GPtrArray *uids = camel_folder_get_uids(folder);
			int i;

			camel_folder_freeze(folder);
			for (i = 0; i < uids->len; i++)
				camel_folder_delete_message(folder, uids->pdata[i]);
			camel_folder_sync(folder, TRUE, NULL);
			camel_folder_thaw(folder);
			camel_folder_free_uids(folder, uids);
		}

		camel_store_delete_folder(store, fi->full_name, ex);
		if (camel_exception_is_set(ex))
			return;
		fi = fi->sibling;
	}
}

static void
em_delete_folders(CamelStore *store, const char *base, CamelException *ex)
{
	CamelFolderInfo *fi;
	guint32 flags = CAMEL_STORE_FOLDER_INFO_RECURSIVE;
 
	if (camel_store_supports_subscriptions(store))
		flags |= CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;

	fi = camel_store_get_folder_info(store, base, flags, ex);
	if (camel_exception_is_set(ex))
		return;

	em_delete_rec(store, fi, ex);
	camel_store_free_folder_info(store, fi);
}

static void
emc_popup_delete_response(GtkWidget *w, guint response, MailComponent *mc)
{
	gtk_widget_destroy(w);

	if (response == GTK_RESPONSE_OK) {
		const char *path = strchr(mc->priv->context_path+1, '/')+1;
		EFolder *folder = e_storage_set_get_folder(mc->priv->storage_set, mc->priv->context_path);
		CamelException *ex = camel_exception_new();
		CamelStore *store;

		/* FIXME: need to hook onto store changed event and delete view as well, somewhere else tho */
		store = camel_session_get_store(session, e_folder_get_physical_uri(folder), ex);
		if (camel_exception_is_set(ex))
			goto exception;

		em_delete_folders(store, path, ex);
		if (!camel_exception_is_set(ex))
			goto noexception;
	exception:
		e_notice(NULL, GTK_MESSAGE_ERROR,
			 _("Could not delete folder: %s"), ex->desc);
	noexception:
		camel_exception_free(ex);
		if (store)
			camel_object_unref(store);
	}
}

static void
emc_popup_delete_folder(GtkWidget *w, MailComponent *mc)
{
	GtkWidget *dialog;
	char *title;
	const char *path = strchr(mc->priv->context_path+1, '/')+1;
	EFolder *folder;

	folder = e_storage_set_get_folder(mc->priv->storage_set, mc->priv->context_path);
	if (folder == NULL)
		return;

	dialog = gtk_message_dialog_new(NULL,
					GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
					GTK_MESSAGE_QUESTION,
					GTK_BUTTONS_NONE,
					_("Really delete folder \"%s\" and all of its subfolders?"), path);

	gtk_dialog_add_button((GtkDialog *)dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
	gtk_dialog_add_button((GtkDialog *)dialog, GTK_STOCK_DELETE, GTK_RESPONSE_OK);

	gtk_dialog_set_default_response((GtkDialog *)dialog, GTK_RESPONSE_OK);
	gtk_container_set_border_width((GtkContainer *)dialog, 6); 
	gtk_box_set_spacing((GtkBox *)((GtkDialog *)dialog)->vbox, 6);

	title = g_strdup_printf(_("Delete \"%s\""), path);
	gtk_window_set_title((GtkWindow *)dialog, title);
	g_free(title);

	g_signal_connect(dialog, "response", G_CALLBACK(emc_popup_delete_response), mc);
	gtk_widget_show(dialog);
}

static void
emc_popup_rename_folder(GtkWidget *w, MailComponent *mc)
{
	char *prompt, *new;
	EFolder *folder;
	const char *old, *why;
	int done = 0;

	folder = e_storage_set_get_folder(mc->priv->storage_set, mc->priv->context_path);
	if (folder == NULL)
		return;

	old = e_folder_get_name(folder);
	prompt = g_strdup_printf (_("Rename the \"%s\" folder to:"), e_folder_get_name(folder));
	while (!done) {
		new = e_request_string(NULL, _("Rename Folder"), prompt, old);
		if (new == NULL || strcmp(old, new) == 0)
			done = 1;
#if 0
		else if (!e_shell_folder_name_is_valid(new, &why))
			e_notice(NULL, GTK_MESSAGE_ERROR, _("The specified folder name is not valid: %s"), why);
#endif
		else {
			char *base, *path;

			/* FIXME: we can't use the os independent path crap here, since we want to control the format */
			base = g_path_get_dirname(mc->priv->context_path);
			path = g_build_filename(base, new, NULL);

			if (e_storage_set_get_folder(mc->priv->storage_set, path) != NULL) {
				e_notice(NULL, GTK_MESSAGE_ERROR,
					 _("A folder named \"%s\" already exists.  Please use a different name."), new);
			} else {
				CamelStore *store;
				CamelException *ex = camel_exception_new();
				const char *oldpath, *newpath;

				oldpath = strchr(mc->priv->context_path+1, '/');
				g_assert(oldpath);
				newpath = strchr(path+1, '/');
				g_assert(newpath);
				oldpath++;
				newpath++;

				printf("renaming %s to %s\n", oldpath, newpath);

				store = camel_session_get_store(session, e_folder_get_physical_uri(folder), ex);
				if (camel_exception_is_set(ex))
					goto exception;

				camel_store_rename_folder(store, oldpath, newpath, ex);
				if (!camel_exception_is_set(ex))
					goto noexception;

			exception:
				e_notice(NULL, GTK_MESSAGE_ERROR,
					 _("Could not rename folder: %s"), ex->desc);
			noexception:
				if (store)
					camel_object_unref(store);
				camel_exception_free(ex);

				done = 1;
			}
			g_free(path);
			g_free(base);
		}
		g_free(new);
	}
}

struct _prop_data {
	void *object;
	CamelArgV *argv;
	GtkWidget **widgets;
};

static void
emc_popup_properties_response(GtkWidget *dialog, int response, struct _prop_data *prop_data)
{
	int i;
	CamelArgV *argv = prop_data->argv;

	if (response != GTK_RESPONSE_OK) {
		gtk_widget_destroy(dialog);
		return;
	}

	for (i=0;i<argv->argc;i++) {
		CamelArg *arg = &argv->argv[i];

		switch (arg->tag & CAMEL_ARG_TYPE) {
		case CAMEL_ARG_BOO:
			arg->ca_int = gtk_toggle_button_get_active(prop_data->widgets[i]);
			break;
		case CAMEL_ARG_STR:
			g_free(arg->ca_str);
			arg->ca_str = gtk_entry_get_text(prop_data->widgets[i]);
			break;
		default:
			printf("unknown property type set\n");
		}
	}

	camel_object_setv(prop_data->object, NULL, argv);
	gtk_widget_destroy(dialog);
}

static void
emc_popup_properties_free(void *data)
{
	struct _prop_data *prop_data = data;
	int i;

	for (i=0; i<prop_data->argv->argc; i++) {
		if ((prop_data->argv->argv[i].tag & CAMEL_ARG_TYPE) == CAMEL_ARG_STR)
			g_free(prop_data->argv->argv[i].ca_str);
	}
	camel_object_unref(prop_data->object);
	g_free(prop_data->argv);
	g_free(prop_data);
}

static void
emc_popup_properties_got_folder(const char *uri, CamelFolder *folder, void *data)
{
	MailComponent *mc = data;

	if (folder) {
		GtkWidget *dialog, *w, *table, *label;
		GSList *list, *l;
		char *name, *txt;
		int row = 1;
		gint32 count, i;
		struct _prop_data *prop_data;
		CamelArgV *argv;
		CamelArgGetV *arggetv;

		camel_object_get(folder, NULL, CAMEL_FOLDER_PROPERTIES, &list, CAMEL_FOLDER_NAME, &name, NULL);

		dialog = gtk_dialog_new_with_buttons(_("Folder properties"),
						     NULL,
						     GTK_DIALOG_DESTROY_WITH_PARENT,
						     GTK_STOCK_OK,
						     GTK_RESPONSE_OK,
						     NULL);

		/* TODO: maybe we want some basic properties here, like message counts/approximate size/etc */
		w = gtk_frame_new(_("Properties"));
		gtk_box_pack_start(((GtkDialog *)dialog)->vbox, w, TRUE, TRUE, 6);
		table = gtk_table_new(g_slist_length(list)+1, 2, FALSE);
		gtk_container_add((GtkContainer *)w, table);
		label = gtk_label_new(_("Folder Name"));
		gtk_misc_set_alignment(label, 1.0, 0.5);
		gtk_table_attach(table, label, 0, 1, 0, 1, GTK_FILL|GTK_EXPAND, 0, 3, 0);
		label = gtk_label_new(name);
		gtk_misc_set_alignment(label, 0.0, 0.5);
		gtk_table_attach(table, label, 1, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 3, 0);

		/* build an arggetv/argv to retrieve/store the results */
		count = g_slist_length(list);
		arggetv = g_malloc0(sizeof(*arggetv) + (count - CAMEL_ARGV_MAX) * sizeof(arggetv->argv[0]));
		arggetv->argc = count;
		argv = g_malloc0(sizeof(*argv) + (count - CAMEL_ARGV_MAX) * sizeof(argv->argv[0]));
		argv->argc = count;
		i = 0;
		l = list;
		while (l) {
			CamelProperty *prop = l->data;

			argv->argv[i].tag = prop->tag;
			arggetv->argv[i].tag = prop->tag;
			arggetv->argv[i].ca_ptr = &argv->argv[i].ca_ptr;

			l = l->next;
			i++;
		}
		camel_object_getv(folder, NULL, arggetv);
		g_free(arggetv);

		prop_data = g_malloc0(sizeof(*prop_data));
		prop_data->widgets = g_malloc0(sizeof(prop_data->widgets[0]) * count);
		prop_data->argv = argv;

		/* setup the ui with the values retrieved */
		l = list;
		i = 0;
		while (l) {
			CamelProperty *prop = l->data;

			switch (prop->tag & CAMEL_ARG_TYPE) {
			case CAMEL_ARG_BOO:
				w = gtk_check_button_new_with_label(prop->description);
				gtk_toggle_button_set_active((GtkToggleButton *)w, argv->argv[i].ca_int != 0);
				gtk_table_attach(table, w, 0, 2, row, row+1, 0, 0, 3, 3);
				prop_data->widgets[i] = w;
				break;
			case CAMEL_ARG_STR:
				label = gtk_label_new(prop->description);
				gtk_misc_set_alignment(label, 1.0, 0.5);
				gtk_table_attach(table, label, 0, 1, row, row+1, GTK_FILL|GTK_EXPAND, 0, 3, 3);

				w = gtk_entry_new();
				if (argv->argv[i].ca_str) {
					gtk_entry_set_text((GtkEntry *)w, txt);
					camel_object_free(folder, argv->argv[i].tag, argv->argv[i].ca_str);
					argv->argv[i].ca_str = NULL;
				}
				gtk_table_attach(table, w, 1, 2, row, row+1, GTK_FILL, 0, 3, 3);
				prop_data->widgets[i] = w;
				break;
			default:
				w = gtk_label_new("CamelFolder error: unsupported propery type");
				gtk_table_attach(table, w, 0, 2, row, row+1, 0, 0, 3, 3);
				break;
			}

			row++;
			l = l->next;
		}

		prop_data->object = folder;
		camel_object_ref(folder);

		camel_object_free(folder, CAMEL_FOLDER_PROPERTIES, list);
		camel_object_free(folder, CAMEL_FOLDER_NAME, name);

		/* we do 'apply on ok' ... since instant apply may apply some very long running tasks */

		g_signal_connect(dialog, "response", G_CALLBACK(emc_popup_properties_response), prop_data);
		g_object_set_data_full((GObject *)dialog, "e-prop-data", prop_data, emc_popup_properties_free);
		gtk_widget_show_all(dialog);
	}
}

static void
emc_popup_properties(GtkWidget *w, MailComponent *mc)
{
	EFolder *efolder;

	/* TODO: Make sure we only have one dialog open for any given folder */

	efolder = e_storage_set_get_folder(mc->priv->storage_set, mc->priv->context_path);
	if (efolder == NULL)
		return;

	mail_get_folder(e_folder_get_physical_uri(efolder), 0, emc_popup_properties_got_folder, mc, mail_thread_new);
}

static EMPopupItem emc_popup_menu[] = {
#if 0
	{ EM_POPUP_ITEM, "00.emc.00", N_("_View"), G_CALLBACK(emc_popup_view), NULL, NULL, 0 },
	{ EM_POPUP_ITEM, "00.emc.01", N_("Open in _New Window"), G_CALLBACK(emc_popup_open_new), NULL, NULL, 0 },

	{ EM_POPUP_BAR, "10.emc" },
#endif
	{ EM_POPUP_ITEM, "10.emc.00", N_("_Copy"), G_CALLBACK(emc_popup_copy), NULL, "folder-copy-16.png", 0 },
	{ EM_POPUP_ITEM, "10.emc.01", N_("_Move"), G_CALLBACK(emc_popup_move), NULL, "folder-move-16.png", 0 },

	{ EM_POPUP_BAR, "20.emc" },
	{ EM_POPUP_ITEM, "20.emc.00", N_("_New Folder..."), G_CALLBACK(emc_popup_new_folder), NULL, "folder-mini.png", 0 },
	{ EM_POPUP_ITEM, "20.emc.01", N_("_Delete"), G_CALLBACK(emc_popup_delete_folder), NULL, "evolution-trash-mini.png", 0 },
	{ EM_POPUP_ITEM, "20.emc.01", N_("_Rename"), G_CALLBACK(emc_popup_rename_folder), NULL, NULL, 0 },

	{ EM_POPUP_BAR, "80.emc" },
	{ EM_POPUP_ITEM, "80.emc.00", N_("_Properties..."), G_CALLBACK(emc_popup_properties), NULL, "configure_16_folder.xpm", 0 },
};


static int
emc_tree_right_click(ETree *tree, gint row, ETreePath path, gint col, GdkEvent *event, MailComponent *component)
{
	char *name;
	ETreeModel *model = e_tree_get_model(tree);
	EMPopup *emp;
	int i;
	GSList *menus = NULL;
	struct _GtkMenu *menu;

	name = e_tree_memory_node_get_data((ETreeMemory *)model, path);
	g_free(component->priv->context_path);
	component->priv->context_path = g_strdup(name);
	printf("right click, path = '%s'\n", name);

	emp = em_popup_new("com.ximian.mail.storageset.popup.select");

	for (i=0;i<sizeof(emc_popup_menu)/sizeof(emc_popup_menu[0]);i++) {
		EMPopupItem *item = &emc_popup_menu[i];

		item->activate_data = component;
		menus = g_slist_prepend(menus, item);
	}

	em_popup_add_items(emp, menus, (GDestroyNotify)g_slist_free);

	menu = em_popup_create_menu_once(emp, NULL, 0, 0);

	if (event == NULL || event->type == GDK_KEY_PRESS) {
		/* FIXME: menu pos function */
		gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 0, event->key.time);
	} else {
		gtk_menu_popup(menu, NULL, NULL, NULL, NULL, event->button.button, event->button.time);
	}

	return TRUE;
}