Merge with camel-async.

svn path=/trunk/; revision=4687

1 files changed, 1576 insertions, 828 deletions

diff --git a/mail/mail-ops.c b/mail/mail-ops.c
index 77045cb79d..d235c6b2d9 100644
--- a/mail/mail-ops.c
+++ b/mail/mail-ops.c
@@ -2,9 +2,9 @@
 /* mail-ops.c: callbacks for the mail toolbar/menus */
 
 /* 
- * Authors: Dan Winship <danw@helixcode.com>
- *          Jeffrey Stedfast <fejj@helixcode.com>
- *          Peter Williams <peterw@helixcode.com>
+ * Author : 
+ *  Dan Winship <danw@helixcode.com>
+ *  Peter Williams <peterw@helixcode.com>
  *
  * Copyright 2000 Helix Code, Inc. (http://www.helixcode.com)
  *
@@ -25,1115 +25,1863 @@
  */
 
 #include <config.h>
-#include <ctype.h>
-#include <errno.h>
 #include <gnome.h>
-#include <libgnomeprint/gnome-print-master.h>
-#include <libgnomeprint/gnome-print-master-preview.h>
 #include "mail.h"
 #include "mail-threads.h"
-#include "folder-browser.h"
+#include "mail-tools.h"
+#include "mail-ops.h"
 #include "e-util/e-setup.h"
-#include "filter/filter-editor.h"
-#include "filter/filter-driver.h"
-#include "widgets/e-table/e-table.h"
-#include "mail-local.h"
+#include "composer/e-msg-composer.h"
 
-/* FIXME: is there another way to do this? */
-#include "Evolution.h"
-#include "evolution-storage.h"
+/* ** FETCH MAIL ********************************************************** */
 
-#include "evolution-shell-client.h"
-
-#ifndef HAVE_MKSTEMP
-#include <fcntl.h>
-#include <sys/stat.h>
-#endif
+typedef struct fetch_mail_input_s
+{
+	gchar *source_url;
+	gboolean keep_on_server;
+	CamelFolder *destination;
+	gpointer hook_func;
+	gpointer hook_data;
+}
+fetch_mail_input_t;
+
+static gchar *describe_fetch_mail (gpointer in_data, gboolean gerund);
+static void setup_fetch_mail (gpointer in_data, gpointer op_data,
+			      CamelException * ex);
+static void do_fetch_mail (gpointer in_data, gpointer op_data,
+			   CamelException * ex);
+static void cleanup_fetch_mail (gpointer in_data, gpointer op_data,
+				CamelException * ex);
+
+static gchar *
+describe_fetch_mail (gpointer in_data, gboolean gerund)
+{
+	fetch_mail_input_t *input = (fetch_mail_input_t *) in_data;
 
-struct post_send_data {
-	CamelFolder *folder;
-	const char *uid;
-	guint32 flags;
-};
+	if (gerund)
+		return g_strdup_printf ("Fetching email from %s",
+					input->source_url);
+	else
+		return g_strdup_printf ("Fetch email from %s",
+					input->source_url);
+}
 
-typedef struct rfm_s { 
-	FolderBrowser *fb; 
-	MailConfigService *source;
-} rfm_t;
+static void
+setup_fetch_mail (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	fetch_mail_input_t *input = (fetch_mail_input_t *) in_data;
 
-typedef struct rsm_s {
-	EMsgComposer *composer;
-	CamelTransport *transport;
-	CamelMimeMessage *message;
-	const char *subject;
-	char *from;
-	struct post_send_data *psd;
-	gboolean ok;
-} rsm_t;
+	if (!input->source_url) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "You have no remote mail source configured "
+				     "to fetch mail from.");
+		return;
+	}
 
-static void
-real_fetch_mail( gpointer user_data );
+	if (input->destination == NULL)
+		return;
 
-static void
-real_send_mail( gpointer user_data );
+	if (!CAMEL_IS_FOLDER (input->destination)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "Bad folder passed to fetch_mail");
+		return;
+	}
 
-static void
-cleanup_send_mail( gpointer userdata );
+	camel_object_ref (CAMEL_OBJECT (input->destination));
+}
 
 static void
-mail_exception_dialog (char *head, CamelException *ex, gpointer widget)
+do_fetch_mail (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	char *msg;
-	GtkWindow *window =
-		GTK_WINDOW (gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW));
+	fetch_mail_input_t *input;
+	CamelFolder *search_folder = NULL;
+
+	input = (fetch_mail_input_t *) in_data;
+
+	if (input->destination == NULL) {
+		input->destination = mail_tool_get_local_inbox (ex);
+
+		if (input->destination == NULL)
+			return;
+	}
 
-	msg = g_strdup_printf ("%s:\n%s", head,
-			       camel_exception_get_description (ex));
-	gnome_error_dialog_parented (msg, window);
-	g_free (msg);
+	search_folder =
+		mail_tool_fetch_mail_into_searchable (input->source_url, 
+						      input->keep_on_server, ex);
+
+	if (search_folder == NULL) {
+		/* This happens with an IMAP source and on error */
+		camel_object_unref (CAMEL_OBJECT (input->destination));
+		input->destination = NULL;
+		return;
+	}
+
+	mail_tool_filter_contents_into (search_folder, input->destination,
+					input->hook_func, input->hook_data,
+					ex);
+	camel_object_unref (CAMEL_OBJECT (search_folder));
 }
 
-#ifdef USE_BROKEN_THREADS
 static void
-async_mail_exception_dialog (char *head, CamelException *ex, gpointer unused )
+cleanup_fetch_mail (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	mail_op_error( "%s: %s", head, camel_exception_get_description( ex ) );
+	fetch_mail_input_t *input = (fetch_mail_input_t *) in_data;
+
+	g_free (input->source_url);
+	if (input->destination)
+		camel_object_unref (CAMEL_OBJECT (input->destination));
 }
-#else
-#define async_mail_exception_dialog mail_exception_dialog
-#endif
 
-static gboolean
-check_configured (void)
+static const mail_operation_spec op_fetch_mail = {
+	describe_fetch_mail,
+	0,
+	setup_fetch_mail,
+	do_fetch_mail,
+	cleanup_fetch_mail
+};
+
+void
+mail_do_fetch_mail (const gchar * source_url, gboolean keep_on_server,
+		    CamelFolder * destination,
+		    gpointer hook_func, gpointer hook_data)
 {
-	if (mail_config_is_configured ())
-		return TRUE;
-	
-	mail_config_druid ();
+	fetch_mail_input_t *input;
 
-	return mail_config_is_configured ();
+	input = g_new (fetch_mail_input_t, 1);
+	input->source_url = g_strdup (source_url);
+	input->keep_on_server = keep_on_server;
+	input->destination = destination;
+	input->hook_func = hook_func;
+	input->hook_data = hook_data;
+
+	mail_operation_queue (&op_fetch_mail, input, TRUE);
 }
 
-static void
-select_first_unread (CamelFolder *folder, int type, gpointer data)
+/* ** SEND MAIL *********************************************************** */
+
+typedef struct send_mail_input_s
 {
-	FolderBrowser *fb = data;
-	ETable *table = E_TABLE_SCROLLED (fb->message_list->etable)->table;
-	int mrow;
+	gchar *xport_uri;
+	CamelMimeMessage *message;
+	gchar *from;
+
+	/* If done_folder != NULL, will add done_flags to
+	 * the flags of the message done_uid in done_folder. */
 
-	mrow = e_table_view_to_model_row (table, 0);
-	message_list_select (fb->message_list, mrow, MESSAGE_LIST_SELECT_NEXT,
-			     0, CAMEL_MESSAGE_SEEN);
+	CamelFolder *done_folder;
+	char *done_uid;
+	guint32 done_flags;
+
+	GtkWidget *composer;
 }
+send_mail_input_t;
+
+static gchar *describe_send_mail (gpointer in_data, gboolean gerund);
+static void setup_send_mail (gpointer in_data, gpointer op_data,
+			     CamelException * ex);
+static void do_send_mail (gpointer in_data, gpointer op_data,
+
+			  CamelException * ex);
+static void cleanup_send_mail (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
 
-static CamelFolder *
-filter_get_folder(FilterDriver *fd, const char *uri, void *data)
+static gchar *
+describe_send_mail (gpointer in_data, gboolean gerund)
 {
-	return mail_uri_to_folder(uri);
+	send_mail_input_t *input = (send_mail_input_t *) in_data;
+
+	if (gerund) {
+		if (input->message->subject && input->message->subject[0])
+			return g_strdup_printf ("Sending \"%s\"",
+						input->message->subject);
+		else
+			return
+				g_strdup
+				("Sending a message without a subject");
+	} else {
+		if (input->message->subject && input->message->subject[0])
+			return g_strdup_printf ("Send \"%s\"",
+						input->message->subject);
+		else
+			return g_strdup ("Send a message without a subject");
+	}
 }
 
 static void
-fetch_remote_mail (CamelFolder *source, CamelFolder *dest,
-		   gboolean keep_on_server, FolderBrowser *fb,
-		   CamelException *ex)
+setup_send_mail (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	CamelUIDCache *cache;
-	GPtrArray *uids;
-	int i;
+	send_mail_input_t *input = (send_mail_input_t *) in_data;
 
-	uids = camel_folder_get_uids (source);
-	if (keep_on_server) {
-		GPtrArray *new_uids;
-		char *url, *p, *filename;
-
-		url = camel_url_to_string (
-			CAMEL_SERVICE (source->parent_store)->url, FALSE);
-		for (p = url; *p; p++) {
-			if (!isascii ((unsigned char)*p) ||
-			    strchr (" /'\"`&();|<>${}!", *p))
-				*p = '_';
-		}
-		filename = g_strdup_printf ("%s/config/cache-%s",
-					    evolution_dir, url);
-		g_free (url);
-
-		cache = camel_uid_cache_new (filename);
-		g_free (filename);
-		if (cache) {
-			new_uids = camel_uid_cache_get_new_uids (cache, uids);
-			camel_folder_free_uids (source, uids);
-			uids = new_uids;
-		} else {
-			async_mail_exception_dialog ("Could not read UID "
-						     "cache file. You may "
-						     "receive duplicate "
-						     "messages.", NULL, fb);
-		}
-	} else
-		cache = NULL;
+	if (!input->xport_uri) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No transport URI specified for send_mail operation.");
+		return;
+	}
 
-	printf ("got %d new messages in source\n", uids->len);
-	for (i = 0; i < uids->len; i++) {
-		CamelMimeMessage *msg;
+	if (!CAMEL_IS_MIME_MESSAGE (input->message)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No message specified for send_mail operation.");
+		return;
+	}
 
-		msg = camel_folder_get_message (source, uids->pdata[i], ex);
-		if (camel_exception_is_set (ex)) {
-			async_mail_exception_dialog ("Unable to get message",
-						     ex, fb);
-			goto done;
-		}
+	if (input->from == NULL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No from address specified for send_mail operation.");
+		return;
+	}
 
-		/* Append with flags = 0 since this is a new message */
-		camel_folder_append_message (dest, msg, 0, ex);
-		if (camel_exception_is_set (ex)) {
-			async_mail_exception_dialog ("Unable to write message",
-						     ex, fb);
-			gtk_object_unref (GTK_OBJECT (msg));
-			goto done;
-		}
+	/* NOTE THE EARLY EXIT!! */
 
-		if (!cache)
-			camel_folder_delete_message (source, uids->pdata[i]);
-		gtk_object_unref (GTK_OBJECT (msg));
+	if (input->done_folder == NULL) {
+		camel_object_ref (CAMEL_OBJECT (input->message));
+		gtk_object_ref (GTK_OBJECT (input->composer));
+		gtk_widget_hide (GTK_WIDGET (input->composer));
+		return;
 	}
 
-	camel_folder_sync (source, TRUE, ex);
+	if (!CAMEL_IS_FOLDER (input->done_folder)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "Bad done_folder specified for send_mail operation.");
+		return;
+	}
+
+	if (input->done_uid == NULL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No done_uid specified for send_mail operation.");
+		return;
+	}
+
+	if (!GTK_IS_WIDGET (input->composer)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No composer specified for send_mail operation.");
+		return;
+	}
 
- done:
-	if (cache) {
-		camel_uid_cache_free_uids (uids);
-		if (!camel_exception_is_set (ex))
-			camel_uid_cache_save (cache);
-		camel_uid_cache_destroy (cache);
-	} else
-		camel_folder_free_uids (source, uids);
+	camel_object_ref (CAMEL_OBJECT (input->message));
+	camel_object_ref (CAMEL_OBJECT (input->done_folder));
+	gtk_object_ref (GTK_OBJECT (input->composer));
+	gtk_widget_hide (GTK_WIDGET (input->composer));
 }
 
-void
-real_fetch_mail (gpointer user_data)
-{
-	rfm_t *info;
-	FolderBrowser *fb = NULL;
-	CamelException *ex;
-	CamelStore *store = NULL, *dest_store = NULL;
-	CamelFolder *folder = NULL, *dest_folder = NULL;
-	char *url = NULL, *dest_url;
-	FilterContext *fc = NULL;
-	FilterDriver *driver = NULL;
-	char *userrules, *systemrules;
-	char *tmp_mbox = NULL, *source;
-	guint handler_id = 0;
-	struct stat st;
-	gboolean keep;
-
-	info = (rfm_t *) user_data;
-	fb = info->fb;
-	url = info->source->url;
-	keep = info->source->keep_on_server;
-	
-	/* If using IMAP, don't do anything... */
-	if (!strncmp (url, "imap:", 5))
+static void
+do_send_mail (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	send_mail_input_t *input = (send_mail_input_t *) in_data;
+	CamelTransport *xport;
+
+	mail_tool_camel_lock_up ();
+	camel_mime_message_set_from (input->message, input->from);
+
+	camel_medium_add_header (CAMEL_MEDIUM (input->message), "X-Mailer",
+				 "Evolution (Developer Preview)");
+	camel_mime_message_set_date (input->message,
+				     CAMEL_MESSAGE_DATE_CURRENT, 0);
+
+	xport = camel_session_get_transport (session, input->xport_uri, ex);
+	mail_tool_camel_lock_down ();
+	if (camel_exception_is_set (ex))
 		return;
 
-	ex = camel_exception_new ();
+	mail_tool_send_via_transport (xport, CAMEL_MEDIUM (input->message),
+				      ex);
 
-	dest_url = g_strdup_printf ("mbox://%s/local/Inbox", evolution_dir);
-	dest_store = camel_session_get_store (session, dest_url, ex);
-	g_free (dest_url);
-	if (!dest_store) {
-		async_mail_exception_dialog ("Unable to get new mail", ex, fb);
-		goto cleanup;
-	}
-	
-	dest_folder = camel_store_get_folder (dest_store, "mbox", FALSE, ex);
-	if (!dest_folder) {
-		async_mail_exception_dialog ("Unable to get new mail", ex, fb);
-		goto cleanup;
+	if (camel_exception_is_set (ex))
+		return;
+
+	if (input->done_folder) {
+		guint32 set;
+
+		mail_tool_camel_lock_up ();
+		set = camel_folder_get_message_flags (input->done_folder,
+						      input->done_uid);
+		camel_folder_set_message_flags (input->done_folder,
+						input->done_uid,
+						input->done_flags, ~set);
+		mail_tool_camel_lock_down ();
 	}
+}
 
-	tmp_mbox = g_strdup_printf ("%s/local/Inbox/movemail", evolution_dir);
+static void
+cleanup_send_mail (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	send_mail_input_t *input = (send_mail_input_t *) in_data;
 
-	/* If fetching mail from an mbox store, safely copy it to a
-	 * temporary store first.
-	 */
-	if (!strncmp (url, "mbox:", 5)) {
-		int tmpfd;
+	camel_object_unref (CAMEL_OBJECT (input->message));
+	if (input->done_folder)
+		camel_object_unref (CAMEL_OBJECT (input->done_folder));
 
-		tmpfd = open (tmp_mbox, O_RDWR | O_CREAT | O_APPEND, 0660);
+	g_free (input->from);
+	g_free (input->xport_uri);
+	g_free (input->done_uid);
 
-		if (tmpfd == -1) {
-			camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
-					      "Couldn't create temporary "
-					      "mbox: %s", g_strerror (errno));
-			async_mail_exception_dialog ("Unable to move mail", ex, fb );
-			goto cleanup;
-		}
-		close (tmpfd);
-
-		/* Skip over "mbox:" plus host part (if any) of url. */
-		source = url + 5;
-		if (!strncmp (source, "//", 2))
-			source = strchr (source + 2, '/');
-
-		camel_movemail (source, tmp_mbox, ex);
-		if (camel_exception_is_set (ex)) {
-			async_mail_exception_dialog ("Unable to move mail",
-						     ex, fb);
-			goto cleanup;
-		}
+	if (!camel_exception_is_set (ex))
+		gtk_widget_destroy (input->composer);
+	else
+		gtk_widget_show (input->composer);
+}
 
-		if (stat (tmp_mbox, &st) == -1 || st.st_size == 0) {
-			gnome_ok_dialog ("No new messages.");
-			goto cleanup;
-		}
+static const mail_operation_spec op_send_mail = {
+	describe_send_mail,
+	0,
+	setup_send_mail,
+	do_send_mail,
+	cleanup_send_mail
+};
 
-		folder = camel_store_get_folder (dest_store, "movemail",
-						 FALSE, ex);
-		if (camel_exception_get_id (ex) != CAMEL_EXCEPTION_NONE) {
-			async_mail_exception_dialog ("Unable to move mail", ex, fb);
-			goto cleanup;
-		}
-	} else {
-		CamelFolder *sourcefolder;
-
-		store = camel_session_get_store(session, url, ex);
- 		if (!store) {
- 			async_mail_exception_dialog("Unable to get new mail", ex, fb);
- 			goto cleanup;
- 		}
-
-		camel_service_connect(CAMEL_SERVICE (store), ex);
-		if (camel_exception_get_id(ex) != CAMEL_EXCEPTION_NONE) {
-			if (camel_exception_get_id(ex) != CAMEL_EXCEPTION_USER_CANCEL)
-				async_mail_exception_dialog("Unable to get new mail", ex, fb);
-			goto cleanup;
-		}
+void
+mail_do_send_mail (const char *xport_uri,
+		   CamelMimeMessage * message,
+		   const char * from,
+		   CamelFolder * done_folder,
+		   const char *done_uid,
+		   guint32 done_flags, GtkWidget * composer)
+{
+	send_mail_input_t *input;
+
+	input = g_new (send_mail_input_t, 1);
+	input->xport_uri = g_strdup (xport_uri);
+	input->message = message;
+	input->from = g_strdup (from);
+	input->done_folder = done_folder;
+	input->done_uid = g_strdup (done_uid);
+	input->done_flags = done_flags;
+	input->composer = composer;
+
+	mail_operation_queue (&op_send_mail, input, TRUE);
+}
 
-		sourcefolder = camel_store_get_folder(store, "inbox", FALSE, ex);
-		if (camel_exception_get_id(ex) != CAMEL_EXCEPTION_NONE) {
-			async_mail_exception_dialog("Unable to get new mail", ex, fb);
-			goto cleanup;
-		}
+/* ** EXPUNGE FOLDER ****************************************************** */
 
-		/* can we perform filtering on this source? */
-		if (!(sourcefolder->has_summary_capability
-		      && sourcefolder->has_search_capability)) {
-			folder = camel_store_get_folder (dest_store,
-							 "movemail", TRUE, ex);
-			if (camel_exception_is_set (ex)) {
-				async_mail_exception_dialog ("Unable to move mail", ex, fb);
-				goto cleanup;
-			}
-
-			fetch_remote_mail (sourcefolder, folder, keep, fb, ex);
-			gtk_object_unref (GTK_OBJECT (sourcefolder));
-			if (camel_exception_is_set (ex))
-				goto cleanup;
-		} else {
-			folder = sourcefolder;
-		}
-	}
+static gchar *describe_expunge_folder (gpointer in_data, gboolean gerund);
+static void setup_expunge_folder (gpointer in_data, gpointer op_data,
+				  CamelException * ex);
+static void do_expunge_folder (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
+static void cleanup_expunge_folder (gpointer in_data, gpointer op_data,
+				    CamelException * ex);
+
+static gchar *
+describe_expunge_folder (gpointer in_data, gboolean gerund)
+{
+	CamelFolder *f = CAMEL_FOLDER (in_data);
 
-	if (camel_folder_get_message_count (folder) == 0) {
-		gnome_ok_dialog ("No new messages.");
-		goto cleanup;
-	} else if (camel_exception_is_set (ex)) {
-		async_mail_exception_dialog ("Unable to get new mail", ex, fb);
-		goto cleanup;
+	if (gerund)
+		return g_strdup_printf ("Expunging \"%s\"", f->full_name);
+	else
+		return g_strdup_printf ("Expunge \"%s\"", f->full_name);
+}
+
+static void
+setup_expunge_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	if (!CAMEL_IS_FOLDER (in_data)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder is selected to be expunged");
+		return;
 	}
 
-	folder_browser_clear_search (fb);
+	camel_object_ref (CAMEL_OBJECT (in_data));
+}
 
-	/* apply filtering rules to this inbox */
-	fc = filter_context_new();
-	userrules = g_strdup_printf("%s/filters.xml", evolution_dir);
-	systemrules = g_strdup_printf("%s/evolution/filtertypes.xml", EVOLUTION_DATADIR);
-	rule_context_load((RuleContext *)fc, systemrules, userrules);
-	g_free (userrules);
-	g_free (systemrules);
+static void
+do_expunge_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	mail_tool_camel_lock_up ();
+	camel_folder_expunge (CAMEL_FOLDER (in_data), ex);
+	mail_tool_camel_lock_down ();
+}
 
-	driver = filter_driver_new(fc, filter_get_folder, 0);
+static void
+cleanup_expunge_folder (gpointer in_data, gpointer op_data,
+			CamelException * ex)
+{
+	camel_object_unref (CAMEL_OBJECT (in_data));
+}
 
-	/* Attach a handler to the destination folder to select the first unread
-	 * message iff it changes and iff it's the folder being viewed.
-	 */
-	if (dest_folder == fb->folder)
-		handler_id = gtk_signal_connect (GTK_OBJECT (dest_folder), "folder_changed",
-						 GTK_SIGNAL_FUNC (select_first_unread), fb);
+static const mail_operation_spec op_expunge_folder = {
+	describe_expunge_folder,
+	0,
+	setup_expunge_folder,
+	do_expunge_folder,
+	cleanup_expunge_folder
+};
 
-	if (filter_driver_run(driver, folder, dest_folder) == -1) {
-		async_mail_exception_dialog ("Unable to get new mail", ex, fb);
-		goto cleanup;
-	}
+void
+mail_do_expunge_folder (CamelFolder * folder)
+{
+	mail_operation_queue (&op_expunge_folder, folder, FALSE);
+}
+
+/* ** REFILE MESSAGES ***************************************************** */
 
-	if (dest_folder == fb->folder)
-		gtk_signal_disconnect (GTK_OBJECT (dest_folder), handler_id);
+typedef struct refile_messages_input_s
+{
+	CamelFolder *source;
+	GPtrArray *uids;
+	gchar *dest_uri;
+}
+refile_messages_input_t;
+
+static gchar *describe_refile_messages (gpointer in_data, gboolean gerund);
+static void setup_refile_messages (gpointer in_data, gpointer op_data,
+				   CamelException * ex);
+static void do_refile_messages (gpointer in_data, gpointer op_data,
+				CamelException * ex);
+static void cleanup_refile_messages (gpointer in_data, gpointer op_data,
+				     CamelException * ex);
+
+static gchar *
+describe_refile_messages (gpointer in_data, gboolean gerund)
+{
+	refile_messages_input_t *input = (refile_messages_input_t *) in_data;
 
- cleanup:
-	if (stat (tmp_mbox, &st) == 0 && st.st_size == 0)
-		unlink (tmp_mbox); /* FIXME: should use camel to do this */
-	g_free (tmp_mbox);
+	if (gerund)
+		return
+			g_strdup_printf
+			("Moving messages from \"%s\" into \"%s\"",
+			 input->source->full_name, input->dest_uri);
+	else
+		return
+			g_strdup_printf
+			("Move messages from \"%s\" into \"%s\"",
+			 input->source->full_name, input->dest_uri);
+}
 
-	if (driver)
-		gtk_object_unref((GtkObject *)driver);
-	if (fc)
-		gtk_object_unref((GtkObject *)fc);
+static void
+setup_refile_messages (gpointer in_data, gpointer op_data,
+		       CamelException * ex)
+{
+	refile_messages_input_t *input = (refile_messages_input_t *) in_data;
 
-	if (folder) {
-		camel_folder_sync (folder, TRUE, ex);
-		gtk_object_unref (GTK_OBJECT (folder));
+	if (!CAMEL_IS_FOLDER (input->source)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No source folder to refile messages from specified.");
+		return;
 	}
 
-	if (dest_folder) {
-		camel_folder_sync (dest_folder, TRUE, ex);
-		gtk_object_unref (GTK_OBJECT (dest_folder));
+	if (input->uids == NULL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No messages to refile have been specified.");
+		return;
 	}
 
-	if (store) {
-		camel_service_disconnect (CAMEL_SERVICE (store), ex);
-		gtk_object_unref (GTK_OBJECT (store));
+	if (input->dest_uri == NULL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No URI to refile to has been specified.");
+		return;
 	}
 
-	if (dest_store && dest_store != fb->folder->parent_store) {
-		camel_service_disconnect (CAMEL_SERVICE (dest_store), ex);
-		gtk_object_unref (GTK_OBJECT (dest_store));
+	camel_object_ref (CAMEL_OBJECT (input->source));
+}
+
+static void
+do_refile_messages (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	refile_messages_input_t *input = (refile_messages_input_t *) in_data;
+	CamelFolder *dest;
+	gint i;
+
+	dest = mail_tool_uri_to_folder (input->dest_uri, ex);
+	if (camel_exception_is_set (ex))
+		return;
+
+	mail_tool_camel_lock_up ();
+	for (i = 0; i < input->uids->len; i++) {
+		camel_folder_move_message_to (input->source,
+					      input->uids->pdata[i], dest,
+					      ex);
+		g_free (input->uids->pdata[i]);
+		if (camel_exception_is_set (ex))
+			break;
 	}
-	camel_exception_free (ex);
+
+	camel_object_unref (CAMEL_OBJECT (dest));
+	mail_tool_camel_lock_down ();
 }
 
+static void
+cleanup_refile_messages (gpointer in_data, gpointer op_data,
+			 CamelException * ex)
+{
+	refile_messages_input_t *input = (refile_messages_input_t *) in_data;
+
+	camel_object_unref (CAMEL_OBJECT (input->source));
+	g_free (input->dest_uri);
+	g_ptr_array_free (input->uids, TRUE);
+}
+
+static const mail_operation_spec op_refile_messages = {
+	describe_refile_messages,
+	0,
+	setup_refile_messages,
+	do_refile_messages,
+	cleanup_refile_messages
+};
+
 void
-fetch_mail (GtkWidget *button, gpointer user_data)
+mail_do_refile_messages (CamelFolder * source, GPtrArray * uids,
+			 gchar * dest_uri)
 {
-	MailConfigService *source;
-	rfm_t *info;
+	refile_messages_input_t *input;
 
-	if (!check_configured ())
-		return;
+	input = g_new (refile_messages_input_t, 1);
+	input->source = source;
+	input->uids = uids;
+	input->dest_uri = g_strdup (dest_uri);
+
+	mail_operation_queue (&op_refile_messages, input, TRUE);
+}
+
+/* ** FLAG MESSAGES ******************************************************* */
 
-	source = mail_config_get_default_source ();
-	if (!source || !source->url) {
-		GtkWidget *win = gtk_widget_get_ancestor (GTK_WIDGET (user_data),
-							  GTK_TYPE_WINDOW);
+typedef struct flag_messages_input_s
+{
+	CamelFolder *source;
+	GPtrArray *uids;
+	gboolean invert;
+	guint32 mask;
+	guint32 set;
+}
+flag_messages_input_t;
+
+static gchar *describe_flag_messages (gpointer in_data, gboolean gerund);
+static void setup_flag_messages (gpointer in_data, gpointer op_data,
+				 CamelException * ex);
+static void do_flag_messages (gpointer in_data, gpointer op_data,
+			      CamelException * ex);
+static void cleanup_flag_messages (gpointer in_data, gpointer op_data,
+				   CamelException * ex);
+
+static gchar *
+describe_flag_messages (gpointer in_data, gboolean gerund)
+{
+	flag_messages_input_t *input = (flag_messages_input_t *) in_data;
+
+	/* FIXME: change based on flags being applied? */
 
-		gnome_error_dialog_parented ("You have no remote mail source "
-					     "configured", GTK_WINDOW (win));
+	if (gerund)
+		return g_strdup_printf ("Marking messages in folder \"%s\"",
+					input->source->full_name);
+	else
+		return g_strdup_printf ("Mark messages in folder \"%s\"",
+					input->source->full_name);
+}
+
+static void
+setup_flag_messages (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	flag_messages_input_t *input = (flag_messages_input_t *) in_data;
+
+	if (!CAMEL_IS_FOLDER (input->source)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No source folder to flag messages from specified.");
 		return;
 	}
 
-	/* This must be dynamically allocated so as not to be clobbered
-	 * when we return. Actually, making it static in the whole file
-	 * would probably work.
-	 */
+	if (input->uids == NULL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No messages to flag have been specified.");
+		return;
+	}
 
-	info = g_new (rfm_t, 1);
-	info->fb = FOLDER_BROWSER (user_data);
-	info->source = source;
+	camel_object_ref (CAMEL_OBJECT (input->source));
+}
 
-#ifdef USE_BROKEN_THREADS
-	mail_operation_try (_("Fetching mail"), real_fetch_mail, NULL, info);
-#else
-	real_fetch_mail (info);
-#endif
+static void
+do_flag_messages (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	flag_messages_input_t *input = (flag_messages_input_t *) in_data;
+	gint i;
+
+	for (i = 0; i < input->uids->len; i++) {
+		if (input->invert) {
+			const CamelMessageInfo *info;
+
+			mail_tool_camel_lock_up ();
+			info = camel_folder_get_message_info (input->source, input->uids->pdata[i]);
+			camel_folder_set_message_flags (input->source, input->uids->pdata[i],
+							input->mask, ~info->flags);
+			mail_tool_camel_lock_down ();
+		} else {
+			mail_tool_set_uid_flags (input->source, input->uids->pdata[i],
+						 input->mask, input->set);
+		}
+
+		g_free (input->uids->pdata[i]);
+	}
 }
 
-static gboolean
-ask_confirm_for_empty_subject (EMsgComposer *composer)
+static void
+cleanup_flag_messages (gpointer in_data, gpointer op_data,
+		       CamelException * ex)
 {
-	GtkWidget *message_box;
-	int button;
+	flag_messages_input_t *input = (flag_messages_input_t *) in_data;
 
-	message_box = gnome_message_box_new (_("This message has no subject.\nReally send?"),
-					     GNOME_MESSAGE_BOX_QUESTION,
-					     GNOME_STOCK_BUTTON_YES, GNOME_STOCK_BUTTON_NO,
-					     NULL);
+	camel_object_unref (CAMEL_OBJECT (input->source));
+	g_ptr_array_free (input->uids, TRUE);
+}
 
-	button = gnome_dialog_run_and_close (GNOME_DIALOG (message_box));
+static const mail_operation_spec op_flag_messages = {
+	describe_flag_messages,
+	0,
+	setup_flag_messages,
+	do_flag_messages,
+	cleanup_flag_messages
+};
+
+void
+mail_do_flag_messages (CamelFolder * source, GPtrArray * uids,
+		       gboolean invert,
+		       guint32 mask, guint32 set)
+{
+	flag_messages_input_t *input;
 
-	if (button == 0)
-		return TRUE;
+	input = g_new (flag_messages_input_t, 1);
+	input->source = source;
+	input->uids = uids;
+	input->invert = invert;
+	input->mask = mask;
+	input->set = set;
+
+	mail_operation_queue (&op_flag_messages, input, TRUE);
+}
+
+/* ** SCAN SUBFOLDERS ***************************************************** */
+
+typedef struct scan_subfolders_input_s
+{
+	gchar *source_uri;
+	gboolean add_INBOX;
+	EvolutionStorage *storage;
+}
+scan_subfolders_input_t;
+
+typedef struct scan_subfolders_folderinfo_s
+{
+	char *path;
+	char *uri;
+}
+scan_subfolders_folderinfo_t;
+
+typedef struct scan_subfolders_op_s
+{
+	GPtrArray *new_folders;
+}
+scan_subfolders_op_t;
+
+static gchar *describe_scan_subfolders (gpointer in_data, gboolean gerund);
+static void setup_scan_subfolders (gpointer in_data, gpointer op_data,
+				   CamelException * ex);
+static void do_scan_subfolders (gpointer in_data, gpointer op_data,
+				CamelException * ex);
+static void cleanup_scan_subfolders (gpointer in_data, gpointer op_data,
+				     CamelException * ex);
+
+static gchar *
+describe_scan_subfolders (gpointer in_data, gboolean gerund)
+{
+	scan_subfolders_input_t *input = (scan_subfolders_input_t *) in_data;
+
+	if (gerund)
+		return g_strdup_printf ("Scanning folders in \"%s\"",
+					input->source_uri);
 	else
-		return FALSE;
+		return g_strdup_printf ("Scan folders in \"%s\"",
+					input->source_uri);
 }
 
 static void
-set_x_mailer_header (CamelMedium *medium)
+setup_scan_subfolders (gpointer in_data, gpointer op_data,
+		       CamelException * ex)
 {
-	char *mailer_string;
+	scan_subfolders_input_t *input = (scan_subfolders_input_t *) in_data;
+	scan_subfolders_op_t *data = (scan_subfolders_op_t *) op_data;
 
-	mailer_string = g_strdup_printf ("Evolution %s (Developer Preview)", VERSION);
+	if (!input->source_uri) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No source uri to scan subfolders from was provided.");
+		return;
+	}
 
-	camel_medium_add_header (medium, "X-Mailer", mailer_string);
+	if (!EVOLUTION_IS_STORAGE (input->storage)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No storage to scan subfolders into was provided.");
+		return;
+	}
 
-	g_free (mailer_string);
+	gtk_object_ref (GTK_OBJECT (input->storage));
+	data->new_folders = g_ptr_array_new ();
 }
 
 static void
-real_send_mail (gpointer user_data)
+do_scan_subfolders (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	rsm_t *info = (rsm_t *) user_data;
-	EMsgComposer *composer = NULL;
-	CamelTransport *transport = NULL;
-	CamelException *ex = NULL;
-	CamelMimeMessage *message = NULL;
-	const char *subject = NULL;
-	char *from = NULL;
-	struct post_send_data *psd = NULL;
+	scan_subfolders_input_t *input = (scan_subfolders_input_t *) in_data;
+	scan_subfolders_op_t *data = (scan_subfolders_op_t *) op_data;
 
-#ifdef USE_BROKEN_THREADS
-	mail_op_hide_progressbar ();
-	mail_op_set_message ("Connecting to transport...");
-#endif
+	scan_subfolders_folderinfo_t *info;
+	GPtrArray *lsub;
+	CamelFolder *folder;
+	int i;
+	char *splice;
 
-	ex = camel_exception_new ();
-	composer = info->composer;
-	transport = info->transport;
-	message = info->message;
-	subject = info->subject;
-	from = info->from;
-	psd = info->psd;
+	if (input->source_uri[strlen (input->source_uri) - 1] == '/')
+		splice = "";
+	else
+		splice = "/";
 
-	set_x_mailer_header (CAMEL_MEDIUM (message));
+	folder = mail_tool_get_root_of_store (input->source_uri, ex);
+	if (camel_exception_is_set (ex))
+		return;
 
-	camel_mime_message_set_from (message, from);
-	camel_mime_message_set_date (message, CAMEL_MESSAGE_DATE_CURRENT, 0);
+	mail_tool_camel_lock_up ();
 
-	camel_service_connect (CAMEL_SERVICE (transport), ex);
+	/* we need a way to set the namespace */
+	lsub = camel_folder_get_subfolder_names (folder);
 
-#ifdef USE_BROKEN_THREADS
-	mail_op_set_message ("Connected. Sending...");
-#endif
+	mail_tool_camel_lock_down ();
 
-	if (!camel_exception_is_set (ex))
-		camel_transport_send (transport, CAMEL_MEDIUM (message), ex);
+	if (input->add_INBOX) {
+		info = g_new (scan_subfolders_folderinfo_t, 1);
+		info->path = g_strdup ("/INBOX");
+		info->uri =
+			g_strdup_printf ("%s%sINBOX", input->source_uri,
+					 splice);
+		g_ptr_array_add (data->new_folders, info);
+	}
 
-	if (!camel_exception_is_set (ex)) {
-#ifdef USE_BROKEN_THREADS
-		mail_op_set_message ("Sent. Disconnecting...");
-#endif 		
-		camel_service_disconnect (CAMEL_SERVICE (transport), ex);
+	for (i = 0; i < lsub->len; i++) {
+		info = g_new (scan_subfolders_folderinfo_t, 1);
+		info->path = g_strdup_printf ("/%s", (char *) lsub->pdata[i]);
+		info->uri =
+			g_strdup_printf ("%s%s%s", input->source_uri, splice,
+					 info->path);
+		g_ptr_array_add (data->new_folders, info);
 	}
 
-	if (camel_exception_is_set (ex)) {
-		async_mail_exception_dialog ("Could not send message", ex, composer);
-		info->ok = FALSE;
-	} else {
-		if (psd) {
-			camel_folder_set_message_flags (psd->folder, psd->uid,
-							psd->flags, psd->flags);
-		}
-		info->ok = TRUE;
+	camel_folder_free_subfolder_names (folder, lsub);
+	camel_object_unref (CAMEL_OBJECT (folder));
+}
+
+static void
+cleanup_scan_subfolders (gpointer in_data, gpointer op_data,
+			 CamelException * ex)
+{
+	scan_subfolders_input_t *input = (scan_subfolders_input_t *) in_data;
+	scan_subfolders_op_t *data = (scan_subfolders_op_t *) op_data;
+
+	int i;
 
+	for (i = 0; i < data->new_folders->len; i++) {
+		scan_subfolders_folderinfo_t *info;
+
+		info = data->new_folders->pdata[i];
+		evolution_storage_new_folder (input->storage,
+					      info->path,
+					      "mail",
+					      info->uri, "(No description)");
+		g_free (info->path);
+		g_free (info->uri);
+		g_free (info);
 	}
 
-	camel_exception_free (ex);
+	g_ptr_array_free (data->new_folders, TRUE);
+	gtk_object_unref (GTK_OBJECT (input->storage));
+	g_free (input->source_uri);
+}
+
+static const mail_operation_spec op_scan_subfolders = {
+	describe_scan_subfolders,
+	sizeof (scan_subfolders_op_t),
+	setup_scan_subfolders,
+	do_scan_subfolders,
+	cleanup_scan_subfolders
+};
+
+void
+mail_do_scan_subfolders (const gchar * source_uri, gboolean add_INBOX,
+			 EvolutionStorage * storage)
+{
+	scan_subfolders_input_t *input;
+
+	input = g_new (scan_subfolders_input_t, 1);
+	input->source_uri = g_strdup (source_uri);
+	input->add_INBOX = add_INBOX;
+	input->storage = storage;
+
+	mail_operation_queue (&op_scan_subfolders, input, TRUE);
+}
+
+/* ** ATTACH MESSAGE ****************************************************** */
+
+typedef struct attach_message_input_s
+{
+	EMsgComposer *composer;
+	CamelFolder *folder;
+	gchar *uid;
+}
+attach_message_input_t;
+
+typedef struct attach_message_data_s
+{
+	CamelMimePart *part;
+}
+attach_message_data_t;
+
+static gchar *describe_attach_message (gpointer in_data, gboolean gerund);
+static void setup_attach_message (gpointer in_data, gpointer op_data,
+				  CamelException * ex);
+static void do_attach_message (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
+static void cleanup_attach_message (gpointer in_data, gpointer op_data,
+				    CamelException * ex);
+
+static gchar *
+describe_attach_message (gpointer in_data, gboolean gerund)
+{
+	attach_message_input_t *input = (attach_message_input_t *) in_data;
+
+	if (gerund)
+		return
+			g_strdup_printf
+			("Attaching messages from folder \"%s\"",
+			 input->folder->full_name);
+	else
+		return g_strdup_printf ("Attach messages from \"%s\"",
+					input->folder->full_name);
 }
 
 static void
-cleanup_send_mail (gpointer userdata)
+setup_attach_message (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	rsm_t *info = (rsm_t *) userdata;
-	
-	if (info->ok) {
-		gtk_object_destroy (GTK_OBJECT (info->composer));
+	attach_message_input_t *input = (attach_message_input_t *) in_data;
+
+	if (!input->uid) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No UID specified to attach.");
+		return;
 	}
 
-	gtk_object_unref (GTK_OBJECT (info->message));
-	g_free (info);
+	if (!CAMEL_IS_FOLDER (input->folder)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder to fetch the message from specified.");
+		return;
+	}
+
+	if (!E_IS_MSG_COMPOSER (input->composer)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No message composer from specified.");
+		return;
+	}
+
+	camel_object_ref (CAMEL_OBJECT (input->folder));
+	gtk_object_ref (GTK_OBJECT (input->composer));
 }
 
 static void
-composer_send_cb (EMsgComposer *composer, gpointer data)
-{
-	const MailConfigIdentity *id = NULL;
-	static CamelTransport *transport = NULL;
-	struct post_send_data *psd = data;
-	rsm_t *info;
-	static char *from = NULL;
-	const char *subject;
-	CamelException *ex;
+do_attach_message (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	attach_message_input_t *input = (attach_message_input_t *) in_data;
+	attach_message_data_t *data = (attach_message_data_t *) op_data;
+
 	CamelMimeMessage *message;
-	char *name, *addr;
-	
-	ex = camel_exception_new ();
-	
-	id = mail_config_get_default_identity ();
-	
-	if (!check_configured() || !id) {
-		GtkWidget *message;
-		
-		message = gnome_warning_dialog_parented (_("You need to configure an identity\n"
-							   "before you can send mail."),
-							 GTK_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (composer),
-											      GTK_TYPE_WINDOW)));
-		gnome_dialog_run_and_close (GNOME_DIALOG (message));
+	CamelMimePart *part;
+
+	mail_tool_camel_lock_up ();
+	message = camel_folder_get_message (input->folder, input->uid, ex);
+	if (!message) {
+		mail_tool_camel_lock_down ();
+		return;
+	}
+
+	part = mail_tool_make_message_attachment (message);
+	camel_object_unref (CAMEL_OBJECT (message));
+	mail_tool_camel_lock_down ();
+	if (!part)
+		return;
+
+	data->part = part;
+}
+
+static void
+cleanup_attach_message (gpointer in_data, gpointer op_data,
+			CamelException * ex)
+{
+	attach_message_input_t *input = (attach_message_input_t *) in_data;
+	attach_message_data_t *data = (attach_message_data_t *) op_data;
+
+	e_msg_composer_attach (input->composer, data->part);
+	camel_object_unref (CAMEL_OBJECT (data->part));
+	camel_object_unref (CAMEL_OBJECT (input->folder));
+	gtk_object_unref (GTK_OBJECT (input->composer));
+	g_free (input->uid);
+}
+
+static const mail_operation_spec op_attach_message = {
+	describe_attach_message,
+	sizeof (attach_message_data_t),
+	setup_attach_message,
+	do_attach_message,
+	cleanup_attach_message
+};
+
+void
+mail_do_attach_message (CamelFolder * folder, const char *uid,
+			EMsgComposer * composer)
+{
+	attach_message_input_t *input;
+
+	input = g_new (attach_message_input_t, 1);
+	input->folder = folder;
+	input->uid = g_strdup (uid);
+	input->composer = composer;
+
+	mail_operation_queue (&op_attach_message, input, TRUE);
+}
+
+/* ** FORWARD MESSAGES **************************************************** */
+
+typedef struct forward_messages_input_s
+{
+	CamelMimeMessage *basis;
+	CamelFolder *source;
+	GPtrArray *uids;
+	EMsgComposer *composer;
+}
+forward_messages_input_t;
+
+typedef struct forward_messages_data_s
+{
+	gchar *subject;
+	GPtrArray *parts;
+}
+forward_messages_data_t;
+
+static gchar *describe_forward_messages (gpointer in_data, gboolean gerund);
+static void setup_forward_messages (gpointer in_data, gpointer op_data,
+				    CamelException * ex);
+static void do_forward_messages (gpointer in_data, gpointer op_data,
+				 CamelException * ex);
+static void cleanup_forward_messages (gpointer in_data, gpointer op_data,
+				      CamelException * ex);
+
+static gchar *
+describe_forward_messages (gpointer in_data, gboolean gerund)
+{
+	forward_messages_input_t *input =
+
+		(forward_messages_input_t *) in_data;
+
+	if (gerund) {
+		if (input->basis->subject)
+			return g_strdup_printf ("Forwarding messages \"%s\"",
+						input->basis->subject);
+		else
+			return
+				g_strdup_printf
+				("Forwarding a message without a subject");
+	} else {
+		if (input->basis->subject)
+			return g_strdup_printf ("Forward message \"%s\"",
+						input->basis->subject);
+		else
+			return
+				g_strdup_printf
+				("Forward a message without a subject");
+	}
+}
+
+static void
+setup_forward_messages (gpointer in_data, gpointer op_data,
+			CamelException * ex)
+{
+	forward_messages_input_t *input =
+
+		(forward_messages_input_t *) in_data;
+
+	if (!input->uids) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No UIDs specified to attach.");
+		return;
+	}
+
+	if (!CAMEL_IS_MIME_MESSAGE (input->basis)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No basic message to forward was specified.");
+		return;
+	}
+
+	if (!CAMEL_IS_FOLDER (input->source)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder to fetch the messages from specified.");
 		return;
 	}
-	
-	from = g_strdup (e_msg_composer_hdrs_get_from (E_MSG_COMPOSER_HDRS (composer->hdrs)));
-	if (!from) {
-		CamelInternetAddress *ciaddr;
-		
-		g_assert (id);
-		
-		name = id->name;
-		g_assert (name);
-		
-		addr = id->address;
-		g_assert (addr);
-		
-		ciaddr = camel_internet_address_new ();
-		camel_internet_address_add (ciaddr, name, addr);
-
-		from = camel_address_encode (CAMEL_ADDRESS (ciaddr));
+
+	if (!E_IS_MSG_COMPOSER (input->composer)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No message composer from specified.");
+		return;
 	}
-	
-	if (!transport) {
-		MailConfigService *t;
-		char *url;
-		
-		t = mail_config_get_transport ();
-		url = t->url;
-		g_assert (url);
-		
-		transport = camel_session_get_transport (session, url, ex);
-		if (camel_exception_get_id (ex) != CAMEL_EXCEPTION_NONE) {
-			mail_exception_dialog ("Could not load mail transport",
-					       ex, composer);
-			camel_exception_free (ex);
+
+	camel_object_ref (CAMEL_OBJECT (input->basis));
+	camel_object_ref (CAMEL_OBJECT (input->source));
+	gtk_object_ref (GTK_OBJECT (input->composer));
+}
+
+static void
+do_forward_messages (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	forward_messages_input_t *input =
+
+		(forward_messages_input_t *) in_data;
+	forward_messages_data_t *data = (forward_messages_data_t *) op_data;
+
+	CamelMimeMessage *message;
+	CamelMimePart *part;
+	int i;
+
+	data->parts = g_ptr_array_new ();
+
+	mail_tool_camel_lock_up ();
+	for (i = 0; i < input->uids->len; i++) {
+		message =
+			camel_folder_get_message (input->source,
+						  input->uids->pdata[i], ex);
+		g_free (input->uids->pdata[i]);
+		if (!message) {
+			mail_tool_camel_lock_down ();
 			return;
 		}
-	}
-	
-	message = e_msg_composer_get_message (composer);
-	
-	subject = camel_mime_message_get_subject (message);
-	if (!subject || !*subject) {
-		if (!ask_confirm_for_empty_subject (composer)) {
-			gtk_object_unref (GTK_OBJECT (message));
+		part = mail_tool_make_message_attachment (message);
+		if (!part) {
+			camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM,
+					     "Failed to generate mime part from "
+					     "message while generating forwarded message.");
+			mail_tool_camel_lock_down ();
 			return;
 		}
+		camel_object_unref (CAMEL_OBJECT (message));
+		g_ptr_array_add (data->parts, part);
 	}
-	
-	info = g_new0 (rsm_t, 1);
-	info->composer = composer;
-	info->transport = transport;
-	info->message = message;
-	info->subject = subject;
-	info->from = from;
-	info->psd = psd;
-
-#ifdef USE_BROKEN_THREADS
-	mail_operation_try ("Send Message", real_send_mail, cleanup_send_mail, info);
-#else
-	real_send_mail (info);
-	cleanup_send_mail (info);
-#endif
+
+	mail_tool_camel_lock_down ();
+
+	data->subject = mail_tool_generate_forward_subject (input->basis);
 }
 
 static void
-free_psd (GtkWidget *composer, gpointer user_data)
+cleanup_forward_messages (gpointer in_data, gpointer op_data,
+			  CamelException * ex)
 {
-	struct post_send_data *psd = user_data;
+	forward_messages_input_t *input =
 
-	gtk_object_unref (GTK_OBJECT (psd->folder));
-	g_free (psd);
-}
+		(forward_messages_input_t *) in_data;
+	forward_messages_data_t *data = (forward_messages_data_t *) op_data;
 
-static GtkWidget *
-create_msg_composer (const char *url)
-{
-	MailConfigIdentity *id;
-	gboolean send_html;
-	gchar *sig_file = NULL;
-	GtkWidget *composer_widget;
+	int i;
 
-	id = mail_config_get_default_identity ();
-	send_html = mail_config_send_html ();
-	
-	if (id) {
-		sig_file = id->sig;
+	for (i = 0; i < data->parts->len; i++) {
+		e_msg_composer_attach (input->composer,
+				       data->parts->pdata[i]);
+		camel_object_unref (CAMEL_OBJECT (data->parts->pdata[i]));
 	}
-	
-	if (url != NULL)
-		composer_widget = e_msg_composer_new_from_url (url);
-	else
-		composer_widget = e_msg_composer_new_with_sig_file (sig_file);
+	camel_object_unref (CAMEL_OBJECT (input->source));
 
-	e_msg_composer_set_send_html (E_MSG_COMPOSER (composer_widget), 
-				      send_html);
+	e_msg_composer_set_headers (input->composer, NULL, NULL, NULL,
+				    data->subject);
 
-	return composer_widget;
+	gtk_object_unref (GTK_OBJECT (input->composer));
+	g_free (data->subject);
+	g_ptr_array_free (data->parts, TRUE);
+	g_ptr_array_free (input->uids, TRUE);
+	gtk_widget_show (GTK_WIDGET (input->composer));
 }
 
+static const mail_operation_spec op_forward_messages = {
+	describe_forward_messages,
+	sizeof (forward_messages_data_t),
+	setup_forward_messages,
+	do_forward_messages,
+	cleanup_forward_messages
+};
+
 void
-compose_msg (GtkWidget *widget, gpointer user_data)
+mail_do_forward_message (CamelMimeMessage * basis,
+			 CamelFolder * source,
+			 GPtrArray * uids, EMsgComposer * composer)
 {
-	GtkWidget *composer;
-	
-	if (!check_configured ())
-		return;
-	
-	composer = create_msg_composer (NULL);
-	
-	gtk_signal_connect (GTK_OBJECT (composer), "send",
-			    GTK_SIGNAL_FUNC (composer_send_cb), NULL);
-	gtk_widget_show (composer);
+	forward_messages_input_t *input;
+
+	input = g_new (forward_messages_input_t, 1);
+	input->basis = basis;
+	input->source = source;
+	input->uids = uids;
+	input->composer = composer;
+
+	mail_operation_queue (&op_forward_messages, input, TRUE);
 }
 
-/* Send according to a mailto (RFC 2368) URL. */
-void
-send_to_url (const char *url)
+/* ** LOAD FOLDER ********************************************************* */
+
+typedef struct load_folder_input_s
 {
-	GtkWidget *composer;
+	FolderBrowser *fb;
+	gchar *url;
+}
+load_folder_input_t;
+
+static gchar *describe_load_folder (gpointer in_data, gboolean gerund);
+static void setup_load_folder (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
+static void do_load_folder (gpointer in_data, gpointer op_data,
+			    CamelException * ex);
+static void cleanup_load_folder (gpointer in_data, gpointer op_data,
+				 CamelException * ex);
+
+static gchar *
+describe_load_folder (gpointer in_data, gboolean gerund)
+{
+	load_folder_input_t *input = (load_folder_input_t *) in_data;
 
-	if (!check_configured ())
+	if (gerund) {
+		return g_strdup_printf ("Loading \"%s\"", input->url);
+	} else {
+		return g_strdup_printf ("Load \"%s\"", input->url);
+	}
+}
+
+static void
+setup_load_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	load_folder_input_t *input = (load_folder_input_t *) in_data;
+
+	if (!IS_FOLDER_BROWSER (input->fb)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder browser specified to load into.");
 		return;
+	}
 
-	composer = create_msg_composer (url);
+	if (!input->url) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No URL to load was specified.");
+		return;
+	}
+
+	gtk_object_ref (GTK_OBJECT (input->fb));
 
-	gtk_signal_connect (GTK_OBJECT (composer), "send",
-			    GTK_SIGNAL_FUNC (composer_send_cb), NULL);
-	gtk_widget_show (composer);
-}	
+	if (input->fb->uri)
+		g_free (input->fb->uri);
+
+	input->fb->uri = input->url;
+}
 
 static void
-reply (FolderBrowser *fb, gboolean to_all)
+do_load_folder (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	EMsgComposer *composer;
-	struct post_send_data *psd;
+	load_folder_input_t *input = (load_folder_input_t *) in_data;
+
+	CamelFolder *folder;
 
-	if (!check_configured () || !fb->message_list->cursor_uid ||
-	    !fb->mail_display->current_message)
+	folder = mail_tool_uri_to_folder (input->url, ex);
+	if (!folder)
 		return;
 
-	psd = g_new (struct post_send_data, 1);
-	psd->folder = fb->folder;
-	gtk_object_ref (GTK_OBJECT (psd->folder));
-	psd->uid = fb->message_list->cursor_uid;
-	psd->flags = CAMEL_MESSAGE_ANSWERED;
+	if (input->fb->folder) {
+		mail_tool_camel_lock_up ();
+		camel_object_unref (CAMEL_OBJECT (input->fb->folder));
+		mail_tool_camel_lock_down ();
+	}
 
-	composer = mail_generate_reply (fb->mail_display->current_message, to_all);
+	input->fb->folder = folder;
+}
+
+static void
+cleanup_load_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	load_folder_input_t *input = (load_folder_input_t *) in_data;
+
+	gtk_widget_set_sensitive (GTK_WIDGET (input->fb->search_entry),
+				  camel_folder_has_search_capability (input->
+								      fb->
+								      folder));
+	gtk_widget_set_sensitive (GTK_WIDGET (input->fb->search_menu),
+				  camel_folder_has_search_capability (input->
+								      fb->
+								      folder));
 
-	gtk_signal_connect (GTK_OBJECT (composer), "send",
-			    GTK_SIGNAL_FUNC (composer_send_cb), psd); 
-	gtk_signal_connect (GTK_OBJECT (composer), "destroy",
-			    GTK_SIGNAL_FUNC (free_psd), psd); 
+	message_list_set_folder (input->fb->message_list, input->fb->folder);
 
-	gtk_widget_show (GTK_WIDGET (composer));	
+	/*g_free (input->url); = fb->uri now */
 }
 
+static const mail_operation_spec op_load_folder = {
+	describe_load_folder,
+	0,
+	setup_load_folder,
+	do_load_folder,
+	cleanup_load_folder
+};
+
 void
-reply_to_sender (GtkWidget *widget, gpointer user_data)
+mail_do_load_folder (FolderBrowser * fb, const char *url)
 {
-	reply (FOLDER_BROWSER (user_data), FALSE);
+	load_folder_input_t *input;
+
+	input = g_new (load_folder_input_t, 1);
+	input->fb = fb;
+	input->url = g_strdup (url);
+
+	mail_operation_queue (&op_load_folder, input, TRUE);
 }
 
-void
-reply_to_all (GtkWidget *widget, gpointer user_data)
+/* ** CREATE FOLDER ******************************************************* */
+
+typedef struct create_folder_input_s
 {
-	reply (FOLDER_BROWSER (user_data), TRUE);
+	Evolution_ShellComponentListener listener;
+	char *uri;
+	char *type;
 }
+create_folder_input_t;
 
-static void
-attach_msg (MessageList *ml, const char *uid, gpointer data)
+typedef struct create_folder_data_s
 {
-	EMsgComposer *composer = data;
-	CamelMimeMessage *message;
-	CamelMimePart *part;
-	const char *subject;
-	char *desc;
-	
-	message = camel_folder_get_message (ml->folder, uid, NULL);
-	if (!message)
-		return;
-	subject = camel_mime_message_get_subject (message);
-	if (subject)
-		desc = g_strdup_printf ("Forwarded message - %s", subject);
-	else
-		desc = g_strdup ("Forwarded message");
-	
-	part = camel_mime_part_new ();
-	camel_mime_part_set_disposition (part, "inline");
-	camel_mime_part_set_description (part, desc);
-	camel_medium_set_content_object (CAMEL_MEDIUM (part),
-					 CAMEL_DATA_WRAPPER (message));
-	camel_mime_part_set_content_type (part, "message/rfc822");
-	
-	e_msg_composer_attach (composer, part);
-	
-	gtk_object_unref (GTK_OBJECT (part));
-	gtk_object_unref (GTK_OBJECT (message));
-	g_free (desc);
+	Evolution_ShellComponentListener_Result result;
+}
+create_folder_data_t;
+
+static gchar *describe_create_folder (gpointer in_data, gboolean gerund);
+static void setup_create_folder (gpointer in_data, gpointer op_data,
+				 CamelException * ex);
+static void do_create_folder (gpointer in_data, gpointer op_data,
+			      CamelException * ex);
+static void cleanup_create_folder (gpointer in_data, gpointer op_data,
+				   CamelException * ex);
+
+static gchar *
+describe_create_folder (gpointer in_data, gboolean gerund)
+{
+	create_folder_input_t *input = (create_folder_input_t *) in_data;
+
+	if (gerund) {
+		return g_strdup_printf ("Creating \"%s\"", input->uri);
+	} else {
+		return g_strdup_printf ("Create \"%s\"", input->uri);
+	}
 }
 
-void
-forward_msg (GtkWidget *widget, gpointer user_data)
+static void
+setup_create_folder (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	FolderBrowser *fb = FOLDER_BROWSER (user_data);
-	EMsgComposer *composer;
-	CamelMimeMessage *cursor_msg;
-	const char *from, *subject;
-	char *fwd_subj;
-	
-	cursor_msg = fb->mail_display->current_message;
-	if (!check_configured () || !cursor_msg)
+	create_folder_input_t *input = (create_folder_input_t *) in_data;
+
+	if (input->listener == CORBA_OBJECT_NIL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "Invalid listener passed to create_folder");
 		return;
+	}
 
-	composer = E_MSG_COMPOSER (create_msg_composer (NULL));
-	message_list_foreach (fb->message_list, attach_msg, composer);
+	if (input->uri == NULL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "Invalid url passed to create_folder");
+		return;
+	}
+
+	if (input->type == NULL) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No type passed to create_folder");
+		return;
+	}
+
+	/* FIXME: reference listener somehow? */
+}
 
-	from = camel_mime_message_get_from (cursor_msg);
-	subject = camel_mime_message_get_subject (cursor_msg);
-	if (from) {
-		if (subject && *subject) {
-			fwd_subj = g_strdup_printf ("[%s] %s", from, subject);
+static void
+do_create_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	create_folder_input_t *input = (create_folder_input_t *) in_data;
+	create_folder_data_t *data = (create_folder_data_t *) op_data;
+
+	CamelFolder *folder;
+	gchar *camel_url;
+
+	if (strcmp (input->type, "mail") != 0)
+		data->result =
+			Evolution_ShellComponentListener_UNSUPPORTED_TYPE;
+	else {
+		camel_url = g_strdup_printf ("mbox://%s", input->uri);
+		folder = mail_tool_get_folder_from_urlname (camel_url,
+							    "mbox", ex);
+		g_free (camel_url);
+
+		if (!camel_exception_is_set (ex)) {
+			camel_object_unref (CAMEL_OBJECT (folder));
+			data->result = Evolution_ShellComponentListener_OK;
 		} else {
-			fwd_subj = g_strdup_printf ("[%s] (forwarded message)",
-						    from);
+			data->result =
+				Evolution_ShellComponentListener_INVALID_URI;
 		}
-	} else {
-		fwd_subj = NULL;
 	}
+}
+
+static void
+cleanup_create_folder (gpointer in_data, gpointer op_data,
+		       CamelException * ex)
+{
+	create_folder_input_t *input = (create_folder_input_t *) in_data;
+	create_folder_data_t *data = (create_folder_data_t *) op_data;
+
+	CORBA_Environment ev;
 
-	e_msg_composer_set_headers (composer, NULL, NULL, NULL, fwd_subj);
-	g_free (fwd_subj);
+	CORBA_exception_init (&ev);
+	Evolution_ShellComponentListener_report_result (input->listener,
+							data->result, &ev);
+	if (ev._major != CORBA_NO_EXCEPTION)
+		camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM,
+				     "Exception while reporting result to shell "
+				     "component listener.");
+	CORBA_exception_free (&ev);
 
-	gtk_signal_connect (GTK_OBJECT (composer), "send",
-			    GTK_SIGNAL_FUNC (composer_send_cb), NULL);
+	/* FIXME: unref listener somehow? */
 
-	gtk_widget_show (GTK_WIDGET (composer));	
+	g_free (input->uri);
+	g_free (input->type);
 }
 
-struct move_data {
-	CamelFolder *source, *dest;
-	CamelException *ex;
+static const mail_operation_spec op_create_folder = {
+	describe_create_folder,
+	sizeof (create_folder_data_t),
+	setup_create_folder,
+	do_create_folder,
+	cleanup_create_folder
 };
 
-static void
-real_move_msg (MessageList *ml, const char *uid, gpointer user_data)
+void
+mail_do_create_folder (const Evolution_ShellComponentListener listener,
+		       const char *uri, const char *type)
 {
-	struct move_data *rfd = user_data;
+	create_folder_input_t *input;
 
-	if (camel_exception_is_set (rfd->ex))
-		return;
+	input = g_new (create_folder_input_t, 1);
+	input->listener = listener;
+	input->uri = g_strdup (uri);
+	input->type = g_strdup (type);
 
-	camel_folder_move_message_to (rfd->source, uid, rfd->dest, rfd->ex);
+	mail_operation_queue (&op_create_folder, input, FALSE);
 }
 
-void
-move_msg (GtkWidget *widget, gpointer user_data)
-{
-	FolderBrowser *fb = user_data;
-	MessageList *ml = fb->message_list;
-	char *uri, *physical, *path;
-	struct move_data rfd;
-	const char *allowed_types[] = { "mail", NULL };
-	extern EvolutionShellClient *global_shell_client;
-	static char *last = NULL;
-
-	if (!last)
-		last = g_strdup ("");
-
-	evolution_shell_client_user_select_folder  (global_shell_client,
-						    _("Move message(s) to"),
-						    last, allowed_types, &uri, &physical);
-	if (!uri)
-		return;
+/* ** SYNC FOLDER ********************************************************* */
+
+static gchar *describe_sync_folder (gpointer in_data, gboolean gerund);
+static void setup_sync_folder (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
+static void do_sync_folder (gpointer in_data, gpointer op_data,
+			    CamelException * ex);
+static void cleanup_sync_folder (gpointer in_data, gpointer op_data,
+				 CamelException * ex);
+
+static gchar *
+describe_sync_folder (gpointer in_data, gboolean gerund)
+{
+	CamelFolder *f = CAMEL_FOLDER (in_data);
 
-	path = strchr (uri, '/');
-	if (path && strcmp (last, path) != 0) {
-		g_free (last);
-		last = g_strdup (path);
+	if (gerund) {
+		return g_strdup_printf ("Synchronizing \"%s\"", f->full_name);
+	} else {
+		return g_strdup_printf ("Synchronize \"%s\"", f->full_name);
 	}
-	g_free (uri);
+}
 
-	rfd.source = ml->folder;
-	rfd.dest = mail_uri_to_folder (physical);
-	g_free (physical);
-	if (!rfd.dest)
+static void
+setup_sync_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	if (!CAMEL_IS_FOLDER (in_data)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder is selected to be synced");
 		return;
-	rfd.ex = camel_exception_new ();
-	
-	message_list_foreach (ml, real_move_msg, &rfd);
-	gtk_object_unref (GTK_OBJECT (rfd.dest));
-	
-	if (camel_exception_is_set (rfd.ex))
-		mail_exception_dialog ("Could not move message", rfd.ex, fb);
-	camel_exception_free (rfd.ex);
+	}
+
+	camel_object_ref (CAMEL_OBJECT (in_data));
+}
+
+static void
+do_sync_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	mail_tool_camel_lock_up ();
+	camel_folder_sync (CAMEL_FOLDER (in_data), FALSE, ex);
+	mail_tool_camel_lock_down ();
+}
+
+static void
+cleanup_sync_folder (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	camel_object_unref (CAMEL_OBJECT (in_data));
 }
 
+static const mail_operation_spec op_sync_folder = {
+	describe_sync_folder,
+	0,
+	setup_sync_folder,
+	do_sync_folder,
+	cleanup_sync_folder
+};
+
 void
-mark_all_seen (BonoboUIHandler *uih, void *user_data, const char *path)
+mail_do_sync_folder (CamelFolder * folder)
 {
-	FolderBrowser *fb = FOLDER_BROWSER(user_data);
-	MessageList *ml = fb->message_list;
-	GPtrArray *uids;
-	int i;
+	mail_operation_queue (&op_sync_folder, folder, FALSE);
+}
 
-	uids = camel_folder_get_uids (ml->folder);
-	for (i = 0; i < uids->len; i++) {
-		camel_folder_set_message_flags (ml->folder, uids->pdata[i],
-						CAMEL_MESSAGE_SEEN,
-						CAMEL_MESSAGE_SEEN);
-	}
+/* ** DISPLAY MESSAGE ***************************************************** */
+
+typedef struct display_message_input_s
+{
+	MessageList *ml;
+	gchar *uid;
+	 gint (*timeout) (gpointer);
 }
+display_message_input_t;
 
-static void
-real_edit_msg (MessageList *ml, const char *uid, gpointer user_data)
+typedef struct display_message_data_s
 {
-	CamelException *ex = user_data;
 	CamelMimeMessage *msg;
-	GtkWidget *composer;
-	
-	if (camel_exception_is_set (ex))
-		return;
-	
-	msg = camel_folder_get_message (ml->folder, uid, ex);
-	
-	composer = e_msg_composer_new_with_message (msg);
-	gtk_signal_connect (GTK_OBJECT (composer), "send",
-			    GTK_SIGNAL_FUNC (composer_send_cb), NULL);
-	gtk_widget_show (composer);
+}
+display_message_data_t;
+
+static gchar *describe_display_message (gpointer in_data, gboolean gerund);
+static void setup_display_message (gpointer in_data, gpointer op_data,
+				   CamelException * ex);
+static void do_display_message (gpointer in_data, gpointer op_data,
+				CamelException * ex);
+static void cleanup_display_message (gpointer in_data, gpointer op_data,
+				     CamelException * ex);
+
+static gchar *
+describe_display_message (gpointer in_data, gboolean gerund)
+{
+	display_message_input_t *input = (display_message_input_t *) in_data;
+
+	if (gerund) {
+		if (input->uid)
+			return g_strdup_printf ("Displaying message UID \"%s\"",
+						input->uid);
+		else
+			return g_strdup ("Clearing message display");
+	} else {
+		if (input->uid)
+			return g_strdup_printf ("Display message UID \"%s\"",
+						input->uid);
+		else
+			return g_strdup ("Clear message dispaly");
+	}
 }
 
-void
-edit_msg (GtkWidget *widget, gpointer user_data)
+static void
+setup_display_message (gpointer in_data, gpointer op_data,
+		       CamelException * ex)
 {
-	FolderBrowser *fb = FOLDER_BROWSER (user_data);
-	MessageList *ml = fb->message_list;
-	CamelException ex;
-	extern CamelFolder *drafts_folder;
-	
-	camel_exception_init (&ex);
-	
-	if (fb->folder != drafts_folder) {
-		camel_exception_setv (&ex, CAMEL_EXCEPTION_FOLDER_INSUFFICIENT_PERMISSION,
-				      "FIXME: some error message about not being in the Drafts folder...");
-		mail_exception_dialog ("Could not open message for editing", &ex, fb);
+	display_message_input_t *input = (display_message_input_t *) in_data;
+	display_message_data_t *data = (display_message_data_t *) op_data;
+
+	if (!IS_MESSAGE_LIST (input->ml)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "Invalid message list passed to display_message");
 		return;
 	}
-	
-	message_list_foreach (ml, real_edit_msg, &ex);
-	if (camel_exception_is_set (&ex)) {
-		mail_exception_dialog ("Could not open message for editing", &ex, fb);
-		camel_exception_clear (&ex);
+
+	if (!input->timeout) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No timeout callback passed to display_message");
 		return;
 	}
-}
 
-void
-edit_message (BonoboUIHandler *uih, void *user_data, const char *path)
-{
-	edit_msg (NULL, user_data);
+	data->msg = NULL;
+	gtk_object_ref (GTK_OBJECT (input->ml));
 }
 
 static void
-real_delete_msg (MessageList *ml, const char *uid, gpointer user_data)
+do_display_message (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	CamelException *ex = user_data;
-	guint32 flags;
+	display_message_input_t *input = (display_message_input_t *) in_data;
+	display_message_data_t *data = (display_message_data_t *) op_data;
 
-	if (camel_exception_is_set (ex))
+	if (input->uid == NULL) {
+		data->msg = NULL;
 		return;
+	}
 
-	/* Toggle the deleted flag without touching other flags. */
-	flags = camel_folder_get_message_flags (ml->folder, uid);
-	camel_folder_set_message_flags (ml->folder, uid,
-					CAMEL_MESSAGE_DELETED, ~flags);
+	data->msg = camel_folder_get_message (input->ml->folder,
+					      input->uid, ex);
 }
 
-void
-delete_msg (GtkWidget *button, gpointer user_data)
-{
-	FolderBrowser *fb = user_data;
-	MessageList *ml = fb->message_list;
-	CamelException ex;
-
-	camel_exception_init (&ex);
-	message_list_foreach (ml, real_delete_msg, &ex);
-	if (camel_exception_is_set (&ex)) {
-		mail_exception_dialog ("Could not toggle deleted flag",
-				       &ex, fb);
-		camel_exception_clear (&ex);
-		return;
+static void
+cleanup_display_message (gpointer in_data, gpointer op_data,
+			 CamelException * ex)
+{
+	display_message_input_t *input = (display_message_input_t *) in_data;
+	display_message_data_t *data = (display_message_data_t *) op_data;
+
+	MailDisplay *md = input->ml->parent_folder_browser->mail_display;
+
+	if (data->msg == NULL) {
+		mail_display_set_message (md, NULL);
+	} else {
+		if (input->ml->seen_id)
+			gtk_timeout_remove (input->ml->seen_id);
+
+		mail_display_set_message (md, CAMEL_MEDIUM (data->msg));
+		camel_object_unref (CAMEL_OBJECT (data->msg));
+
+		input->ml->seen_id =
+			gtk_timeout_add (1500, input->timeout, input->ml);
 	}
+
+	if (input->uid)
+		g_free (input->uid);
+	gtk_object_unref (GTK_OBJECT (input->ml));
 }
 
-static void real_expunge_folder (gpointer user_data)
-{
-	FolderBrowser *fb = FOLDER_BROWSER (user_data);
-	CamelException ex;
+static const mail_operation_spec op_display_message = {
+	describe_display_message,
+	sizeof (display_message_data_t),
+	setup_display_message,
+	do_display_message,
+	cleanup_display_message
+};
 
-	e_table_model_pre_change(fb->message_list->table_model);
+void
+mail_do_display_message (MessageList * ml, const char *uid,
+			 gint (*timeout) (gpointer))
+{
+	display_message_input_t *input;
 
-#ifdef USE_BROKEN_THREADS
-	mail_op_hide_progressbar ();
-	mail_op_set_message ("Expunging %s...", fb->message_list->folder->full_name);
-#endif
+	input = g_new (display_message_input_t, 1);
+	input->ml = ml;
+	input->uid = g_strdup (uid);
+	input->timeout = timeout;
 
-	camel_exception_init (&ex);
+	mail_operation_queue (&op_display_message, input, FALSE);
+}
 
-	camel_folder_expunge (fb->message_list->folder, &ex);
+/* ** EDIT MESSAGES ******************************************************* */
 
-	/* FIXME: is there a better way to force an update? */
-	/* FIXME: Folder should raise a signal to say its contents has changed ... */
-	e_table_model_changed (fb->message_list->table_model);
+typedef struct edit_messages_input_s {
+	CamelFolder *folder;
+	GPtrArray *uids;
+	GtkSignalFunc signal;
+} edit_messages_input_t;
+
+typedef struct edit_messages_data_s {
+	GPtrArray *messages;
+} edit_messages_data_t;
+
+static gchar *describe_edit_messages (gpointer in_data, gboolean gerund);
+static void setup_edit_messages (gpointer in_data, gpointer op_data,
+				  CamelException * ex);
+static void do_edit_messages (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
+static void cleanup_edit_messages (gpointer in_data, gpointer op_data,
+				    CamelException * ex);
+
+static gchar *
+describe_edit_messages (gpointer in_data, gboolean gerund)
+{
+	edit_messages_input_t *input = (edit_messages_input_t *) in_data;
 
-	if (camel_exception_get_id (&ex) != CAMEL_EXCEPTION_NONE) {
-		async_mail_exception_dialog ("Unable to expunge deleted messages", &ex, fb);
-	}
+	if (gerund)
+		return g_strdup_printf
+			("Opening messages from folder \"%s\"",
+			 input->folder->full_name);
+	else
+		return g_strdup_printf ("Open messages from \"%s\"",
+					input->folder->full_name);
 }
 
-void
-expunge_folder (BonoboUIHandler *uih, void *user_data, const char *path)
+static void
+setup_edit_messages (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	FolderBrowser *fb = FOLDER_BROWSER(user_data);
+	edit_messages_input_t *input = (edit_messages_input_t *) in_data;
 
-	if (fb->message_list->folder) {
-#ifdef USE_BROKEN_THREADS
-		mail_operation_try ("Expunge Folder", real_expunge_folder, NULL, fb);
-#else
-		real_expunge_folder (fb);
-#endif
+	if (!input->uids) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No UIDs specified to edit.");
+		return;
+	}
+
+	if (!CAMEL_IS_FOLDER (input->folder)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder to fetch the messages from specified.");
+		return;
 	}
+
+	camel_object_ref (CAMEL_OBJECT (input->folder));
 }
 
 static void
-filter_druid_clicked(GtkWidget *w, int button, FolderBrowser *fb)
+do_edit_messages (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	FilterContext *fc;
+	edit_messages_input_t *input = (edit_messages_input_t *) in_data;
+	edit_messages_data_t *data = (edit_messages_data_t *) op_data;
+
+	int i;
 
-	if (button == 0) {
-		char *user;
+	data->messages = g_ptr_array_new ();
 
-		fc = gtk_object_get_data((GtkObject *)w, "context");
-		user = g_strdup_printf("%s/filters.xml", evolution_dir);
-		rule_context_save((RuleContext *)fc, user);
-		g_free(user);
-	}
-	
-	if (button != -1) {
-		gnome_dialog_close((GnomeDialog *)w);
+	for (i = 0; i < input->uids->len; i++) {
+		CamelMimeMessage *message;
+
+		mail_tool_camel_lock_up ();
+		message = camel_folder_get_message (input->folder, input->uids->pdata[i], ex);
+		mail_tool_camel_lock_down ();
+
+		if (message)
+			g_ptr_array_add (data->messages, message);
+
+		g_free (input->uids->pdata[i]);
 	}
 }
 
-void
-filter_edit (BonoboUIHandler *uih, void *user_data, const char *path)
+static void
+cleanup_edit_messages (gpointer in_data, gpointer op_data,
+			CamelException * ex)
 {
-	FolderBrowser *fb = FOLDER_BROWSER (user_data);
-	FilterContext *fc;
-	char *user, *system;
-	GtkWidget *w;
+	edit_messages_input_t *input = (edit_messages_input_t *) in_data;
+	edit_messages_data_t *data = (edit_messages_data_t *) op_data;
+
+	int i;
+
+	for (i = 0; i < data->messages->len; i++) {
+		GtkWidget *composer;
+
+		composer = e_msg_composer_new_with_message (data->messages->pdata[i]);
+
+		if (input->signal)
+			gtk_signal_connect (GTK_OBJECT (composer), "send", 
+					    input->signal, NULL);
+
+		gtk_widget_show (composer);
+
+		camel_object_unref (CAMEL_OBJECT (data->messages->pdata[i]));
+	}
+
+	g_ptr_array_free (input->uids, TRUE);
+	g_ptr_array_free (data->messages, TRUE);
+	camel_object_unref (CAMEL_OBJECT (input->folder));
 
-	fc = filter_context_new();
-	user = g_strdup_printf("%s/filters.xml", evolution_dir);
-	system = g_strdup_printf("%s/evolution/filtertypes.xml", EVOLUTION_DATADIR);
-	rule_context_load((RuleContext *)fc, system, user);
-	g_free(user);
-	g_free(system);
-	w = filter_editor_construct(fc);
-	gtk_object_set_data_full((GtkObject *)w, "context", fc, (GtkDestroyNotify)gtk_object_unref);
-	gtk_signal_connect((GtkObject *)w, "clicked", filter_druid_clicked, fb);
-	gtk_widget_show(w);
 }
 
+static const mail_operation_spec op_edit_messages = {
+	describe_edit_messages,
+	sizeof (edit_messages_data_t),
+	setup_edit_messages,
+	do_edit_messages,
+	cleanup_edit_messages
+};
+
 void
-vfolder_edit_vfolders (BonoboUIHandler *uih, void *user_data, const char *path)
+mail_do_edit_messages (CamelFolder * folder, GPtrArray *uids,
+		       GtkSignalFunc signal)
 {
-	void vfolder_edit(void);
+	edit_messages_input_t *input;
+
+	input = g_new (edit_messages_input_t, 1);
+	input->folder = folder;
+	input->uids = uids;
+	input->signal = signal;
 
-	vfolder_edit();
+	mail_operation_queue (&op_edit_messages, input, TRUE);
 }
 
-void
-providers_config (BonoboUIHandler *uih, void *user_data, const char *path)
+/* ** SETUP DRAFTBOX ****************************************************** */
+
+static gchar *describe_setup_draftbox (gpointer in_data, gboolean gerund);
+static void noop_setup_draftbox (gpointer in_data, gpointer op_data,
+				  CamelException * ex);
+static void do_setup_draftbox (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
+
+static gchar *
+describe_setup_draftbox (gpointer in_data, gboolean gerund)
 {
-	mail_config();
+	if (gerund)
+		return g_strdup_printf ("Loading Draftbox");
+	else
+		return g_strdup_printf ("Load Draftbox");
 }
 
-void
-print_msg (GtkWidget *button, gpointer user_data)
+static void
+noop_setup_draftbox (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	FolderBrowser *fb = user_data;
-	GnomePrintMaster *print_master;
-	GnomePrintContext *print_context;
-	GtkWidget *preview;
+}
 
-	print_master = gnome_print_master_new ();
+static void
+do_setup_draftbox (gpointer in_data, gpointer op_data, CamelException * ex)
+{
+	extern CamelFolder *drafts_folder;
+	gchar *url;
 
-	print_context = gnome_print_master_get_context (print_master);
-	gtk_html_print (fb->mail_display->html, print_context);
+	url = g_strdup_printf ("mbox://%s/local/Drafts", evolution_dir);
+	drafts_folder = mail_tool_get_folder_from_urlname (url, "mbox", ex);
+	g_free (url);
+}
 
-	preview = GTK_WIDGET (gnome_print_master_preview_new (
-		print_master, "Mail Print Preview"));
-	gtk_widget_show (preview);
+/*
+ *static void
+ *cleanup_setup_draftbox (gpointer in_data, gpointer op_data,
+ *			CamelException * ex)
+ *{
+ *}
+ */
 
-	gtk_object_unref (GTK_OBJECT (print_master));
-}
+static const mail_operation_spec op_setup_draftbox = {
+	describe_setup_draftbox,
+	0,
+	noop_setup_draftbox,
+	do_setup_draftbox,
+	noop_setup_draftbox
+};
 
 void
-configure_folder(BonoboUIHandler *uih, void *user_data, const char *path)
+mail_do_setup_draftbox (void)
 {
-	FolderBrowser *fb = FOLDER_BROWSER(user_data);
-
-	local_reconfigure_folder(fb);
+	mail_operation_queue (&op_setup_draftbox, NULL, FALSE);
 }
 
+/* ** VIEW MESSAGES ******************************************************* */
 
-struct view_msg_data {
+typedef struct view_messages_input_s {
+	CamelFolder *folder;
+	GPtrArray *uids;
 	FolderBrowser *fb;
-	CamelException *ex;
-};
+} view_messages_input_t;
+
+typedef struct view_messages_data_s {
+	GPtrArray *messages;
+} view_messages_data_t;
+
+static gchar *describe_view_messages (gpointer in_data, gboolean gerund);
+static void setup_view_messages (gpointer in_data, gpointer op_data,
+				  CamelException * ex);
+static void do_view_messages (gpointer in_data, gpointer op_data,
+			       CamelException * ex);
+static void cleanup_view_messages (gpointer in_data, gpointer op_data,
+				    CamelException * ex);
+
+static gchar *
+describe_view_messages (gpointer in_data, gboolean gerund)
+{
+	view_messages_input_t *input = (view_messages_input_t *) in_data;
+
+	if (gerund)
+		return g_strdup_printf
+			("Viewing messages from folder \"%s\"",
+			 input->folder->full_name);
+	else
+		return g_strdup_printf ("View messages from \"%s\"",
+					input->folder->full_name);
+}
 
 static void
-real_view_msg (MessageList *ml, const char *uid, gpointer user_data)
+setup_view_messages (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	struct view_msg_data *data = user_data;
-	FolderBrowser *fb;
-	CamelMimeMessage *msg;
-	GtkWidget *view;
-	
-	if (camel_exception_is_set (data->ex))
+	view_messages_input_t *input = (view_messages_input_t *) in_data;
+
+	if (!input->uids) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No UIDs specified to view.");
 		return;
-	
-	msg = camel_folder_get_message (ml->folder, uid, data->ex);
-	
-	fb = FOLDER_BROWSER (folder_browser_new ());
-	folder_browser_set_uri (fb, data->fb->uri);
-	
-	fb->message_list->cursor_uid = uid;
-	fb->mail_display->current_message = msg;
-	
-	view = mail_view_create (fb);
-	
-	gtk_widget_show (view);
+	}
+
+	if (!CAMEL_IS_FOLDER (input->folder)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder to fetch the messages from specified.");
+		return;
+	}
+
+	if (!IS_FOLDER_BROWSER (input->fb)) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_INVALID_PARAM,
+				     "No folder browser was specified.");
+		return;
+	}
+
+
+	camel_object_ref (CAMEL_OBJECT (input->folder));
+	gtk_object_ref (GTK_OBJECT (input->fb));
 }
 
-void
-view_msg (GtkWidget *widget, gpointer user_data)
+static void
+do_view_messages (gpointer in_data, gpointer op_data, CamelException * ex)
 {
-	struct view_msg_data data;
-	FolderBrowser *fb = user_data;
-	FolderBrowser *folder_browser;
-	CamelException ex;
-	MessageList *ml;
-	
-	camel_exception_init (&ex);
-	
-	data.fb = fb;
-	data.ex = &ex;
-	
-	ml = fb->message_list;
-	message_list_foreach (ml, real_view_msg, &data);
-	if (camel_exception_is_set (&ex)) {
-		mail_exception_dialog ("Could not open message for viewing", &ex, fb);
-		camel_exception_clear (&ex);
-		return;
+	view_messages_input_t *input = (view_messages_input_t *) in_data;
+	view_messages_data_t *data = (view_messages_data_t *) op_data;
+
+	int i;
+
+	data->messages = g_ptr_array_new ();
+
+	for (i = 0; i < input->uids->len; i++) {
+		CamelMimeMessage *message;
+
+		mail_tool_camel_lock_up ();
+		message = camel_folder_get_message (input->folder, input->uids->pdata[i], ex);
+		mail_tool_camel_lock_down ();
+
+		g_ptr_array_add (data->messages, message);
 	}
 }
 
+static void
+cleanup_view_messages (gpointer in_data, gpointer op_data,
+		       CamelException * ex)
+{
+	view_messages_input_t *input = (view_messages_input_t *) in_data;
+	view_messages_data_t *data = (view_messages_data_t *) op_data;
+
+	int i;
+
+	for (i = 0; i < data->messages->len; i++) {
+		CamelMimeMessage *msg;
+		gchar *uid;
+		GtkWidget *view;
+
+		if (data->messages->pdata[i] == NULL)
+			continue;
+
+		msg = data->messages->pdata[i];
+		uid = input->uids->pdata[i];
+
+		view = mail_view_create (input->folder, uid, msg);
+		gtk_widget_show (view);
+
+		/*Owned by the mail_display now*/
+		camel_object_unref (CAMEL_OBJECT (data->messages->pdata[i]));
+		g_free (uid);
+	}
+
+	g_ptr_array_free (input->uids, TRUE);
+	g_ptr_array_free (data->messages, TRUE);
+	camel_object_unref (CAMEL_OBJECT (input->folder));
+	gtk_object_unref (GTK_OBJECT (input->fb));
+}
+
+static const mail_operation_spec op_view_messages = {
+	describe_view_messages,
+	sizeof (view_messages_data_t),
+	setup_view_messages,
+	do_view_messages,
+	cleanup_view_messages
+};
+
 void
-view_message (BonoboUIHandler *uih, void *user_data, const char *path)
+mail_do_view_messages (CamelFolder * folder, GPtrArray *uids,
+		       FolderBrowser *fb)
 {
-	view_msg (NULL, user_data);
+	view_messages_input_t *input;
+
+	input = g_new (view_messages_input_t, 1);
+	input->folder = folder;
+	input->uids = uids;
+	input->fb = fb;
+
+	mail_operation_queue (&op_view_messages, input, TRUE);
 }