Get the mail component to use the new Evolution::ShellView interface.

This implementation is so ugly and evil and needs to be replaced.
Don't look at it.  Go away.

svn path=/trunk/; revision=4797

1 files changed, 303 insertions, 535 deletions

diff --git a/mail/mail-threads.c b/mail/mail-threads.c
index ebf1e862ad..e1707eb3f3 100644
--- a/mail/mail-threads.c
+++ b/mail/mail-threads.c
@@ -26,19 +26,15 @@
 
 #include <string.h>
 #include <glib.h>
+
+#include "folder-browser-factory.h"
+
 #include "camel/camel-object.h"
 #include "mail.h"
 #include "mail-threads.h"
 
 #define DEBUG(p) g_print p
 
-/* FIXME TODO: Do we need operations that don't get a progress window because
- * they're quick, but we still want camel to be locked? We need some kind
- * of flag to mail_operation_queue, but then we also need some kind of monitor
- * to open the window if it takes more than a second or something. That would
- * probably entail another thread....
- */
-
 /**
  * A function and its userdata
  **/
@@ -63,15 +59,20 @@ typedef struct com_msg_s
 {
 	enum com_msg_type_e { 
 		STARTING, 
+
+#if 0
 		PERCENTAGE, 
 		HIDE_PBAR, 
 		SHOW_PBAR, 
+#endif
+
 		MESSAGE, 
 		PASSWORD,
 		ERROR, 
 		FORWARD_EVENT,
 		FINISHED
 	} type;
+
 	gfloat percentage;
 	gchar *message;
 
@@ -91,6 +92,18 @@ typedef struct com_msg_s
 com_msg_t;
 
 /**
+ * Stuff needed for blocking
+ **/
+
+typedef struct block_info_s {
+	GMutex *mutex;
+	GCond *cond;
+	gboolean val;
+} block_info_t;
+
+#define BLOCK_INFO_INIT { NULL, NULL, FALSE }
+
+/**
  * @dispatch_thread_started: gboolean that tells us whether
  * the dispatch thread has been launched.
  **/
@@ -110,31 +123,6 @@ static gboolean dispatch_thread_started = FALSE;
 static gint queue_len = 0;
 
 /**
- * @queue_window: The little window on the screen that
- * shows the progress of the current operation and the
- * operations that are queued to proceed after it.
- *
- * @queue_window_pending: The vbox that contains the
- * list of pending operations.
- *
- * @queue_window_message: The label that contains the
- * operation's message to the user
- **/
-
-static GtkWidget *queue_window = NULL;
-static GtkWidget *queue_window_pending = NULL;
-static GtkWidget *queue_window_message = NULL;
-static GtkWidget *queue_window_progress = NULL;
-
-/**
- * @progress_timeout_handle: the handle to our timer
- * function so that we can remove it when the progress bar
- * mode changes.
- **/
-
-static int progress_timeout_handle = -1;
-
-/**
  * @main_compipe: The pipe through which the dispatcher communicates
  * with the main thread for GTK+ calls
  *
@@ -155,59 +143,57 @@ static int dispatch_compipe[2] = { -1, -1 };
 GIOChannel *chan_reader = NULL;
 
 /**
- * @modal_cond: a condition maintained so that the
+ * @modal_block: a condition maintained so that the
  * calling thread (the dispatch thread) blocks correctly
  * until the user has responded to some kind of modal
  * dialog boxy thing.
- *
- * @modal_lock: a mutex for said condition
- *
- * @modal_may_proceed: a gboolean telling us whether
- * the dispatch thread may proceed its operations.
  */
 
-G_LOCK_DEFINE_STATIC (modal_lock);
-static GCond *modal_cond = NULL;
-static gboolean modal_may_proceed = FALSE;
+static block_info_t modal_block = BLOCK_INFO_INIT;
 
 /**
- * @ready_for_op: A lock that the main thread only releases
- * when it is ready for the dispatch thread to do its thing
- *
- * @ready_cond: A condition for this ... condition
- *
- * @ready_may_proceed: a gboolean telling the dispatch thread
- * when it may proceed.
+ * @finish_block: A condition so that the dispatch thread
+ * blocks until the main thread has finished the cleanup.
  **/
 
-G_LOCK_DEFINE_STATIC (ready_for_op);
-static GCond *ready_cond = NULL;
-static gboolean ready_may_proceed = FALSE;
+static block_info_t finish_block = BLOCK_INFO_INIT;
+
+/**
+ * @current_message: The current message for the status bar.
+ * @busy_status: Whether we are currently busy doing some async operation,
+ * for status bar purposes.
+ */
+
+static char *current_message = NULL;
+static gboolean busy = FALSE;
 
 /**
  * Static prototypes
  **/
 
-static void create_queue_window (void);
-static void destroy_queue_window (void);
+static void ui_set_busy (void);
+static void ui_unset_busy (void);
+static void ui_set_message (const char *message);
+static void ui_unset_message (void);
+
+static void block_prepare (block_info_t *info);
+static void block_wait (block_info_t *info);
+static void block_hold (block_info_t *info);
+static void block_release (block_info_t *info);
+
 static void *dispatch (void * data);
 static void check_dispatcher (void);
 static void check_compipes (void);
-static void check_cond (void);
 static gboolean read_msg (GIOChannel * source, GIOCondition condition,
 			  gpointer userdata);
-static void remove_next_pending (void);
+
 static void show_error (com_msg_t * msg);
-static void show_error_clicked (GtkObject * obj);
+
 static void get_password (com_msg_t * msg);
 static void get_password_cb (gchar * string, gpointer data);
-static void get_password_clicked (GnomeDialog * dialog, gint button,
-				  gpointer user_data);
-static void get_password_deleted (GtkWidget *widget, gpointer user_data);
 
-static gboolean progress_timeout (gpointer data);
-static void timeout_toggle (gboolean active);
-static gboolean display_timeout (gpointer data);
+static void cleanup_op (com_msg_t * msg);
+
 static closure_t *new_closure (const mail_operation_spec * spec, gpointer input,
 			       gboolean free_in_data);
 static void free_closure (closure_t *clur);
@@ -292,9 +278,11 @@ mail_operation_queue (const mail_operation_spec * spec, gpointer input,
 			g_free (msg);
 			gnome_dialog_set_close (GNOME_DIALOG (err_dialog),
 						TRUE);
-			/*gnome_dialog_run_and_close (GNOME_DIALOG (err_dialog));*/
+			GDK_THREADS_ENTER ();
+			gnome_dialog_run_and_close (GNOME_DIALOG (err_dialog));
+			GDK_THREADS_LEAVE ();
 			/*gtk_widget_destroy (err_dialog); */
-			gtk_widget_show (GTK_WIDGET (err_dialog));
+			/*gtk_widget_show (GTK_WIDGET (err_dialog));*/
 
 			g_warning ("Setup failed for `%s': %s",
 				   clur->infinitive,
@@ -307,37 +295,16 @@ mail_operation_queue (const mail_operation_spec * spec, gpointer input,
 	}
 
 	if (queue_len == 0) {
-		check_cond ();
 		check_compipes ();
 		check_dispatcher ();
-		create_queue_window ();
-		/*gtk_widget_show_all (queue_window); */
-		gtk_timeout_add (1000, display_timeout, NULL);
-	} else {
-		GtkWidget *label;
-
-		/* We already have an operation running. Well,
-		 * queue ourselves up. (visually)
-		 */
-
-		/* Show us in the pending window. */
-		label = gtk_label_new (clur->infinitive);
-		gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
-		gtk_box_pack_start (GTK_BOX (queue_window_pending), label,
-				    FALSE, TRUE, 2);
-		gtk_widget_show (label);
-
-		/* If we want the next op to be on the bottom, uncomment this */
-		/* 1 = first on list always (0-based) */
-		/* gtk_box_reorder_child( GTK_BOX( queue_window_pending ), label, 1 ); */
-		gtk_widget_show (queue_window_pending);
-	}
+	} /* else add self to queue */
 
 	write (DISPATCH_WRITER, clur, sizeof (closure_t));
 	queue_len++;
 	return TRUE;
 }
 
+#if 0
 /**
  * mail_op_set_percentage:
  * @percentage: the percentage that will be displayed in the progress bar
@@ -363,11 +330,6 @@ mail_op_set_percentage (gfloat percentage)
  * Threadsafe for, nay, intended to be called by, the dispatching thread.
  **/
 
-/* FIXME: I'd much rather have one of those Netscape-style progress
- * bars that just zips back and forth, but gtkprogressbar can't do
- * that, right? 
- */
-
 void
 mail_op_hide_progressbar (void)
 {
@@ -393,6 +355,8 @@ mail_op_show_progressbar (void)
 	write (MAIN_WRITER, &msg, sizeof (msg));
 }
 
+#endif
+
 /**
  * mail_op_set_message:
  * @fmt: printf-style format string for the message
@@ -443,17 +407,9 @@ mail_op_get_password (gchar * prompt, gboolean secret, gchar ** dest)
 
 	(*dest) = NULL;
 
-	G_LOCK (modal_lock);
-
+	block_prepare (&modal_block);
 	write (MAIN_WRITER, &msg, sizeof (msg));
-	modal_may_proceed = FALSE;
-
-	while (modal_may_proceed == FALSE)
-		g_cond_wait (modal_cond,
-			     g_static_mutex_get_mutex (&G_LOCK_NAME
-						       (modal_lock)));
-
-	G_UNLOCK (modal_lock);
+	block_wait (&modal_block);
 
 	return result;
 }
@@ -478,17 +434,9 @@ mail_op_error (gchar * fmt, ...)
 	msg.message = g_strdup_vprintf (fmt, val);
 	va_end (val);
 
-	G_LOCK (modal_lock);
-
-	modal_may_proceed = FALSE;
+	block_prepare (&modal_block);
 	write (MAIN_WRITER, &msg, sizeof (msg));
-
-	while (modal_may_proceed == FALSE)
-		g_cond_wait (modal_cond,
-			     g_static_mutex_get_mutex (&G_LOCK_NAME
-						       (modal_lock)));
-
-	G_UNLOCK (modal_lock);
+	block_wait (&modal_block);
 }
 
 /**
@@ -558,6 +506,14 @@ mail_operations_terminate (void)
 	write (DISPATCH_WRITER, &clur, sizeof (closure_t));
 }
 
+void
+mail_operations_get_status (int *busy_return,
+			    const char **message_return)
+{
+	*busy_return = busy;
+	*message_return = current_message;
+}
+
 /* ** Static functions **************************************************** */
 
 static void check_dispatcher (void)
@@ -583,117 +539,6 @@ static void check_dispatcher (void)
 		dispatch_thread_started = TRUE;
 }
 
-static void
-print_hide (GtkWidget * wid)
-{
-	g_message ("$$$ hide signal emitted");
-}
-
-static void
-print_unmap (GtkWidget * wid)
-{
-	g_message ("$$$ unmap signal emitted");
-}
-
-static void
-print_map (GtkWidget * wid)
-{
-	g_message ("$$$ map signal emitted");
-}
-
-static void
-print_show (GtkWidget * wid)
-{
-	g_message ("$$$ show signal emitted");
-}
-
-/**
- * create_queue_window:
- *
- * Creates the queue_window widget that displays the progress of the
- * current operation.
- */
-
-static void
-queue_window_delete_event_cb (GtkWindow *window,
-			      void *data)
-{
-	/* Do nothing.  Just prevent GTK+ from destroying the window.  */
-}
-
-static void
-create_queue_window (void)
-{
-	GtkWidget *vbox;
-	GtkWidget *pending_vb, *pending_lb;
-	GtkWidget *progress_lb, *progress_bar;
-
-	/* Check to see if we've only hidden it */
-	if (queue_window != NULL)
-		return;
-
-	queue_window = gtk_window_new (GTK_WINDOW_DIALOG);
-	gtk_container_set_border_width (GTK_CONTAINER (queue_window), 8);
-
-	gtk_signal_connect (GTK_OBJECT (queue_window), "delete_event",
-			    GTK_SIGNAL_FUNC (queue_window_delete_event_cb), NULL);
-
-	vbox = gtk_vbox_new (FALSE, 4);
-
-	pending_vb = gtk_vbox_new (FALSE, 2);
-	queue_window_pending = pending_vb;
-
-	pending_lb = gtk_label_new (_("Currently pending operations:"));
-	gtk_misc_set_alignment (GTK_MISC (pending_lb), 0.0, 0.0);
-	gtk_box_pack_start (GTK_BOX (pending_vb), pending_lb, FALSE, TRUE, 0);
-
-	gtk_box_pack_start (GTK_BOX (vbox), pending_vb, TRUE, TRUE, 4);
-
-	/* FIXME: 'operation' is not the warmest cuddliest word. */
-	progress_lb = gtk_label_new ("");
-	queue_window_message = progress_lb;
-	gtk_box_pack_start (GTK_BOX (vbox), progress_lb, FALSE, TRUE, 4);
-
-	progress_bar = gtk_progress_bar_new ();
-	queue_window_progress = progress_bar;
-	/* FIXME: is this fit for l10n? */
-	gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (progress_bar),
-					  GTK_PROGRESS_LEFT_TO_RIGHT);
-	gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (progress_bar),
-					GTK_PROGRESS_CONTINUOUS);
-	gtk_box_pack_start (GTK_BOX (vbox), progress_bar, FALSE, TRUE, 4);
-
-	gtk_container_add (GTK_CONTAINER (queue_window), vbox);
-
-	gtk_widget_show (GTK_WIDGET (progress_bar));
-	gtk_widget_show (GTK_WIDGET (progress_lb));
-	gtk_widget_show (GTK_WIDGET (pending_lb));
-	gtk_widget_show (GTK_WIDGET (pending_vb));
-	gtk_widget_show (GTK_WIDGET (vbox));
-
-	gtk_signal_connect (GTK_OBJECT (queue_window), "hide", print_hide,
-			    NULL);
-	gtk_signal_connect (GTK_OBJECT (queue_window), "unmap", print_unmap,
-			    NULL);
-	gtk_signal_connect (GTK_OBJECT (queue_window), "show", print_show,
-			    NULL);
-	gtk_signal_connect (GTK_OBJECT (queue_window), "map", print_map,
-			    NULL);
-}
-
-static void destroy_queue_window (void)
-{
-	g_return_if_fail (queue_window);
-
-	timeout_toggle (FALSE);
-	gtk_widget_destroy (queue_window);
-
-	queue_window = NULL;
-	queue_window_progress = NULL;
-	queue_window_pending = NULL;
-	queue_window_message = NULL;
-}
-
 /**
  * check_compipes:
  *
@@ -727,22 +572,6 @@ check_compipes (void)
 }
 
 /**
- * check_cond:
- *
- * See if our condition is initialized and do so if necessary
- **/
-
-static void
-check_cond (void)
-{
-	if (modal_cond == NULL)
-		modal_cond = g_cond_new ();
-
-	if (ready_cond == NULL)
-		ready_cond = g_cond_new ();
-}
-
-/**
  * dispatch:
  * @clur: The operation to execute and its parameters
  *
@@ -779,8 +608,6 @@ dispatch (void *unused)
 		msg.message = g_strdup (clur->gerund);
 		write (MAIN_WRITER, &msg, sizeof (msg));
 
-		mail_op_hide_progressbar ();
-		
 		(clur->spec->callback) (clur->in_data, clur->op_data, clur->ex);
 
 		if (camel_exception_is_set (clur->ex)) {
@@ -799,15 +626,10 @@ dispatch (void *unused)
 		msg.type = FINISHED;
 		msg.clur = clur;
 
-		G_LOCK (ready_for_op);
+		/* Wait for the cleanup to finish before starting our next op */
+		block_prepare (&finish_block);
 		write (MAIN_WRITER, &msg, sizeof (msg));
-
-		ready_may_proceed = FALSE;
-		while (ready_may_proceed == FALSE)
-			g_cond_wait (ready_cond,
-				     g_static_mutex_get_mutex (&G_LOCK_NAME
-							       (ready_for_op)));
-		G_UNLOCK (ready_for_op);
+		block_wait (&finish_block);
 	}
 
 #ifdef G_THREADS_IMPL_POSIX
@@ -860,54 +682,41 @@ read_msg (GIOChannel * source, GIOCondition condition, gpointer userdata)
 	switch (msg->type) {
 	case STARTING:
 		DEBUG (("*** Message -- STARTING %s\n", msg->message));
-		gtk_label_set_text (GTK_LABEL (queue_window_message),
-				    msg->message);
-		gtk_progress_bar_update (GTK_PROGRESS_BAR
-					 (queue_window_progress), 0.0);
+		ui_set_message (msg->message);
+		ui_set_busy ();
 		g_free (msg->message);
-		g_free (msg);
 		break;
+#if 0
 	case PERCENTAGE:
 		DEBUG (("*** Message -- PERCENTAGE\n"));
-		gtk_progress_bar_update (GTK_PROGRESS_BAR
-					 (queue_window_progress),
-					 msg->percentage);
-		g_free (msg);
+		g_warning ("PERCENTAGE operation unsupported");
 		break;
 	case HIDE_PBAR:
 		DEBUG (("*** Message -- HIDE_PBAR\n"));
-		gtk_progress_set_activity_mode (GTK_PROGRESS
-						(queue_window_progress),
-						TRUE);
-		timeout_toggle (TRUE);
-		g_free (msg);
+		g_warning ("HIDE_PBAR operation unsupported");
 		break;
 	case SHOW_PBAR:
 		DEBUG (("*** Message -- SHOW_PBAR\n"));
-		timeout_toggle (FALSE);
-		gtk_progress_set_activity_mode (GTK_PROGRESS
-						(queue_window_progress),
-						FALSE);
-		g_free (msg);
+		g_warning ("HIDE_PBAR operation unsupported");
 		break;
+#endif
+
 	case MESSAGE:
 		DEBUG (("*** Message -- MESSAGE\n"));
-		gtk_label_set_text (GTK_LABEL (queue_window_message),
-				    msg->message);
+		ui_set_message (msg->message);
 		g_free (msg->message);
-		g_free (msg);
 		break;
+
 	case PASSWORD:
 		DEBUG (("*** Message -- PASSWORD\n"));
 		g_assert (msg->reply);
 		g_assert (msg->success);
 		get_password (msg);
-		/* don't free msg! done later */
 		break;
+
 	case ERROR:
 		DEBUG (("*** Message -- ERROR\n"));
 		show_error (msg);
-		g_free (msg);
 		break;
 
 		/* Don't fall through; dispatch_func does the FINISHED
@@ -916,100 +725,62 @@ read_msg (GIOChannel * source, GIOCondition condition, gpointer userdata)
 
 	case FORWARD_EVENT:
 		DEBUG (("*** Message -- FORWARD_EVENT %p\n", msg->event_hook));
-
 		g_assert (msg->event_hook);
 		(msg->event_hook) (msg->event_obj, msg->event_event_data, msg->event_user_data);
-		g_free (msg);
 		break;
 
 	case FINISHED:
-		DEBUG (
-		       ("*** Message -- FINISH %s\n",
-			msg->clur->gerund));
-
-		if (msg->clur->spec->cleanup)
-			(msg->clur->spec->cleanup) (msg->clur->in_data,
-						    msg->clur->op_data,
-						    msg->clur->ex);
-
-		G_LOCK (ready_for_op);
-		ready_may_proceed = TRUE;
-		g_cond_signal (ready_cond);
-		G_UNLOCK (ready_for_op);
-
-		if (camel_exception_is_set (msg->clur->ex) &&
-		    msg->clur->ex->id != CAMEL_EXCEPTION_USER_CANCEL) {
-			g_warning ("Error on cleanup of `%s': %s",
-				   msg->clur->infinitive,
-				   camel_exception_get_description (msg->
-								    clur->
-								    ex));
-		}
-
-		free_closure (msg->clur);
-		queue_len--;
-
-		if (queue_len == 0) {
-			g_print ("\tNo more ops -- hide %p.\n", queue_window);
-			/* All done! */
-			/* gtk_widget_hide seems to have problems sometimes 
-			 * here... perhaps because we're in a gsource handler,
-			 * not a GTK event handler? Anyway, we defer the hiding
-			 * til an idle. */
-			/*gtk_idle_add (hide_queue_window, NULL);*/
-			/*gtk_widget_hide (queue_window); */
-			destroy_queue_window ();
-		} else {
-			g_print ("\tOperation(s) left.\n");
-
-			/* There's another operation left :
-			 * Clear it out of the 'pending' vbox 
-			 */
-			remove_next_pending ();
-		}
-		g_free (msg);
+		DEBUG (("*** Message -- FINISH %s\n", msg->clur->gerund));
+		cleanup_op (msg);
 		break;
+
 	default:
 		g_warning (_("Corrupted message from dispatching thread?"));
 		break;
 	}
 
 	GDK_THREADS_LEAVE ();
+	g_free (msg);
 	return TRUE;
 }
 
 /**
- * remove_next_pending:
+ * cleanup_op:
  *
- * Remove an item from the list of pending items. If
- * that's the last one, additionally hide the little
- * 'pending' message.
+ * Cleanup after a finished operation
  **/
 
 static void
-remove_next_pending (void)
+cleanup_op (com_msg_t * msg)
 {
-	GList *children;
+	block_hold (&finish_block);
 
-	children =
-		gtk_container_children (GTK_CONTAINER (queue_window_pending));
+	/* Run the cleanup */
 
-	/* Skip past the header label */
-	children = g_list_first (children);
-	children = g_list_next (children);
+	if (msg->clur->spec->cleanup)
+		(msg->clur->spec->cleanup) (msg->clur->in_data,
+					    msg->clur->op_data,
+					    msg->clur->ex);
+	
+	/* Tell the dispatch thread that it can start
+	 * the next operation */
 
-	if (!children) {
-		g_warning ("Mistake in queue window!");
-		return;
+	block_release (&finish_block);
+
+	/* Print an exception if the cleanup caused one */
+
+	if (camel_exception_is_set (msg->clur->ex) &&
+	    msg->clur->ex->id != CAMEL_EXCEPTION_USER_CANCEL) {
+		g_warning ("Error on cleanup of `%s': %s",
+			   msg->clur->infinitive,
+			   camel_exception_get_description (msg->clur->ex));
 	}
 
-	/* Nuke the one on top */
-	gtk_container_remove (GTK_CONTAINER (queue_window_pending),
-			      GTK_WIDGET (children->data));
+	free_closure (msg->clur);
+	queue_len--;
 
-	/* Hide it? */
-	if (g_list_next (children) == NULL)
-		gtk_widget_hide (queue_window_pending);
+	ui_unset_busy ();
+	ui_unset_message ();
 }
 
 /**
@@ -1022,63 +793,27 @@ static void
 show_error (com_msg_t * msg)
 {
 	GtkWidget *err_dialog;
-	gchar *old_message;
+
+	/* Create the dialog */
 
 	err_dialog = gnome_error_dialog (msg->message);
-	gnome_dialog_set_close (GNOME_DIALOG (err_dialog), TRUE);
-	gtk_signal_connect (GTK_OBJECT (err_dialog), "close",
-			    (GtkSignalFunc) show_error_clicked, NULL);
-	gtk_signal_connect (GTK_OBJECT (err_dialog), "clicked",
-			    (GtkSignalFunc) show_error_clicked, NULL);
 	g_free (msg->message);
 
-	/* Save the old message, but display a new one right now */
-	gtk_label_get (GTK_LABEL (queue_window_message), &old_message);
-	gtk_object_set_data (GTK_OBJECT (err_dialog), "old_message",
-			     g_strdup (old_message));
-	gtk_label_set_text (GTK_LABEL (queue_window_message),
-			    _("Waiting for user to close error dialog"));
+	/* Stop the other thread until the user reacts */
 
-	G_LOCK (modal_lock);
+	ui_unset_busy ();
+	block_hold (&modal_block);
 
-	timeout_toggle (FALSE);
-	modal_may_proceed = FALSE;
-	/*gtk_widget_show_all (GTK_WIDGET (err_dialog));*/
-	gnome_dialog_run_and_close (GNOME_DIALOG (err_dialog));
-	/*
-	 *gnome_win_hints_set_layer (err_dialog, WIN_LAYER_ONTOP);
-	 *gnome_win_hints_set_state (err_dialog, WIN_STATE_ARRANGE_IGNORE);
-	 *gnome_win_hints_set_hints (err_dialog,
-	 *			   WIN_HINTS_SKIP_FOCUS |
-	 *			   WIN_HINTS_SKIP_WINLIST |
-	 *			   WIN_HINTS_SKIP_TASKBAR);
-	 */
-}
+	/* Show the dialog. */
 
-/**
- * show_error_clicked:
- *
- * Called when the user makes hits okay to the error dialog --
- * the dispatch thread is allowed to continue.
- **/
-
-static void
-show_error_clicked (GtkObject * obj)
-{
-	gchar *old_message;
-
-	gtk_signal_disconnect_by_func (GTK_OBJECT (obj), show_error_clicked, NULL);
+	GDK_THREADS_ENTER ();
+	gnome_dialog_run_and_close (GNOME_DIALOG (err_dialog));
+	GDK_THREADS_LEAVE ();
 
-	/* Restore the old message */
-	old_message = gtk_object_get_data (obj, "old_message");
-	gtk_label_set_text (GTK_LABEL (queue_window_message),
-			    old_message);
-	g_free (old_message);
+	/* Allow the other thread to proceed */
 
-	modal_may_proceed = TRUE;
-	timeout_toggle (TRUE);
-	g_cond_signal (modal_cond);
-	G_UNLOCK (modal_lock);
+	block_release (&modal_block);
+	ui_set_busy ();
 }
 
 /**
@@ -1091,46 +826,43 @@ static void
 get_password (com_msg_t * msg)
 {
 	GtkWidget *dialog;
-	gchar *old_message;
+	int button;
+
+	/* Create the dialog */
 
 	dialog = gnome_request_dialog (msg->secret, msg->message, NULL,
 				       0, get_password_cb, msg, NULL);
-	gnome_dialog_set_close (GNOME_DIALOG (dialog), TRUE);
-	gtk_signal_connect (GTK_OBJECT (dialog), "clicked",
-			    get_password_clicked, msg);
-	gtk_signal_connect (GTK_OBJECT (dialog), "close",
-			    get_password_deleted, msg);
+	g_free (msg->message);
 
-	/* Save the old message, but display a new one right now */
-	gtk_label_get (GTK_LABEL (queue_window_message), &old_message);
-	gtk_object_set_data (GTK_OBJECT (dialog), "old_message", g_strdup(old_message));
-	gtk_label_set_text (GTK_LABEL (queue_window_message),
-			    _("Waiting for user to enter data"));
+	/* Stop the other thread */
 
-	G_LOCK (modal_lock);
+	ui_unset_busy ();
+	block_hold (&modal_block);
 
-	modal_may_proceed = FALSE;
+	/* Show the dialog (or report an error) */
 
 	if (dialog == NULL) {
 		*(msg->success) = FALSE;
 		*(msg->reply) = g_strdup (_("Could not create dialog box."));
-		modal_may_proceed = TRUE;
-		g_cond_signal (modal_cond);
-		G_UNLOCK (modal_lock);
+		button = -1;
 	} else {
 		*(msg->reply) = NULL;
-		timeout_toggle (FALSE);
-		/*
-		 *gtk_widget_show_all (GTK_WIDGET (dialog));
-		 *gnome_win_hints_set_layer (dialog, WIN_LAYER_ONTOP);
-		 *gnome_win_hints_set_state (dialog, WIN_STATE_ARRANGE_IGNORE);
-		 *gnome_win_hints_set_hints (dialog,
-		 *			   WIN_HINTS_SKIP_FOCUS |
-		 *			   WIN_HINTS_SKIP_WINLIST |
-		 *			   WIN_HINTS_SKIP_TASKBAR);
-		 */
-		gnome_dialog_run_and_close (GNOME_DIALOG (dialog));
+		GDK_THREADS_ENTER ();
+		button = gnome_dialog_run_and_close (GNOME_DIALOG (dialog));
+		GDK_THREADS_LEAVE ();
+	}
+
+	if (button == 1 || *(msg->reply) == NULL) {
+		*(msg->success) = FALSE;
+		*(msg->reply) = g_strdup (_("User cancelled query."));
+	} else if (button > 0) {
+		*(msg->success) = TRUE;
 	}
+
+	/* Allow the other thread to proceed */
+	
+	block_release (&modal_block);
+	ui_set_busy ();
 }
 
 static void
@@ -1144,167 +876,203 @@ get_password_cb (gchar * string, gpointer data)
 		*(msg->reply) = NULL;
 }
 
-static void
-get_password_deleted (GtkWidget *widget, gpointer user_data)
+static closure_t *
+new_closure (const mail_operation_spec * spec, gpointer input,
+	     gboolean free_in_data)
 {
-	get_password_clicked (GNOME_DIALOG (widget), 1, user_data);
-}
+	closure_t *clur;
 
-static void
-get_password_clicked (GnomeDialog * dialog, gint button, gpointer user_data)
-{
-	com_msg_t *msg = (com_msg_t *) user_data;
-	gchar *old_message;
+	clur = g_new0 (closure_t, 1);
+	clur->spec = spec;
+	clur->in_data = input;
+	clur->free_in_data = free_in_data;
+	clur->ex = camel_exception_new ();
 
-	gtk_signal_disconnect_by_func (GTK_OBJECT (dialog), get_password_deleted, user_data);
+	clur->op_data = g_malloc (spec->datasize);
 
-	/* Restore the old message */
-	old_message = gtk_object_get_data (GTK_OBJECT (dialog), "old_message");
-	gtk_label_set_text (GTK_LABEL (queue_window_message),
-			    old_message);
-	g_free (old_message);
+	camel_exception_init (clur->ex);
 
-	if (button == 1 || *(msg->reply) == NULL) {
-		*(msg->success) = FALSE;
-		*(msg->reply) = g_strdup (_("User cancelled query."));
-	} else
-		*(msg->success) = TRUE;
+	clur->infinitive = (spec->describe) (input, FALSE);
+	clur->gerund = (spec->describe) (input, TRUE);
 
-	g_free (msg);
-	modal_may_proceed = TRUE;
-	timeout_toggle (TRUE);
-	g_cond_signal (modal_cond);
-	G_UNLOCK (modal_lock);
+	return clur;
 }
 
-/* NOT totally copied from gtk+/gtk/testgtk.c, really! */
-
-static gboolean
-progress_timeout (gpointer data)
+static void
+free_closure (closure_t *clur)
 {
-	gfloat new_val;
-	GtkAdjustment *adj;
+	clur->spec = NULL;
 
-	if (queue_window == NULL) {
-		gtk_timeout_remove (progress_timeout_handle);
-		progress_timeout_handle = -1;
-		return FALSE;
-	}
-		
-	adj = GTK_PROGRESS (data)->adjustment;
+	if (clur->free_in_data)
+		g_free (clur->in_data);
+	clur->in_data = NULL;
 
-	new_val = adj->value + 1;
-	if (new_val > adj->upper)
-		new_val = adj->lower;
+	g_free (clur->op_data);
+	clur->op_data = NULL;
 
-	gtk_progress_set_value (GTK_PROGRESS (data), new_val);
+	camel_exception_free (clur->ex);
+	clur->ex = NULL;
 
-	return TRUE;
+	g_free (clur->infinitive);
+	g_free (clur->gerund);
+
+	g_free (clur);
 }
 
+/* ******************** */
+
 /**
- * timeout_toggle:
  *
- * Turn on and off our timeout to zip the progressbar along,
- * protecting against recursion (Ie, call with TRUE twice
- * in a row.
+ * Thread A calls block_prepare
+ * Thread A causes thread B to do something
+ * Thread A calls block_wait
+ * Thread A continues when thread B calls block_release
+ *
+ * Thread B gets thread A's message
+ * Thread B calls block_hold
+ * Thread B does something
+ * Thread B calls block_release
+ *
  **/
 
 static void
-timeout_toggle (gboolean active)
+block_prepare (block_info_t *info)
 {
-	if (!queue_window)
-		return;
-
-	if ((GTK_PROGRESS (queue_window_progress))->activity_mode == 0)
-		return;
-
-	if (active) {
-		/* We do this in case queue_window_progress gets reset */
-		if (progress_timeout_handle < 0) {
-			progress_timeout_handle =
-				gtk_timeout_add (80, progress_timeout,
-						 queue_window_progress);
-		} else {
-			gtk_timeout_remove (progress_timeout_handle);
-			progress_timeout_handle =
-				gtk_timeout_add (80, progress_timeout,
-						 queue_window_progress);
-		}
-	} else {
-		if (progress_timeout_handle >= 0) {
-			gtk_timeout_remove (progress_timeout_handle);
-			progress_timeout_handle = -1;
-		}
+	if (info->cond == NULL) {
+		info->cond = g_cond_new ();
+		info->mutex = g_mutex_new ();
 	}
+
+	g_mutex_lock (info->mutex);
+	info->val = FALSE;
 }
 
-/* This can theoretically run into problems where if a short operation starts
- * and finishes, then another short operation starts and finishes a second
- * later, we will see the window prematurely. My response: oh noooooo!
- *
- * Solution: keep the timeout's handle and remove the timeout upon reception
- * of FINISH, and zero out the handle in this function. Whatever.
- */
-static gboolean
-display_timeout (gpointer data)
+static void
+block_wait (block_info_t *info)
 {
-	if (queue_len > 0 && queue_window) {
-		gtk_widget_show (queue_window);
-		gnome_win_hints_set_layer (queue_window, WIN_LAYER_ONTOP);
-		gnome_win_hints_set_state (queue_window,
-					   WIN_STATE_ARRANGE_IGNORE);
-		gnome_win_hints_set_hints (queue_window,
-					   WIN_HINTS_SKIP_FOCUS |
-					   WIN_HINTS_SKIP_WINLIST |
-					   WIN_HINTS_SKIP_TASKBAR);
-
-		if (queue_len == 1)
-			gtk_widget_hide (queue_window_pending);
-	}
+	g_assert (info->cond);
+
+	while (info->val == FALSE)
+		g_cond_wait (info->cond, info->mutex);
 
-	return FALSE;
+	g_mutex_unlock (info->mutex);
 }
+static void
+block_hold (block_info_t *info)
+{
+	g_assert (info->cond);
 
-static closure_t *
-new_closure (const mail_operation_spec * spec, gpointer input,
-	     gboolean free_in_data)
+	g_mutex_lock (info->mutex);
+	info->val = FALSE;
+}
+
+static void
+block_release (block_info_t *info)
 {
-	closure_t *clur;
+	g_assert (info->cond);
 
-	clur = g_new0 (closure_t, 1);
-	clur->spec = spec;
-	clur->in_data = input;
-	clur->free_in_data = free_in_data;
-	clur->ex = camel_exception_new ();
+	info->val = TRUE;
+	g_cond_signal (info->cond);
+	g_mutex_unlock (info->mutex);
+}
 
-	clur->op_data = g_malloc (spec->datasize);
+/* ******************** */
 
-	camel_exception_init (clur->ex);
+/* FIXME FIXME FIXME This is a totally evil hack.  */
 
-	clur->infinitive = (spec->describe) (input, FALSE);
-	clur->gerund = (spec->describe) (input, TRUE);
+static Evolution_ShellView
+retrieve_shell_view_interface_from_control (BonoboControl *control)
+{
+	Bonobo_ControlFrame control_frame;
+	Evolution_ShellView shell_view_interface;
+	CORBA_Environment ev;
+
+	control_frame = bonobo_control_get_control_frame (control);
+
+	CORBA_exception_init (&ev);
+	shell_view_interface = Bonobo_Unknown_query_interface (control_frame,
+							       "IDL:Evolution/ShellView:1.0",
+							       &ev);
+	CORBA_exception_free (&ev);
+
+	if (shell_view_interface != CORBA_OBJECT_NIL)
+		gtk_object_set_data (GTK_OBJECT (control),
+				     "mail_threads_shell_view_interface",
+				     shell_view_interface);
+	else
+		g_warning ("Control frame doesn't have Evolution/ShellView.");
 
-	return clur;
+	return shell_view_interface;
 }
 
 static void
-free_closure (closure_t *clur)
+update_active_views (void)
 {
-	clur->spec = NULL;
+	GList *active_controls;
+	GList *p;
+
+	active_controls = folder_browser_factory_get_active_control_list ();
+	for (p = active_controls; p != NULL; p = p->next) {
+		BonoboControl *control;
+		Evolution_ShellView shell_view_interface;
+		CORBA_Environment ev;
+
+		control = BONOBO_CONTROL (p->data);
+
+		shell_view_interface = gtk_object_get_data (GTK_OBJECT (control), "mail_threads_shell_view_interface");
+
+		if (shell_view_interface == CORBA_OBJECT_NIL)
+			shell_view_interface = retrieve_shell_view_interface_from_control (control);
+
+		CORBA_exception_init (&ev);
+
+		if (shell_view_interface != CORBA_OBJECT_NIL) {
+			if (current_message == NULL && ! busy) {
+				Evolution_ShellView_unset_message (shell_view_interface, &ev);
+			} else {
+				if (current_message == NULL)
+					Evolution_ShellView_set_message (shell_view_interface,
+									 "",
+									 busy,
+									 &ev);
+				else
+					Evolution_ShellView_set_message (shell_view_interface,
+									 current_message,
+									 busy,
+									 &ev);
+			}
+		}
 
-	if (clur->free_in_data)
-		g_free (clur->in_data);
-	clur->in_data = NULL;
+		CORBA_exception_free (&ev);
+	}
+}
 
-	g_free (clur->op_data);
-	clur->op_data = NULL;
+static void 
+ui_set_busy (void)
+{
+	busy = TRUE;
+	update_active_views ();
+}
 
-	camel_exception_free (clur->ex);
-	clur->ex = NULL;
+static void 
+ui_unset_busy (void)
+{
+	busy = FALSE;
+	update_active_views ();
+}
 
-	g_free (clur->infinitive);
-	g_free (clur->gerund);
+static void 
+ui_set_message (const char *message)
+{
+	g_free (current_message);
+	current_message = g_strdup (message);
+	update_active_views ();
+}
 
-	g_free (clur);
+static void 
+ui_unset_message (void)
+{
+	g_free (current_message);
+	current_message = NULL;
+	update_active_views ();
 }