cvs removed.

2003-09-17  Not Zed  <NotZed@Ximian.com>

         * folder-browser.c, folder-browser.h, folder-browser-ui.c
         folder-browser-ui.h, mail-callbacks.c, mail-callbacks.h
         mail-display.c, mail-display.h, mail-display-stream.c
         mail-display-stream.h, mail-format.c, mail-format.h
         mail-identify.c, mail-search.c, mail-search.h
         message-browser.c, message-browser.h, subscribe-dialog.c
         subscribe-dialog.h, mail-font-prefs.c, mail-font-prefs.h: cvs
         removed.

        * Makefile.am: Removed mail-font-prefs.[ch], hasn't been built for
        ages.

        * em-*.c: killed a bunch of printfs.

        * em-format-html-display.c (efhd_html_button_press_event): update
        for html object api chagnes.

        ** Merge in mail-refactor-2 branch.

svn path=/trunk/; revision=22602

1 files changed, 2327 insertions, 0 deletions

diff --git a/mail/em-utils.c b/mail/em-utils.c
new file mode 100644
index 0000000000..07de855e0f
--- /dev/null
+++ b/mail/em-utils.c
@@ -0,0 +1,2327 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ *  Authors: Jeffrey Stedfast <fejj@ximian.com>
+ *
+ *  Copyright 2003 Ximian, Inc. (www.ximian.com)
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <time.h>
+
+#include <camel/camel-stream-fs.h>
+#include <camel/camel-url-scanner.h>
+
+#include <filter/filter-editor.h>
+
+#include "mail-mt.h"
+#include "mail-ops.h"
+#include "mail-tools.h"
+#include "mail-config.h"
+#include "mail-config-druid.h"
+#include "message-tag-followup.h"
+
+#include <e-util/e-mktemp.h>
+#include <e-util/e-dialog-utils.h>
+
+#include "em-utils.h"
+#include "em-composer-utils.h"
+#include "em-format-quote.h"
+
+static EAccount *guess_account (CamelMimeMessage *message);
+
+/**
+ * em_utils_prompt_user:
+ * @parent: parent window
+ * @def: default response
+ * @again: continue prompting the user in the future
+ * @fmt: prompt format
+ * @Varargs: varargs
+ *
+ * Convenience function to query the user with a Yes/No dialog and a
+ * "Don't show this dialog again" checkbox. If the user checks that
+ * checkbox, then @again is set to %FALSE, otherwise it is set to
+ * %TRUE.
+ *
+ * Returns %TRUE if the user clicks Yes or %FALSE otherwise.
+ **/
+gboolean
+em_utils_prompt_user (GtkWindow *parent, int def, gboolean *again, const char *fmt, ...)
+{
+	GtkWidget *mbox, *check = NULL;
+	va_list ap;
+	int button;
+	char *str;
+	
+	va_start (ap, fmt);
+	str = g_strdup_vprintf (fmt, ap);
+	va_end (ap);
+	mbox = gtk_message_dialog_new (parent, GTK_DIALOG_DESTROY_WITH_PARENT,
+				       GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
+				       "%s", str);
+	g_free (str);
+	gtk_dialog_set_default_response ((GtkDialog *) mbox, def);
+	if (again) {
+		check = gtk_check_button_new_with_label (_("Don't show this message again."));
+		gtk_box_pack_start ((GtkBox *)((GtkDialog *) mbox)->vbox, check, TRUE, TRUE, 10);
+		gtk_widget_show (check);
+	}
+	
+	button = gtk_dialog_run ((GtkDialog *) mbox);
+	if (again)
+		*again = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check));
+	gtk_widget_destroy (mbox);
+	
+	return button == GTK_RESPONSE_YES;
+}
+
+
+/**
+ * em_utils_uids_copy:
+ * @uids: array of uids
+ *
+ * Duplicates the array of uids held by @uids into a new
+ * GPtrArray. Use em_utils_uids_free() to free the resultant uid
+ * array.
+ *
+ * Returns a duplicate copy of @uids.
+ **/
+GPtrArray *
+em_utils_uids_copy (GPtrArray *uids)
+{
+	GPtrArray *copy;
+	int i;
+	
+	copy = g_ptr_array_new ();
+	g_ptr_array_set_size (copy, uids->len);
+	
+	for (i = 0; i < uids->len; i++)
+		copy->pdata[i] = g_strdup (uids->pdata[i]);
+	
+	return copy;
+}
+
+/**
+ * em_utils_uids_free:
+ * @uids: array of uids
+ *
+ * Frees the array of uids pointed to by @uids back to the system.
+ **/
+void
+em_utils_uids_free (GPtrArray *uids)
+{
+	int i;
+	
+	for (i = 0; i < uids->len; i++)
+		g_free (uids->pdata[i]);
+	
+	g_ptr_array_free (uids, TRUE);
+}
+
+static void
+druid_destroy_cb (gpointer user_data, GObject *deadbeef)
+{
+	gtk_main_quit ();
+}
+
+/**
+ * em_utils_configure_account:
+ * @parent: parent window for the druid to be a child of.
+ *
+ * Displays a druid allowing the user to configure an account. If
+ * @parent is non-NULL, then the druid will be created as a child
+ * window of @parent's toplevel window.
+ *
+ * Returns %TRUE if an account has been configured or %FALSE
+ * otherwise.
+ **/
+gboolean
+em_utils_configure_account (GtkWidget *parent)
+{
+	MailConfigDruid *druid;
+	
+	druid = mail_config_druid_new ();
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) druid, parent);
+	
+	g_object_weak_ref ((GObject *) druid, (GWeakNotify) druid_destroy_cb, NULL);
+	gtk_widget_show ((GtkWidget *) druid);
+	gtk_grab_add ((GtkWidget *) druid);
+	gtk_main ();
+	
+	return mail_config_is_configured ();
+}
+
+/**
+ * em_utils_check_user_can_send_mail:
+ * @parent: parent window for the druid to be a child of.
+ *
+ * If no accounts have been configured, the user will be given a
+ * chance to configure an account. In the case that no accounts are
+ * configured, a druid will be created. If @parent is non-NULL, then
+ * the druid will be created as a child window of @parent's toplevel
+ * window.
+ *
+ * Returns %TRUE if the user has an account configured (to send mail)
+ * or %FALSE otherwise.
+ **/
+gboolean
+em_utils_check_user_can_send_mail (GtkWidget *parent)
+{
+	EAccount *account;
+	
+	if (!mail_config_is_configured ()) {
+		if (!em_utils_configure_account (parent))
+			return FALSE;
+	}
+	
+	if (!(account = mail_config_get_default_account ()))
+		return FALSE;
+	
+	/* Check for a transport */
+	if (!account->transport->url)
+		return FALSE;
+	
+	return TRUE;
+}
+
+/* Editing Filters/vFolders... */
+
+static GtkWidget *filter_editor = NULL;
+
+static void
+filter_editor_response (GtkWidget *dialog, int button, gpointer user_data)
+{
+	extern char *evolution_dir;
+	FilterContext *fc;
+	
+	if (button == GTK_RESPONSE_ACCEPT) {
+		char *user;
+		
+		fc = g_object_get_data ((GObject *) dialog, "context");
+		user = g_strdup_printf ("%s/filters.xml", evolution_dir);
+		rule_context_save ((RuleContext *) fc, user);
+		g_free (user);
+	}
+	
+	gtk_widget_destroy (dialog);
+	
+	filter_editor = NULL;
+}
+
+static const char *filter_source_names[] = {
+	"incoming",
+	"outgoing",
+	NULL,
+};
+
+/**
+ * em_utils_edit_filters:
+ * @parent: parent window
+ *
+ * Opens or raises the filters editor dialog so that the user may edit
+ * his/her filters. If @parent is non-NULL, then the dialog will be
+ * created as a child window of @parent's toplevel window.
+ **/
+void
+em_utils_edit_filters (GtkWidget *parent)
+{
+	extern char *evolution_dir;
+	char *user, *system;
+	FilterContext *fc;
+	
+	if (filter_editor) {
+		gdk_window_raise (GTK_WIDGET (filter_editor)->window);
+		return;
+	}
+	
+	fc = filter_context_new ();
+	user = g_strdup_printf ("%s/filters.xml", evolution_dir);
+	system = EVOLUTION_PRIVDATADIR "/filtertypes.xml";
+	rule_context_load ((RuleContext *) fc, system, user);
+	g_free (user);
+	
+	if (((RuleContext *) fc)->error) {
+		e_notice (parent, GTK_MESSAGE_ERROR,
+			  _("Error loading filter information:\n%s"),
+			  ((RuleContext *) fc)->error);
+		return;
+	}
+	
+	filter_editor = (GtkWidget *) filter_editor_new (fc, filter_source_names);
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) filter_editor, parent);
+	
+	gtk_window_set_title (GTK_WINDOW (filter_editor), _("Filters"));
+	g_object_set_data_full ((GObject *) filter_editor, "context", fc, (GtkDestroyNotify) g_object_unref);
+	g_signal_connect (filter_editor, "response", G_CALLBACK (filter_editor_response), NULL);
+	gtk_widget_show (GTK_WIDGET (filter_editor));
+}
+
+/* Composing messages... */
+
+static EMsgComposer *
+create_new_composer (GtkWidget *parent)
+{
+	EMsgComposer *composer;
+	
+	composer = e_msg_composer_new ();
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) composer, parent);
+	
+	em_composer_utils_setup_default_callbacks (composer);
+	
+	return composer;
+}
+
+/**
+ * em_utils_compose_new_message:
+ * @parent: parent window
+ *
+ * Opens a new composer window as a child window of @parent's toplevel
+ * window.
+ **/
+void
+em_utils_compose_new_message (GtkWidget *parent)
+{
+	GtkWidget *composer;
+	
+	composer = (GtkWidget *) create_new_composer (parent);
+	
+	gtk_widget_show (composer);
+}
+
+/**
+ * em_utils_compose_new_message_with_mailto:
+ * @parent: parent window
+ * @url: mailto url
+ *
+ * Opens a new composer window as a child window of @parent's toplevel
+ * window. If @url is non-NULL, the composer fields will be filled in
+ * according to the values in the mailto url.
+ **/
+void
+em_utils_compose_new_message_with_mailto (GtkWidget *parent, const char *url)
+{
+	EMsgComposer *composer;
+	
+	if (url != NULL)
+		composer = e_msg_composer_new_from_url (url);
+	else
+		composer = e_msg_composer_new ();
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) composer, parent);
+	
+	em_composer_utils_setup_default_callbacks (composer);
+	
+	gtk_widget_show ((GtkWidget *) composer);
+}
+
+/**
+ * em_utils_post_to_url:
+ * @parent: parent window
+ * @url: mailto url
+ *
+ * Opens a new composer window as a child window of @parent's toplevel
+ * window. If @url is non-NULL, the composer will default to posting
+ * mail to the folder specified by @url.
+ **/
+void
+em_utils_post_to_url (GtkWidget *parent, const char *url)
+{
+	EMsgComposer *composer;
+	
+	composer = e_msg_composer_new_post ();
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) composer, parent);
+	
+	if (url != NULL)
+		e_msg_composer_hdrs_set_post_to ((EMsgComposerHdrs *) ((EMsgComposer *) composer)->hdrs, url);
+	
+	em_composer_utils_setup_default_callbacks (composer);
+	
+	e_msg_composer_unset_changed (composer);
+	e_msg_composer_drop_editor_undo (composer);
+	
+	gtk_widget_show ((GtkWidget *) composer);
+}
+
+/* Editing messages... */
+
+static void
+edit_message (GtkWidget *parent, CamelMimeMessage *message, CamelFolder *drafts, const char *uid)
+{
+	EMsgComposer *composer;
+	
+	composer = e_msg_composer_new_with_message (message);
+	em_composer_utils_setup_callbacks (composer, NULL, NULL, 0, 0, drafts, uid);
+	e_msg_composer_unset_changed (composer);
+	e_msg_composer_drop_editor_undo (composer);
+	
+	gtk_widget_show (GTK_WIDGET (composer));
+}
+
+/**
+ * em_utils_edit_message:
+ * @parent: parent window
+ * @message: message to edit
+ *
+ * Opens a composer filled in with the headers/mime-parts/etc of
+ * @message.
+ **/
+void
+em_utils_edit_message (GtkWidget *parent, CamelMimeMessage *message)
+{
+	g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));
+	
+	edit_message (parent, message, NULL, NULL);
+}
+
+static void
+edit_messages (CamelFolder *folder, GPtrArray *uids, GPtrArray *msgs, void *user_data)
+{
+	int i;
+	
+	if (msgs == NULL)
+		return;
+	
+	for (i = 0; i < msgs->len; i++) {
+		camel_medium_remove_header (CAMEL_MEDIUM (msgs->pdata[i]), "X-Mailer");
+		
+		edit_message ((GtkWidget *) user_data, msgs->pdata[i], folder, uids->pdata[i]);
+	}
+}
+
+/**
+ * em_utils_edit_messages:
+ * @parent: parent window
+ * @folder: folder containing messages to edit
+ * @uids: uids of messages to edit
+ *
+ * Opens a composer for each message to be edited.
+ **/
+void
+em_utils_edit_messages (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+	
+	mail_get_messages (folder, uids, edit_messages, parent);
+}
+
+/* Forwarding messages... */
+
+static void
+forward_attached (CamelFolder *folder, GPtrArray *messages, CamelMimePart *part, char *subject, void *user_data)
+{
+	EMsgComposer *composer;
+	
+	if (part == NULL)
+		return;
+	
+	composer = create_new_composer ((GtkWidget *) user_data);
+	e_msg_composer_set_headers (composer, NULL, NULL, NULL, NULL, subject);
+	e_msg_composer_attach (composer, part);
+	
+	e_msg_composer_unset_changed (composer);
+	e_msg_composer_drop_editor_undo (composer);
+	
+	gtk_widget_show (GTK_WIDGET (composer));
+}
+
+/**
+ * em_utils_forward_attached:
+ * @parent: parent window
+ * @folder: folder containing messages to forward
+ * @uids: uids of messages to forward
+ *
+ * If there is more than a single message in @uids, a multipart/digest
+ * will be constructed and attached to a new composer window preset
+ * with the appropriate header defaults for forwarding the first
+ * message in the list. If only one message is to be forwarded, it is
+ * forwarded as a simple message/rfc822 attachment.
+ **/
+void
+em_utils_forward_attached (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+	
+	mail_build_attachment (folder, uids, forward_attached, parent);
+}
+
+static void
+forward_non_attached (GtkWidget *parent, GPtrArray *messages, int style)
+{
+	CamelMimeMessage *message;
+	CamelDataWrapper *wrapper;
+	EMsgComposer *composer;
+	char *subject, *text;
+	int i;
+	guint32 flags;
+
+	if (messages->len == 0)
+		return;
+
+	flags = EM_FORMAT_QUOTE_HEADERS;
+	if (style == MAIL_CONFIG_FORWARD_QUOTED)
+		flags |= EM_FORMAT_QUOTE_CITE;
+
+	for (i = 0; i < messages->len; i++) {
+		message = messages->pdata[i];
+		subject = mail_tool_generate_forward_subject (message);
+		
+		text = em_utils_message_to_html(message, _("-------- Forwarded Message --------"), flags);
+		
+		if (text) {
+			composer = create_new_composer (parent);
+			e_msg_composer_set_headers (composer, NULL, NULL, NULL, NULL, subject);
+			e_msg_composer_set_body_text (composer, text);
+			
+			wrapper = camel_medium_get_content_object (CAMEL_MEDIUM (message));
+			if (CAMEL_IS_MULTIPART (wrapper))
+				e_msg_composer_add_message_attachments (composer, message, FALSE);
+			
+			e_msg_composer_unset_changed (composer);
+			e_msg_composer_drop_editor_undo (composer);
+			
+			gtk_widget_show (GTK_WIDGET (composer));
+			
+			g_free (text);
+		}
+		
+		g_free (subject);
+	}
+}
+
+static void
+forward_inline (CamelFolder *folder, GPtrArray *uids, GPtrArray *messages, void *user_data)
+{
+	forward_non_attached ((GtkWidget *) user_data, messages, MAIL_CONFIG_FORWARD_INLINE);
+}
+
+/**
+ * em_utils_forward_inline:
+ * @parent: parent window
+ * @folder: folder containing messages to forward
+ * @uids: uids of messages to forward
+ *
+ * Forwards each message in the 'inline' form, each in its own composer window.
+ **/
+void
+em_utils_forward_inline (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+	
+	mail_get_messages (folder, uids, forward_inline, parent);
+}
+
+static void
+forward_quoted (CamelFolder *folder, GPtrArray *uids, GPtrArray *messages, void *user_data)
+{
+	forward_non_attached ((GtkWidget *) user_data, messages, MAIL_CONFIG_FORWARD_QUOTED);
+}
+
+/**
+ * em_utils_forward_quoted:
+ * @parent: parent window
+ * @folder: folder containing messages to forward
+ * @uids: uids of messages to forward
+ *
+ * Forwards each message in the 'quoted' form (each line starting with
+ * a "> "), each in its own composer window.
+ **/
+void
+em_utils_forward_quoted (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+	
+	mail_get_messages (folder, uids, forward_quoted, parent);
+}
+
+/**
+ * em_utils_forward_message:
+ * @parent: parent window
+ * @message: message to be forwarded
+ *
+ * Forwards a message in the user's configured default style.
+ **/
+void
+em_utils_forward_message (GtkWidget *parent, CamelMimeMessage *message)
+{
+	GPtrArray *messages;
+	CamelMimePart *part;
+	GConfClient *gconf;
+	char *subject;
+	int mode;
+	
+	messages = g_ptr_array_new ();
+	g_ptr_array_add (messages, message);
+	
+	gconf = mail_config_get_gconf_client ();
+	mode = gconf_client_get_int (gconf, "/apps/evolution/mail/format/forward_style", NULL);
+	
+	switch (mode) {
+	case MAIL_CONFIG_FORWARD_ATTACHED:
+	default:
+		part = mail_tool_make_message_attachment (message);
+		
+		subject = mail_tool_generate_forward_subject (message);
+		
+		forward_attached (NULL, messages, part, subject, parent);
+		camel_object_unref (part);
+		g_free (subject);
+		break;
+	case MAIL_CONFIG_FORWARD_INLINE:
+		forward_non_attached(parent, messages, MAIL_CONFIG_FORWARD_INLINE);
+		break;
+	case MAIL_CONFIG_FORWARD_QUOTED:
+		forward_non_attached(parent, messages, MAIL_CONFIG_FORWARD_QUOTED);
+		break;
+	}
+	
+	g_ptr_array_free (messages, TRUE);
+}
+
+/**
+ * em_utils_forward_messages:
+ * @parent: parent window
+ * @folder: folder containing messages to forward
+ * @uids: uids of messages to forward
+ *
+ * Forwards a group of messages in the user's configured default
+ * style.
+ **/
+void
+em_utils_forward_messages (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	GConfClient *gconf;
+	int mode;
+	
+	gconf = mail_config_get_gconf_client ();
+	mode = gconf_client_get_int (gconf, "/apps/evolution/mail/format/forward_style", NULL);
+	
+	switch (mode) {
+	case MAIL_CONFIG_FORWARD_ATTACHED:
+	default:
+		em_utils_forward_attached (parent, folder, uids);
+		break;
+	case MAIL_CONFIG_FORWARD_INLINE:
+		em_utils_forward_inline (parent, folder, uids);
+		break;
+	case MAIL_CONFIG_FORWARD_QUOTED:
+		em_utils_forward_quoted (parent, folder, uids);
+		break;
+	}
+}
+
+/* Redirecting messages... */
+
+static EMsgComposer *
+redirect_get_composer (GtkWidget *parent, CamelMimeMessage *message)
+{
+	EMsgComposer *composer;
+	EAccount *account;
+	
+	/* QMail will refuse to send a message if it finds one of
+	   it's Delivered-To headers in the message, so remove all
+	   Delivered-To headers. Fixes bug #23635. */
+	while (camel_medium_get_header (CAMEL_MEDIUM (message), "Delivered-To"))
+		camel_medium_remove_header (CAMEL_MEDIUM (message), "Delivered-To");
+	
+	account = guess_account (message);
+	
+	composer = e_msg_composer_new_redirect (message, account ? account->name : NULL);
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) composer, parent);
+	
+	em_composer_utils_setup_default_callbacks (composer);
+	
+	return composer;
+}
+
+/**
+ * em_utils_redirect_message:
+ * @parent: parent window
+ * @message: message to redirect
+ *
+ * Opens a composer to redirect @message (Note: only headers will be
+ * editable). Adds Resent-From/Resent-To/etc headers.
+ **/
+void
+em_utils_redirect_message (GtkWidget *parent, CamelMimeMessage *message)
+{
+	EMsgComposer *composer;
+	CamelDataWrapper *wrapper;
+	
+	g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));
+	
+	composer = redirect_get_composer (parent, message);
+	
+	wrapper = camel_medium_get_content_object (CAMEL_MEDIUM (message));
+	if (CAMEL_IS_MULTIPART (wrapper))
+		e_msg_composer_add_message_attachments (composer, message, FALSE);
+	
+	gtk_widget_show (GTK_WIDGET (composer));
+	e_msg_composer_unset_changed (composer);
+	e_msg_composer_drop_editor_undo (composer);
+}
+
+static void
+redirect_msg (CamelFolder *folder, const char *uid, CamelMimeMessage *message, void *user_data)
+{
+	if (message == NULL)
+		return;
+	
+	em_utils_redirect_message ((GtkWidget *) user_data, message);
+}
+
+/**
+ * em_utils_redirect_message_by_uid:
+ * @parent: parent window
+ * @folder: folder containing message to be redirected
+ * @uid: uid of message to be redirected
+ *
+ * Opens a composer to redirect the message (Note: only headers will
+ * be editable). Adds Resent-From/Resent-To/etc headers.
+ **/
+void
+em_utils_redirect_message_by_uid (GtkWidget *parent, CamelFolder *folder, const char *uid)
+{
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uid != NULL);
+	
+	mail_get_message (folder, uid, redirect_msg, parent, mail_thread_new);
+}
+
+/* Replying to messages... */
+
+static GHashTable *
+generate_account_hash (void)
+{
+	GHashTable *account_hash;
+	EAccount *account, *def;
+	EAccountList *accounts;
+	EIterator *iter;
+	
+	accounts = mail_config_get_accounts ();
+	account_hash = g_hash_table_new (camel_strcase_hash, camel_strcase_equal);
+	
+	/* add the default account to the hash first */
+	if ((def = mail_config_get_default_account ())) {
+		if (def->id->address)
+			g_hash_table_insert (account_hash, (char *) def->id->address, (void *) def);
+	}
+	
+	iter = e_list_get_iterator ((EList *) accounts);
+	while (e_iterator_is_valid (iter)) {
+		account = (EAccount *) e_iterator_get (iter);
+		
+		if (account->id->address) {
+			EAccount *acnt;
+			
+			/* Accounts with identical email addresses that are enabled
+			 * take precedence over the accounts that aren't. If all
+			 * accounts with matching email addresses are disabled, then
+			 * the first one in the list takes precedence. The default
+			 * account always takes precedence no matter what.
+			 */
+			acnt = g_hash_table_lookup (account_hash, account->id->address);
+			if (acnt && acnt != def && !acnt->enabled && account->enabled) {
+				g_hash_table_remove (account_hash, acnt->id->address);
+				acnt = NULL;
+			}
+			
+			if (!acnt)
+				g_hash_table_insert (account_hash, (char *) account->id->address, (void *) account);
+		}
+		
+		e_iterator_next (iter);
+	}
+	
+	g_object_unref (iter);
+	
+	return account_hash;
+}
+
+static EDestination **
+em_utils_camel_address_to_destination (CamelInternetAddress *iaddr)
+{
+	EDestination *dest, **destv;
+	int n, i, j;
+	
+	if (iaddr == NULL)
+		return NULL;
+	
+	if ((n = camel_address_length ((CamelAddress *) iaddr)) == 0)
+		return NULL;
+	
+	destv = g_malloc (sizeof (EDestination *) * (n + 1));
+	for (i = 0, j = 0; i < n; i++) {
+		const char *name, *addr;
+		
+		if (camel_internet_address_get (iaddr, i, &name, &addr)) {
+			dest = e_destination_new ();
+			e_destination_set_name (dest, name);
+			e_destination_set_email (dest, addr);
+			
+			destv[j++] = dest;
+		}
+	}
+	
+	if (j == 0) {
+		g_free (destv);
+		return NULL;
+	}
+	
+	destv[j] = NULL;
+	
+	return destv;
+}
+
+static EMsgComposer *
+reply_get_composer (GtkWidget *parent, CamelMimeMessage *message, EAccount *account,
+		    CamelInternetAddress *to, CamelInternetAddress *cc)
+{
+	const char *message_id, *references;
+	EDestination **tov, **ccv;
+	EMsgComposer *composer;
+	char *subject;
+	
+	g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);
+	g_return_val_if_fail (to == NULL || CAMEL_IS_INTERNET_ADDRESS (to), NULL);
+	g_return_val_if_fail (cc == NULL || CAMEL_IS_INTERNET_ADDRESS (cc), NULL);
+	
+	composer = e_msg_composer_new ();
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) composer, parent);
+	
+	/* construct the tov/ccv */
+	tov = em_utils_camel_address_to_destination (to);
+	ccv = em_utils_camel_address_to_destination (cc);
+	
+	/* Set the subject of the new message. */
+	if ((subject = (char *) camel_mime_message_get_subject (message))) {
+		if (strncasecmp (subject, "Re: ", 4) != 0)
+			subject = g_strdup_printf ("Re: %s", subject);
+		else
+			subject = g_strdup (subject);
+	} else {
+		subject = g_strdup ("");
+	}
+	
+	e_msg_composer_set_headers (composer, account ? account->name : NULL, tov, ccv, NULL, subject);
+	
+	g_free (subject);
+	
+	/* Add In-Reply-To and References. */
+	message_id = camel_medium_get_header (CAMEL_MEDIUM (message), "Message-Id");
+	references = camel_medium_get_header (CAMEL_MEDIUM (message), "References");
+	if (message_id) {
+		char *reply_refs;
+		
+		e_msg_composer_add_header (composer, "In-Reply-To", message_id);
+		
+		if (references)
+			reply_refs = g_strdup_printf ("%s %s", references, message_id);
+		else
+			reply_refs = g_strdup (message_id);
+		
+		e_msg_composer_add_header (composer, "References", reply_refs);
+		g_free (reply_refs);
+	} else if (references) {
+		e_msg_composer_add_header (composer, "References", references);
+	}
+	
+	e_msg_composer_drop_editor_undo (composer);
+	
+	return composer;
+}
+
+static EAccount *
+guess_account (CamelMimeMessage *message)
+{
+	const CamelInternetAddress *to, *cc;
+	GHashTable *account_hash;
+	EAccount *account = NULL;
+	const char *addr;
+	int i;
+	
+	to = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_TO);
+	cc = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_CC);
+	
+	if (to == NULL && cc == NULL)
+		return NULL;
+	
+	account_hash = generate_account_hash ();
+	
+	if (to) {
+		for (i = 0; camel_internet_address_get (to, i, NULL, &addr); i++) {
+			account = g_hash_table_lookup (account_hash, addr);
+			if (account)
+				goto found;
+		}
+	}
+	
+	if (cc) {
+		for (i = 0; camel_internet_address_get (cc, i, NULL, &addr); i++) {
+			account = g_hash_table_lookup (account_hash, addr);
+			if (account)
+				goto found;
+		}
+	}
+	
+ found:
+	
+	g_hash_table_destroy (account_hash);
+	
+	return account;
+}
+
+static void
+get_reply_sender (CamelMimeMessage *message, CamelInternetAddress **to)
+{
+	const CamelInternetAddress *reply_to;
+	const char *name, *addr;
+	int i;
+	
+	reply_to = camel_mime_message_get_reply_to (message);
+	if (!reply_to)
+		reply_to = camel_mime_message_get_from (message);
+	
+	if (reply_to) {
+		*to = camel_internet_address_new ();
+		
+		for (i = 0; camel_internet_address_get (reply_to, i, &name, &addr); i++)
+			camel_internet_address_add (*to, name, addr);
+	}
+}
+
+static gboolean
+get_reply_list (CamelMimeMessage *message, CamelInternetAddress **to)
+{
+	const char *header, *p;
+	char *addr;
+	
+	/* Examples:
+	 * 
+	 * List-Post: <mailto:list@host.com>
+	 * List-Post: <mailto:moderator@host.com?subject=list%20posting>
+	 * List-Post: NO (posting not allowed on this list)
+	 */
+	if (!(header = camel_medium_get_header ((CamelMedium *) message, "List-Post")))
+		return FALSE;
+	
+	while (*header == ' ' || *header == '\t')
+		header++;
+	
+	/* check for NO */
+	if (!strncasecmp (header, "NO", 2))
+		return FALSE;
+	
+	/* Search for the first mailto angle-bracket enclosed URL.
+	 * (See rfc2369, Section 2, paragraph 3 for details) */
+	if (!(header = camel_strstrcase (header, "<mailto:")))
+		return FALSE;
+	
+	header += 8;
+	
+	p = header;
+	while (*p && !strchr ("?>", *p))
+		p++;
+	
+	addr = g_strndup (header, p - header);
+	
+	*to = camel_internet_address_new ();
+	camel_internet_address_add (*to, NULL, addr);
+	
+	g_free (addr);
+	
+	return TRUE;
+}
+
+static void
+concat_unique_addrs (CamelInternetAddress *dest, const CamelInternetAddress *src, GHashTable *rcpt_hash)
+{
+	const char *name, *addr;
+	int i;
+	
+	for (i = 0; camel_internet_address_get (src, i, &name, &addr); i++) {
+		if (!g_hash_table_lookup (rcpt_hash, addr)) {
+			camel_internet_address_add (dest, name, addr);
+			g_hash_table_insert (rcpt_hash, (char *) addr, GINT_TO_POINTER (1));
+		}
+	}
+}
+
+static void
+get_reply_all (CamelMimeMessage *message, CamelInternetAddress **to, CamelInternetAddress **cc)
+{
+	const CamelInternetAddress *reply_to, *to_addrs, *cc_addrs;
+	const char *name, *addr;
+	GHashTable *rcpt_hash;
+	int i;
+	
+	rcpt_hash = generate_account_hash ();
+	
+	reply_to = camel_mime_message_get_reply_to (message);
+	if (!reply_to)
+		reply_to = camel_mime_message_get_from (message);
+	
+	to_addrs = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_TO);
+	cc_addrs = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_CC);
+	
+	*to = camel_internet_address_new ();
+	*cc = camel_internet_address_new ();
+	
+	if (reply_to) {
+		for (i = 0; camel_internet_address_get (reply_to, i, &name, &addr); i++) {
+			/* ignore references to the Reply-To address in the To and Cc lists */
+			if (addr && !g_hash_table_lookup (rcpt_hash, addr)) {
+				/* In the case that we are doing a Reply-To-All, we do not want
+				   to include the user's email address because replying to oneself
+				   is kinda silly. */
+				
+				camel_internet_address_add (*to, name, addr);
+				g_hash_table_insert (rcpt_hash, (char *) addr, GINT_TO_POINTER (1));
+			}
+		}
+	}
+	
+	concat_unique_addrs (*cc, to_addrs, rcpt_hash);
+	concat_unique_addrs (*cc, cc_addrs, rcpt_hash);
+	
+	/* promote the first Cc: address to To: if To: is empty */
+	if (camel_address_length ((CamelAddress *) *to) == 0 && camel_address_length ((CamelAddress *) *cc) > 0) {
+		camel_internet_address_get (*cc, 0, &name, &addr);
+		camel_internet_address_add (*to, name, addr);
+		camel_address_remove ((CamelAddress *) *cc, 0);
+	}
+	
+	g_hash_table_destroy (rcpt_hash);
+}
+
+static void
+composer_set_body (EMsgComposer *composer, CamelMimeMessage *message)
+{
+	const CamelInternetAddress *sender;
+	char *text, *credits, format[256];
+	const char *name, *addr;
+	CamelMimePart *part;
+	GConfClient *gconf;
+	time_t date;
+	int date_offset;
+	
+	gconf = mail_config_get_gconf_client ();
+	
+	switch (gconf_client_get_int (gconf, "/apps/evolution/mail/format/reply_style", NULL)) {
+	case MAIL_CONFIG_REPLY_DO_NOT_QUOTE:
+		/* do nothing */
+		break;
+	case MAIL_CONFIG_REPLY_ATTACH:
+		/* attach the original message as an attachment */
+		part = mail_tool_make_message_attachment (message);
+		e_msg_composer_attach (composer, part);
+		camel_object_unref (part);
+		break;
+	case MAIL_CONFIG_REPLY_QUOTED:
+	default:
+		/* do what any sane user would want when replying... */
+		sender = camel_mime_message_get_from (message);
+		if (sender != NULL && camel_address_length (CAMEL_ADDRESS (sender)) > 0) {
+			camel_internet_address_get (sender, 0, &name, &addr);
+		} else {
+			name = _("an unknown sender");
+		}
+
+		date = camel_mime_message_get_date(message, &date_offset);
+		/* Convert to UTC */
+		date += (date_offset / 100) * 60 * 60;
+		date += (date_offset % 100) * 60;
+
+		/* translators: attribution string used when quoting messages,
+		   it must contain a single single %%+05d followed by a single '%%s' */
+		e_utf8_strftime(format, sizeof(format), _("On %a, %Y-%m-%d at %H:%M %%+05d, %%s wrote:"), gmtime(&date));
+		credits = g_strdup_printf(format, date_offset, name && *name ? name : addr);
+		text = em_utils_message_to_html(message, credits, EM_FORMAT_QUOTE_CITE);
+		g_free (credits);
+		e_msg_composer_set_body_text(composer, text);
+		g_free (text);
+		break;
+	}
+	
+	e_msg_composer_drop_editor_undo (composer);
+}
+
+/**
+ * em_utils_reply_to_message:
+ * @parent: parent window
+ * @message: message to reply to
+ * @mode: reply mode
+ *
+ * Creates a new composer ready to reply to @message.
+ **/
+void
+em_utils_reply_to_message (GtkWidget *parent, CamelMimeMessage *message, int mode)
+{
+	CamelInternetAddress *to = NULL, *cc = NULL;
+	EMsgComposer *composer;
+	EAccount *account;
+	
+	account = guess_account (message);
+	
+	switch (mode) {
+	case REPLY_MODE_SENDER:
+		get_reply_sender (message, &to);
+		break;
+	case REPLY_MODE_LIST:
+		if (get_reply_list (message, &to))
+			break;
+	case REPLY_MODE_ALL:
+		get_reply_all (message, &to, &cc);
+		break;
+	}
+	
+	composer = reply_get_composer (parent, message, account, to, cc);
+	e_msg_composer_add_message_attachments (composer, message, TRUE);
+	
+	if (to != NULL)
+		camel_object_unref (to);
+	
+	if (cc != NULL)
+		camel_object_unref (cc);
+	
+	composer_set_body (composer, message);
+	
+	em_composer_utils_setup_default_callbacks (composer);
+	
+	gtk_widget_show (GTK_WIDGET (composer));
+	e_msg_composer_unset_changed (composer);
+}
+
+struct rtm_t {
+	GtkWidget *parent;
+	int mode;
+};
+
+static void
+reply_to_message (CamelFolder *folder, const char *uid, CamelMimeMessage *message, void *user_data)
+{
+	CamelInternetAddress *to = NULL, *cc = NULL;
+	struct rtm_t *rtm = user_data;
+	EMsgComposer *composer;
+	EAccount *account;
+	guint32 flags;
+	
+	account = guess_account (message);
+	flags = CAMEL_MESSAGE_ANSWERED | CAMEL_MESSAGE_SEEN;
+	
+	switch (rtm->mode) {
+	case REPLY_MODE_SENDER:
+		get_reply_sender (message, &to);
+		break;
+	case REPLY_MODE_LIST:
+		flags |= CAMEL_MESSAGE_ANSWERED_ALL;
+		if (get_reply_list (message, &to))
+			break;
+	case REPLY_MODE_ALL:
+		flags |= CAMEL_MESSAGE_ANSWERED_ALL;
+		get_reply_all (message, &to, &cc);
+		break;
+	}
+	
+	composer = reply_get_composer (rtm->parent, message, account, to, cc);
+	e_msg_composer_add_message_attachments (composer, message, TRUE);
+	
+	if (to != NULL)
+		camel_object_unref (to);
+	
+	if (cc != NULL)
+		camel_object_unref (cc);
+	
+	composer_set_body (composer, message);
+	
+	em_composer_utils_setup_callbacks (composer, folder, uid, flags, flags, NULL, NULL);
+	
+	gtk_widget_show (GTK_WIDGET (composer));
+	e_msg_composer_unset_changed (composer);
+}
+
+/**
+ * em_utils_reply_to_message_by_uid:
+ * @parent: parent window
+ * @folder: folder containing message to reply to
+ * @uid: message uid
+ * @mode: reply mode
+ *
+ * Creates a new composer ready to reply to the message referenced by
+ * @folder and @uid.
+ **/
+void
+em_utils_reply_to_message_by_uid (GtkWidget *parent, CamelFolder *folder, const char *uid, int mode)
+{
+	struct rtm_t *rtm;
+	
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uid != NULL);
+	
+	rtm = g_malloc (sizeof (struct rtm_t));
+	rtm->parent = parent;
+	rtm->mode = mode;
+	
+	mail_get_message (folder, uid, reply_to_message, rtm, mail_thread_new);
+}
+
+/* Posting replies... */
+
+static void
+post_reply_to_message (CamelFolder *folder, const char *uid, CamelMimeMessage *message, void *user_data)
+{
+	/* FIXME: would be nice if this shared more code with reply_get_composer() */
+	const char *message_id, *references;
+	CamelInternetAddress *to = NULL;
+	GtkWidget *parent = user_data;
+	EDestination **tov = NULL;
+	EMsgComposer *composer;
+	char *subject, *url;
+	EAccount *account;
+	guint32 flags;
+	
+	account = guess_account (message);
+	flags = CAMEL_MESSAGE_ANSWERED | CAMEL_MESSAGE_SEEN;
+	
+	get_reply_sender (message, &to);
+	
+	composer = e_msg_composer_new_post ();
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) composer, parent);
+	
+	/* construct the tov/ccv */
+	tov = em_utils_camel_address_to_destination (to);
+	
+	/* Set the subject of the new message. */
+	if ((subject = (char *) camel_mime_message_get_subject (message))) {
+		if (strncasecmp (subject, "Re: ", 4) != 0)
+			subject = g_strdup_printf ("Re: %s", subject);
+		else
+			subject = g_strdup (subject);
+	} else {
+		subject = g_strdup ("");
+	}
+	
+	e_msg_composer_set_headers (composer, account ? account->name : NULL, tov, NULL, NULL, subject);
+	
+	g_free (subject);
+	
+	url = mail_tools_folder_to_url (folder);
+	e_msg_composer_hdrs_set_post_to ((EMsgComposerHdrs *) composer->hdrs, url);
+	g_free (url);
+	
+	/* Add In-Reply-To and References. */
+	message_id = camel_medium_get_header (CAMEL_MEDIUM (message), "Message-Id");
+	references = camel_medium_get_header (CAMEL_MEDIUM (message), "References");
+	if (message_id) {
+		char *reply_refs;
+		
+		e_msg_composer_add_header (composer, "In-Reply-To", message_id);
+		
+		if (references)
+			reply_refs = g_strdup_printf ("%s %s", references, message_id);
+		else
+			reply_refs = g_strdup (message_id);
+		
+		e_msg_composer_add_header (composer, "References", reply_refs);
+		g_free (reply_refs);
+	} else if (references) {
+		e_msg_composer_add_header (composer, "References", references);
+	}
+	
+	e_msg_composer_drop_editor_undo (composer);
+	
+	e_msg_composer_add_message_attachments (composer, message, TRUE);
+	
+	if (to != NULL)
+		camel_object_unref (to);
+	
+	composer_set_body (composer, message);
+	
+	em_composer_utils_setup_callbacks (composer, folder, uid, flags, flags, NULL, NULL);
+	
+	gtk_widget_show (GTK_WIDGET (composer));	
+	e_msg_composer_unset_changed (composer);
+}
+
+/**
+ * em_utils_post_reply_to_message_by_uid:
+ * @parent: parent window
+ * @folder: folder containing message to reply to
+ * @uid: message uid
+ * @mode: reply mode
+ *
+ * Creates a new composer (post mode) ready to reply to the message
+ * referenced by @folder and @uid.
+ **/
+void
+em_utils_post_reply_to_message_by_uid (GtkWidget *parent, CamelFolder *folder, const char *uid)
+{
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uid != NULL);
+	
+	mail_get_message (folder, uid, post_reply_to_message, parent, mail_thread_new);
+}
+
+/* Saving messages... */
+
+static GtkFileSelection *
+emu_get_save_filesel(GtkWidget *parent, const char *title, const char *name)
+{
+	GtkFileSelection *filesel;
+	char *gdir, *mname = NULL, *filename;
+	const char *realname, *dir;
+	GConfClient *gconf;
+
+	filesel = (GtkFileSelection *)gtk_file_selection_new(title);
+	if (parent)
+		e_dialog_set_transient_for((GtkWindow *)filesel, parent);
+
+	gconf = gconf_client_get_default();
+	dir = gdir = gconf_client_get_string(gconf, "/apps/evolution/mail/save_dir", NULL);
+	g_object_unref(gconf);
+	if (dir == NULL)
+		dir = g_get_home_dir();
+
+	if (name && name[0]) {
+		realname = mname = g_strdup(name);
+		e_filename_make_safe(mname);
+	} else {
+		realname = "/";
+	}
+
+	filename = g_build_filename(dir, realname, NULL);
+	gtk_file_selection_set_filename(filesel, filename);
+	g_free(filename);
+	g_free(mname);
+	g_free (gdir);
+
+	return filesel;
+}
+
+static void
+emu_update_save_path(const char *filename)
+{
+	char *dir = g_path_get_dirname(filename);
+	GConfClient *gconf = gconf_client_get_default();
+
+	gconf_client_set_string(gconf, "/apps/evolution/mail/save_dir", dir, NULL);
+	g_object_unref(gconf);
+	g_free(dir);
+}
+
+static gboolean
+emu_can_save(GtkWindow *parent, const char *path)
+{
+	struct stat st;
+	
+	if (path[0] == 0)
+		return FALSE;
+
+	/* make sure we can actually save to it... */
+	if (stat (path, &st) != -1 && !S_ISREG (st.st_mode))
+		return FALSE;
+	
+	if (access (path, F_OK) == 0) {
+		if (access (path, W_OK) != 0) {
+			e_notice (parent, GTK_MESSAGE_ERROR,
+				 _("Cannot save to `%s'\n %s"), path, g_strerror (errno));
+			return FALSE;
+		}
+		
+		return em_utils_prompt_user (parent, GTK_RESPONSE_NO, NULL,
+					     _("`%s' already exists.\nOverwrite it?"), path);
+	}
+	
+	return TRUE;
+}
+
+static void
+emu_save_part_response(GtkFileSelection *filesel, int response, CamelMimePart *part)
+{
+	if (response == GTK_RESPONSE_OK) {
+		const char *path = gtk_file_selection_get_filename(filesel);
+
+		if (!emu_can_save((GtkWindow *)filesel, path))
+			return;
+
+		emu_update_save_path(path);
+		/* FIXME: popup error if it fails? */
+		mail_save_part(part, path, NULL, NULL);
+	}
+
+	gtk_widget_destroy((GtkWidget *)filesel);
+	camel_object_unref(part);
+}
+
+/**
+ * em_utils_save_part:
+ * @parent: parent window
+ * @prompt: prompt string
+ * @part: part to save
+ *
+ * Saves a mime part to disk (prompting the user for filename).
+ **/
+void
+em_utils_save_part(GtkWidget *parent, const char *prompt, CamelMimePart *part)
+{
+	const char *name;
+	GtkFileSelection *filesel;
+
+	name = camel_mime_part_get_filename(part);
+	if (name == NULL) {
+		if (CAMEL_IS_MIME_MESSAGE(part)) {
+			name = camel_mime_message_get_subject((CamelMimeMessage *)part);
+			if (name == NULL)
+				name = _("message");
+		} else {
+			name = _("attachment");
+		}
+	}
+
+	filesel = emu_get_save_filesel(parent, prompt, name);
+	camel_object_ref(part);
+	g_signal_connect(filesel, "response", G_CALLBACK(emu_save_part_response), part);
+	gtk_widget_show((GtkWidget *)filesel);
+}
+
+
+struct _save_messages_data {
+	CamelFolder *folder;
+	GPtrArray *uids;
+};
+
+static void
+emu_save_messages_response(GtkFileSelection *filesel, int response, struct _save_messages_data *data)
+{
+	if (response == GTK_RESPONSE_OK) {
+		const char *path = gtk_file_selection_get_filename(filesel);
+
+		if (!emu_can_save((GtkWindow *)filesel, path))
+			return;
+
+		emu_update_save_path(path);
+		mail_save_messages(data->folder, data->uids, path, NULL, NULL);
+		data->uids = NULL;
+	}
+
+	camel_object_unref(data->folder);
+	if (data->uids)
+		em_utils_uids_free(data->uids);
+	g_free(data);
+	gtk_widget_destroy((GtkWidget *)filesel);
+}
+
+/**
+ * em_utils_save_messages:
+ * @parent: parent window
+ * @folder: folder containing messages to save
+ * @uids: uids of messages to save
+ *
+ * Saves a group of messages to disk in mbox format (prompting the
+ * user for filename).
+ **/
+void
+em_utils_save_messages (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	struct _save_messages_data *data;
+	GtkFileSelection *filesel;
+
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+
+	filesel = emu_get_save_filesel(parent, _("Save Message..."), NULL);
+	camel_object_ref(folder);
+	
+	data = g_malloc(sizeof(struct _save_messages_data));
+	data->folder = folder;
+	data->uids = uids;
+
+	g_signal_connect(filesel, "response", G_CALLBACK(emu_save_messages_response), data);
+	gtk_widget_show((GtkWidget *)filesel);
+}
+
+/* Flag-for-Followup... */
+
+/* tag-editor callback data */
+struct ted_t {
+	MessageTagEditor *editor;
+	CamelFolder *folder;
+	GPtrArray *uids;
+};
+
+static void
+ted_free (struct ted_t *ted)
+{
+	camel_object_unref (ted->folder);
+	em_utils_uids_free (ted->uids);
+	g_free (ted);
+}
+
+static void
+tag_editor_response (GtkWidget *dialog, int button, struct ted_t *ted)
+{
+	CamelFolder *folder;
+	CamelTag *tags, *t;
+	GPtrArray *uids;
+	int i;
+	
+	if (button == GTK_RESPONSE_OK && (tags = message_tag_editor_get_tag_list (ted->editor))) {
+		folder = ted->folder;
+		uids = ted->uids;
+		
+		camel_folder_freeze (folder);
+		for (i = 0; i < uids->len; i++) {
+			for (t = tags; t; t = t->next)
+				camel_folder_set_message_user_tag (folder, uids->pdata[i], t->name, t->value);
+		}
+		
+		camel_folder_thaw (folder);
+		camel_tag_list_free (&tags);
+	}
+	
+	gtk_widget_destroy (dialog);
+}
+
+/**
+ * em_utils_flag_for_followup:
+ * @parent: parent window
+ * @folder: folder containing messages to flag
+ * @uids: uids of messages to flag
+ *
+ * Open the Flag-for-Followup editor for the messages specified by
+ * @folder and @uids.
+ **/
+void
+em_utils_flag_for_followup (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	GtkWidget *editor;
+	struct ted_t *ted;
+	int i;
+	
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+	
+	editor = (GtkWidget *) message_tag_followup_new ();
+	
+	if (parent != NULL)
+		e_dialog_set_transient_for ((GtkWindow *) editor, parent);
+	
+	camel_object_ref (folder);
+	
+	ted = g_new (struct ted_t, 1);
+	ted->editor = MESSAGE_TAG_EDITOR (editor);
+	ted->folder = folder;
+	ted->uids = uids;
+	
+	for (i = 0; i < uids->len; i++) {
+		CamelMessageInfo *info;
+		
+		info = camel_folder_get_message_info (folder, uids->pdata[i]);
+		message_tag_followup_append_message (MESSAGE_TAG_FOLLOWUP (editor),
+						     camel_message_info_from (info),
+						     camel_message_info_subject (info));
+	}
+	
+	/* special-case... */
+	if (uids->len == 1) {
+		CamelMessageInfo *info;
+		
+		info = camel_folder_get_message_info (folder, uids->pdata[0]);
+		if (info) {
+			if (info->user_tags)
+				message_tag_editor_set_tag_list (MESSAGE_TAG_EDITOR (editor), info->user_tags);
+			camel_folder_free_message_info (folder, info);
+		}
+	}
+	
+	g_signal_connect (editor, "response", G_CALLBACK (tag_editor_response), ted);
+	g_object_weak_ref ((GObject *) editor, (GWeakNotify) ted_free, ted);
+	
+	gtk_widget_show (editor);
+}
+
+/**
+ * em_utils_flag_for_followup_clear:
+ * @parent: parent window
+ * @folder: folder containing messages to unflag
+ * @uids: uids of messages to unflag
+ *
+ * Clears the Flag-for-Followup flag on the messages referenced by
+ * @folder and @uids.
+ **/
+void
+em_utils_flag_for_followup_clear (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	int i;
+	
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+	
+	camel_folder_freeze (folder);
+	for (i = 0; i < uids->len; i++) {
+		camel_folder_set_message_user_tag (folder, uids->pdata[i], "follow-up", "");
+		camel_folder_set_message_user_tag (folder, uids->pdata[i], "due-by", "");
+		camel_folder_set_message_user_tag (folder, uids->pdata[i], "completed-on", "");
+	}
+	camel_folder_thaw (folder);
+	
+	em_utils_uids_free (uids);
+}
+
+/**
+ * em_utils_flag_for_followup_completed:
+ * @parent: parent window
+ * @folder: folder containing messages to 'complete'
+ * @uids: uids of messages to 'complete'
+ *
+ * Sets the completed state (and date/time) for each message
+ * referenced by @folder and @uids that is marked for
+ * Flag-for-Followup.
+ **/
+void
+em_utils_flag_for_followup_completed (GtkWidget *parent, CamelFolder *folder, GPtrArray *uids)
+{
+	char *now;
+	int i;
+	
+	g_return_if_fail (CAMEL_IS_FOLDER (folder));
+	g_return_if_fail (uids != NULL);
+	
+	now = header_format_date (time (NULL), 0);
+	
+	camel_folder_freeze (folder);
+	for (i = 0; i < uids->len; i++) {
+		const char *tag;
+		
+		tag = camel_folder_get_message_user_tag (folder, uids->pdata[i], "follow-up");
+		if (tag == NULL || *tag == '\0')
+			continue;
+		
+		camel_folder_set_message_user_tag (folder, uids->pdata[i], "completed-on", now);
+	}
+	camel_folder_thaw (folder);
+	
+	g_free (now);
+	
+	em_utils_uids_free (uids);
+}
+
+#include "camel/camel-stream-mem.h"
+#include "camel/camel-stream-filter.h"
+#include "camel/camel-mime-filter-from.h"
+
+/* This kind of sucks, because for various reasons most callers need to run synchronously
+   in the gui thread, however this could take a long, blocking time, to run */
+static int
+em_utils_write_messages_to_stream(CamelFolder *folder, GPtrArray *uids, CamelStream *stream)
+{
+	CamelStreamFilter *filtered_stream;
+	CamelMimeFilterFrom *from_filter;
+	int i, res = 0;
+
+	from_filter = camel_mime_filter_from_new();
+	filtered_stream = camel_stream_filter_new_with_stream(stream);
+	camel_stream_filter_add(filtered_stream, (CamelMimeFilter *)from_filter);
+	camel_object_unref(from_filter);
+	
+	for (i=0; i<uids->len; i++) {
+		CamelMimeMessage *message;
+		char *from;
+
+		message = camel_folder_get_message(folder, uids->pdata[i], NULL);
+		if (message == NULL) {
+			res = -1;
+			break;
+		}
+
+		/* we need to flush after each stream write since we are writing to the same stream */
+		from = camel_mime_message_build_mbox_from(message);
+
+		if (camel_stream_write_string(stream, from) == -1
+		    || camel_stream_flush(stream) == -1
+		    || camel_data_wrapper_write_to_stream((CamelDataWrapper *)message, (CamelStream *)filtered_stream) == -1
+		    || camel_stream_flush((CamelStream *)filtered_stream) == -1)
+			res = -1;
+		
+		g_free(from);
+		camel_object_unref(message);
+
+		if (res == -1)
+			break;
+	}
+
+	camel_object_unref(filtered_stream);
+
+	return res;
+}
+
+/* This kind of sucks, because for various reasons most callers need to run synchronously
+   in the gui thread, however this could take a long, blocking time, to run */
+static int
+em_utils_read_messages_from_stream(CamelFolder *folder, CamelStream *stream)
+{
+	CamelException *ex = camel_exception_new();
+	CamelMimeParser *mp = camel_mime_parser_new();
+	int res = -1;
+
+	camel_mime_parser_scan_from(mp, TRUE);
+	camel_mime_parser_init_with_stream(mp, stream);
+	camel_object_unref(stream);
+
+	while (camel_mime_parser_step(mp, 0, 0) == HSCAN_FROM) {
+		CamelMimeMessage *msg;
+
+		/* NB: de-from filter, once written */
+		msg = camel_mime_message_new();
+		if (camel_mime_part_construct_from_parser((CamelMimePart *)msg, mp) == -1) {
+			camel_object_unref(msg);
+			break;
+		}
+		
+		camel_folder_append_message(folder, msg, NULL, NULL, ex);
+		camel_object_unref(msg);
+		
+		if (camel_exception_is_set (ex))
+			break;
+		
+		camel_mime_parser_step(mp, 0, 0);
+	}
+	
+	camel_object_unref(mp);
+	if (!camel_exception_is_set(ex))
+		res = 0;
+	camel_exception_free(ex);
+
+	return res;
+}
+
+/**
+ * em_utils_selection_set_mailbox:
+ * @data: selection data
+ * @folder: folder containign messages to copy into the selection
+ * @uids: uids of the messages to copy into the selection
+ * 
+ * Creates a mailbox-format selection.
+ * Warning: Could be BIG!
+ * Warning: This could block the ui for an extended period.
+ **/
+void
+em_utils_selection_set_mailbox(GtkSelectionData *data, CamelFolder *folder, GPtrArray *uids)
+{
+	CamelStream *stream;
+
+	stream = camel_stream_mem_new();
+	if (em_utils_write_messages_to_stream(folder, uids, stream) == 0)
+		gtk_selection_data_set(data, data->target, 8,
+				       ((CamelStreamMem *)stream)->buffer->data,
+				       ((CamelStreamMem *)stream)->buffer->len);
+
+	camel_object_unref(stream);
+}
+
+/**
+ * em_utils_selection_get_mailbox:
+ * @data: selection data
+ * @folder: 
+ * 
+ * Receive a mailbox selection/dnd
+ * Warning: Could be BIG!
+ * Warning: This could block the ui for an extended period.
+ * FIXME: Exceptions?
+ **/
+void
+em_utils_selection_get_mailbox(GtkSelectionData *data, CamelFolder *folder)
+{
+	CamelStream *stream;
+
+	if (data->data == NULL || data->length == -1)
+		return;
+
+	/* TODO: a stream mem with read-only access to existing data? */
+	/* NB: Although copying would let us run this async ... which it should */
+	stream = camel_stream_mem_new_with_buffer(data->data, data->length);
+	em_utils_read_messages_from_stream(folder, stream);
+	camel_object_unref(stream);
+}
+
+/**
+ * em_utils_selection_set_uidlist:
+ * @data: selection data
+ * @uri:
+ * @uids: 
+ * 
+ * Sets a "x-evolution-message" format selection data.
+ *
+ * FIXME: be nice if this could take a folder argument rather than uri
+ **/
+void
+em_utils_selection_set_uidlist(GtkSelectionData *data, const char *uri, GPtrArray *uids)
+{
+	GByteArray *array = g_byte_array_new();
+	int i;
+
+	/* format: "uri\0uid1\0uid2\0uid3\0...\0uidn\0" */
+	/* NB: original form missed trailing \0 */
+
+	g_byte_array_append(array, uri, strlen(uri)+1);
+
+	for (i=0; i<uids->len; i++)
+		g_byte_array_append(array, uids->pdata[i], strlen(uids->pdata[i])+1);
+		
+	gtk_selection_data_set(data, data->target, 8, array->data, array->len);
+	g_byte_array_free(array, TRUE);
+}
+
+/**
+ * em_utils_selection_get_uidlist:
+ * @data: selection data
+ * @urip: Pointer to uri string, to be free'd by caller
+ * @uidsp: Pointer to an array of uid's.
+ * 
+ * Convert an x-evolution-message type to a uri and a uid list.
+ * 
+ * Return value: The number of uid's found.  If 0, then @urip and
+ * @uidsp will be empty.
+ **/
+int
+em_utils_selection_get_uidlist(GtkSelectionData *data, char **urip, GPtrArray **uidsp)
+{
+	/* format: "uri\0uid1\0uid2\0uid3\0...\0uidn" */
+	char *inptr, *inend;
+	GPtrArray *uids;
+	int res;
+
+	*urip = NULL;
+	*uidsp = NULL;
+
+	if (data == NULL || data->data == NULL || data->length == -1)
+		return 0;
+	
+	uids = g_ptr_array_new();
+
+	inptr = data->data;
+	inend = data->data + data->length;
+	while (inptr < inend) {
+		char *start = inptr;
+
+		while (inptr < inend && *inptr)
+			inptr++;
+
+		if (start > (char *)data->data)
+			g_ptr_array_add(uids, g_strndup(start, inptr-start));
+
+		inptr++;
+	}
+
+	if (uids->len == 0) {
+		g_ptr_array_free(uids, TRUE);
+		res = 0;
+	} else {
+		*urip = g_strdup(data->data);
+		*uidsp = uids;
+		res = uids->len;
+	}
+
+	return res;
+}
+
+/**
+ * em_utils_selection_set_urilist:
+ * @data: 
+ * @folder: 
+ * @uids: 
+ * 
+ * Set the selection data @data to a uri which points to a file, which is
+ * a berkely mailbox format mailbox.  The file is automatically cleaned
+ * up when the application quits.
+ **/
+void
+em_utils_selection_set_urilist(GtkSelectionData *data, CamelFolder *folder, GPtrArray *uids)
+{
+	const char *tmpdir;
+	CamelStream *fstream;
+	char *uri;
+	int fd;
+
+	tmpdir = e_mkdtemp("drag-n-drop-XXXXXX");
+	if (tmpdir == NULL)
+		return;
+
+	/* FIXME: this used to save a single message with the subject
+	   as the filename but it was unsafe, and makes this messier,
+	   the pain */
+
+	uri = alloca(strlen(tmpdir)+16);
+	sprintf(uri, "file:///%s/mbox", tmpdir);
+	
+	fd = open(uri + 7, O_WRONLY | O_CREAT | O_EXCL, 0666);
+	if (fd == -1)
+		return;
+		
+	fstream = camel_stream_fs_new_with_fd(fd);
+	if (fstream) {
+		if (em_utils_write_messages_to_stream(folder, uids, fstream) == 0)
+			gtk_selection_data_set(data, data->target, 8, uri, strlen(uri));
+
+		camel_object_unref(fstream);
+	}
+}
+
+static void
+emu_save_part_done(CamelMimePart *part, char *name, int done, void *data)
+{
+	((int *)data)[0] = done;
+}
+
+/**
+ * em_utils_temp_save_part:
+ * @parent: 
+ * @part: 
+ * 
+ * Save a part's content to a temporary file, and return the
+ * filename.
+ * 
+ * Return value: NULL if anything failed.
+ **/
+char *
+em_utils_temp_save_part(GtkWidget *parent, CamelMimePart *part)
+{
+	const char *tmpdir, *filename;
+	char *path, *mfilename = NULL;
+	int done;
+
+	tmpdir = e_mkdtemp("evolution-tmp-XXXXXX");
+	if (tmpdir == NULL) {
+		e_notice(parent, GTK_MESSAGE_ERROR,
+			 _("Could not create temporary directory: %s"),
+			 g_strerror (errno));
+
+		return NULL;
+	}
+
+	filename = camel_mime_part_get_filename (part);
+	if (filename == NULL) {
+		/* This is the default filename used for temporary file creation */
+		filename = _("Unknown");
+	} else {
+		mfilename = g_strdup(filename);
+		e_filename_make_safe(mfilename);
+		filename = mfilename;
+	}
+
+	path = g_build_filename(tmpdir, filename, NULL);
+	g_free(mfilename);
+
+	/* FIXME: This doesn't handle default charsets */
+	mail_msg_wait(mail_save_part(part, path, emu_save_part_done, &done));
+
+	if (!done) {
+		/* mail_save_part should popup an error box automagically */
+		g_free(path);
+		path = NULL;
+	}
+
+	return path;
+}
+
+extern CamelFolder *drafts_folder, *sent_folder, *outbox_folder;
+
+/**
+ * em_utils_folder_is_drafts:
+ * @folder: folder
+ * @uri: uri for this folder, if known
+ *
+ * Decides if @folder is a Drafts folder.
+ * 
+ * Returns %TRUE if this is a Drafts folder or %FALSE otherwise.
+ **/
+gboolean
+em_utils_folder_is_drafts(CamelFolder *folder, const char *uri)
+{
+	EAccountList *accounts;
+	EAccount *account;
+	EIterator *iter;
+	int is = FALSE;
+
+	if (folder == drafts_folder)
+		return TRUE;
+
+	if (uri == NULL)
+		return FALSE;
+
+	accounts = mail_config_get_accounts();
+	iter = e_list_get_iterator((EList *)accounts);
+	while (e_iterator_is_valid(iter)) {
+		account = (EAccount *)e_iterator_get(iter);
+		if (account->drafts_folder_uri &&
+		    camel_store_uri_cmp(folder->parent_store, account->drafts_folder_uri, uri)) {
+			is = TRUE;
+			break;
+		}
+		
+		e_iterator_next(iter);
+	}
+	
+	g_object_unref(iter);
+	
+	return is;
+}
+
+/**
+ * em_utils_folder_is_sent:
+ * @folder: folder
+ * @uri: uri for this folder, if known
+ *
+ * Decides if @folder is a Sent folder
+ * 
+ * Returns %TRUE if this is a Sent folder or %FALSE otherwise.
+ **/
+gboolean
+em_utils_folder_is_sent(CamelFolder *folder, const char *uri)
+{
+	EAccountList *accounts;
+	EAccount *account;
+	EIterator *iter;
+	int is = FALSE;
+
+	if (folder == sent_folder)
+		return TRUE;
+
+	if (uri == NULL)
+		return FALSE;
+
+	accounts = mail_config_get_accounts();
+	iter = e_list_get_iterator((EList *)accounts);
+	while (e_iterator_is_valid(iter)) {
+		account = (EAccount *)e_iterator_get(iter);
+		if (account->sent_folder_uri &&
+		    camel_store_uri_cmp(folder->parent_store, account->sent_folder_uri, uri)) {
+			is = TRUE;
+			break;
+		}
+		
+		e_iterator_next(iter);
+	}
+	
+	g_object_unref(iter);
+	
+	return is;
+}
+
+/**
+ * em_utils_folder_is_outbox:
+ * @folder: folder
+ * @uri: uri for this folder, if known
+ *
+ * Decides if @folder is an Outbox folder
+ * 
+ * Returns %TRUE if this is an Outbox folder or %FALSE otherwise.
+ **/
+gboolean
+em_utils_folder_is_outbox(CamelFolder *folder, const char *uri)
+{
+	/* <Highlander>There can be only one.</Highlander> */
+	return folder == outbox_folder;
+}
+
+/**
+ * em_utils_adjustment_page:
+ * @adj: 
+ * @down: 
+ * 
+ * Move an adjustment up/down forward/back one page.
+ **/
+void
+em_utils_adjustment_page(GtkAdjustment *adj, gboolean down)
+{
+	float page_size = adj->page_size - adj->step_increment;
+
+	if (down) {
+		if (adj->value < adj->upper - adj->page_size - page_size)
+			adj->value += page_size;
+		else if (adj->upper >= adj->page_size)
+			adj->value = adj->upper - adj->page_size;
+		else
+			adj->value = adj->lower;
+	} else {
+		if (adj->value > adj->lower + page_size)
+			adj->value -= page_size;
+		else
+			adj->value = adj->lower;
+	}
+
+	gtk_adjustment_value_changed(adj);
+}
+
+/* ********************************************************************** */
+static char *emu_proxy_uri;
+
+static void
+emu_set_proxy(GConfClient *client)
+{
+	char *server;
+	int port;
+
+	if (!gconf_client_get_bool(client, "/system/http_proxy/use_http_proxy", NULL)) {
+		g_free(emu_proxy_uri);
+		emu_proxy_uri = NULL;
+
+		return;
+	}
+
+	/* TODO: Should lock ... */
+
+	server = gconf_client_get_string(client, "/system/http_proxy/host", NULL);
+	port = gconf_client_get_int(client, "/system/http_proxy/port", NULL);
+
+	if (server && server[0]) {
+		g_free(emu_proxy_uri);
+
+		if (gconf_client_get_bool(client, "/system/http_proxy/use_authentication", NULL)) {
+			char *user = gconf_client_get_string(client, "/system/http_proxy/authentication_user", NULL);
+			char *pass = gconf_client_get_string(client, "/system/http_proxy/authentication_password", NULL);
+
+			emu_proxy_uri = g_strdup_printf("http://%s:%s@%s:%d", user, pass, server, port);
+			g_free(user);
+			g_free(pass);
+		} else {
+			emu_proxy_uri = g_strdup_printf("http://%s:%d", server, port);
+		}
+	}
+
+	g_free(server);
+}
+
+static void
+emu_proxy_changed(GConfClient *client, guint32 cnxn_id, GConfEntry *entry, gpointer user_data)
+{
+	emu_set_proxy(client);
+}
+
+/**
+ * em_utils_get_proxy_uri:
+ * 
+ * Get the system proxy uri.
+ * 
+ * Return value: Must be freed when finished with.
+ **/
+char *
+em_utils_get_proxy_uri(void)
+{
+	static int init;
+
+	if (!init) {
+		GConfClient *client = gconf_client_get_default();
+
+		gconf_client_add_dir(client, "/system/http_proxy", GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
+		gconf_client_notify_add(client, "/system/http_proxy", emu_proxy_changed, NULL, NULL, NULL);
+		emu_set_proxy(client);
+		g_object_unref(client);
+		init = TRUE;
+	}
+
+	return g_strdup(emu_proxy_uri);
+}
+
+/**
+ * em_utils_part_to_html:
+ * @part:
+ *
+ * Converts a mime part's contents into html text.  If @credits is given,
+ * then it will be used as an attribution string, and the
+ * content will be cited.  Otherwise no citation or attribution
+ * will be performed.
+ * 
+ * Return Value: The part in displayable html format.
+ **/
+char *
+em_utils_part_to_html(CamelMimePart *part)
+{
+	EMFormatQuote *emfq;
+	CamelStreamMem *mem;
+	GByteArray *buf;
+	char *text;
+	
+	buf = g_byte_array_new ();
+	mem = (CamelStreamMem *) camel_stream_mem_new ();
+	camel_stream_mem_set_byte_array (mem, buf);
+	
+	emfq = em_format_quote_new(NULL, (CamelStream *)mem, 0);
+	em_format_part((EMFormat *) emfq, (CamelStream *) mem, part);
+	g_object_unref (emfq);
+	
+	camel_stream_write ((CamelStream *) mem, "", 1);
+	camel_object_unref (mem);
+	
+	text = buf->data;
+	g_byte_array_free (buf, FALSE);
+	
+	return text;
+}
+
+/**
+ * em_utils_message_to_html:
+ * @message: 
+ * @credits: 
+ * @flags: EMFormatQuote flags
+ *
+ * Convert a message to html, quoting if the @credits attribution
+ * string is given.
+ * 
+ * Return value: The html version.
+ **/
+char *
+em_utils_message_to_html(CamelMimeMessage *message, const char *credits, guint32 flags)
+{
+	EMFormatQuote *emfq;
+	CamelStreamMem *mem;
+	GByteArray *buf;
+	char *text;
+	
+	buf = g_byte_array_new ();
+	mem = (CamelStreamMem *) camel_stream_mem_new ();
+	camel_stream_mem_set_byte_array (mem, buf);
+	
+	emfq = em_format_quote_new(credits, (CamelStream *)mem, flags);
+	em_format_format((EMFormat *)emfq, (CamelMedium *)message);
+	g_object_unref (emfq);
+	
+	camel_stream_write ((CamelStream *) mem, "", 1);
+	camel_object_unref (mem);
+	
+	text = buf->data;
+	g_byte_array_free (buf, FALSE);
+	
+	return text;
+}
+
+/* ********************************************************************** */
+
+static gboolean
+emu_confirm_expunge (GtkWidget *parent)
+{
+	gboolean res, show_again;
+	GConfClient *gconf;
+	
+	gconf = mail_config_get_gconf_client ();
+	
+	if (!gconf_client_get_bool (gconf, "/apps/evolution/mail/prompts/expunge", NULL))
+		return TRUE;
+	
+	/* FIXME: we need to get the parent GtkWindow from @parent... */
+	
+	res = em_utils_prompt_user (NULL, GTK_RESPONSE_NO, &show_again,
+				    _("This operation will permanently erase all messages marked as\n"
+				      "deleted. If you continue, you will not be able to recover these messages.\n"
+				      "\nReally erase these messages?"));
+	
+	gconf_client_set_bool (gconf, "/apps/evolution/mail/prompts/expunge", show_again, NULL);
+	
+	return res;
+}
+
+/**
+ * em_utils_expunge_folder:
+ * @parent: parent window
+ * @folder: folder to expunge
+ *
+ * Expunges @folder.
+ **/
+void
+em_utils_expunge_folder (GtkWidget *parent, CamelFolder *folder)
+{
+	if (!emu_confirm_expunge(parent))
+		return;
+	
+	mail_expunge_folder(folder, NULL, NULL);
+}
+
+/**
+ * em_utils_empty_trash:
+ * @parent: parent window
+ *
+ * Empties all Trash folders.
+ **/
+void
+em_utils_empty_trash (GtkWidget *parent)
+{
+	extern CamelSession *session;
+	CamelProvider *provider;
+	EAccountList *accounts;
+	EAccount *account;
+	EIterator *iter;
+	CamelException ex;
+	
+	if (!emu_confirm_expunge (parent))
+		return;
+	
+	camel_exception_init (&ex);
+	
+	/* expunge all remote stores */
+	accounts = mail_config_get_accounts ();
+	iter = e_list_get_iterator ((EList *) accounts);
+	while (e_iterator_is_valid (iter)) {
+		account = (EAccount *) e_iterator_get (iter);
+		
+		/* make sure this is a valid source */
+		if (account->enabled && account->source->url) {
+			provider = camel_session_get_provider (session, account->source->url, &ex);
+			if (provider) {
+				/* make sure this store is a remote store */
+				if (provider->flags & CAMEL_PROVIDER_IS_STORAGE &&
+				    provider->flags & CAMEL_PROVIDER_IS_REMOTE) {
+					mail_empty_trash (account, NULL, NULL);
+				}
+			}
+			
+			/* clear the exception for the next round */
+			camel_exception_clear (&ex);
+		}
+		
+		e_iterator_next (iter);
+	}
+	
+	g_object_unref (iter);
+	
+	/* Now empty the local trash folder */
+	mail_empty_trash (NULL, NULL, NULL);
+}