/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* Author :
* Peter Williams (peterw@helixcode.com)
*
* Copyright 2000, Helix Code, Inc. (http://www.helixcode.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.
*
*/
#include <config.h>
#include <string.h>
#include <errno.h>
#include <glib.h>
#include <gal/widgets/e-gui-utils.h>
#include "folder-browser-factory.h"
#include "camel/camel-object.h"
#include "mail.h"
#include "mail-threads.h"
#define DEBUG(p) g_print p
/**
* A function and its userdata
**/
typedef struct closure_s
{
gpointer in_data;
gboolean free_in_data;
gpointer op_data;
const mail_operation_spec *spec;
CamelException *ex;
gchar *infinitive;
gchar *gerund;
}
closure_t;
/**
* A command issued through the compipe
**/
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;
closure_t *clur;
/* Password stuff */
gchar **reply;
gboolean secret;
gboolean *success;
/* Event stuff */
CamelObjectEventHookFunc event_hook;
CamelObject *event_obj;
gpointer event_event_data;
gpointer event_user_data;
} 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.
**/
static gboolean dispatch_thread_started = FALSE;
/**
* @queue_len : the number of operations pending
* and being executed.
*
* Because camel is not thread-safe we work
* with the restriction that more than one mailbox
* cannot be accessed at once. Thus we cannot
* concurrently check mail and move messages, etc.
**/
static gint queue_len = 0;
/**
* @main_compipe: The pipe through which the dispatcher communicates
* with the main thread for GTK+ calls
*
* @chan_reader: the GIOChannel that reads our pipe
*
* @MAIN_READER: the fd in our main pipe that.... reads!
* @MAIN_WRITER: the fd in our main pipe that.... writes!
*/
#define MAIN_READER main_compipe[0]
#define MAIN_WRITER main_compipe[1]
#define DISPATCH_READER dispatch_compipe[0]
#define DISPATCH_WRITER dispatch_compipe[1]
static int main_compipe[2] = { -1, -1 };
static int dispatch_compipe[2] = { -1, -1 };
GIOChannel *chan_reader = NULL;
/**
* @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.
*/
static block_info_t modal_block = BLOCK_INFO_INIT;
/**
* @finish_block: A condition so that the dispatch thread
* blocks until the main thread has finished the cleanup.
**/
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 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 gboolean read_msg (GIOChannel * source, GIOCondition condition,
gpointer userdata);
static void show_error (com_msg_t * msg);
static void get_password (com_msg_t * msg);
static void get_password_cb (gchar * string, 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);
/* Pthread code */
/* FIXME: support other thread types!!!! */
#ifdef G_THREADS_IMPL_POSIX
#include <pthread.h>
/**
* @dispatch_thread: the pthread_t (when using pthreads, of
* course) representing our dispatcher routine. Never used
* except to make pthread_create happy
**/
static pthread_t dispatch_thread;
/* FIXME: do we need to set any attributes for our thread?
* If so, we need to create a pthread_attr structure and
* fill it in somewhere. But the defaults should be good
* enough.
*/
#elif defined( G_THREADS_IMPL_SOLARIS )
#include <thread.h>
static thread_t dispatch_thread;
#else /* no supported thread impl */
void
f (void)
{
Error_No_supported_thread_implementation_recognized ();
choke on this;
}
#endif
static int
pipe_write (int fd, const void *buf, size_t count)
{
size_t res;
do {
res = write (fd, buf, count);
}
while (res == -1 && errno == EINTR);
return res;
}
static size_t
pipe_read (int fd, void *buf, size_t count)
{
size_t res;
do {
res = read (fd, buf, count);
} while (res == -1 && errno == EINTR);
return res;
}
/**
* mail_operation_queue:
* @spec: describes the operation to be performed
* @input: input data for the operation.
*
* Runs a mail operation asynchronously. If no other operation is running,
* we start another thread and call the callback in that thread. The function
* can then use the mail_op_ functions to perform limited UI returns, while
* the main UI is completely unlocked.
*
* If an async operation is going on when this function is called again,
* it waits for the currently executing operation to finish, then
* executes the callback function in another thread.
*
* Returns TRUE on success, FALSE on some sort of queueing error.
**/
gboolean
mail_operation_queue (const mail_operation_spec * spec, gpointer input,
gboolean free_in_data)
{
closure_t *clur;
g_assert (spec);
clur = new_closure (spec, input, free_in_data);
if (spec->setup)
(spec->setup) (clur->in_data, clur->op_data, clur->ex);
if (camel_exception_is_set (clur->ex)) {
if (clur->ex->id != CAMEL_EXCEPTION_USER_CANCEL) {
GtkWidget *err_dialog;
gchar *msg;
msg =
g_strdup_printf
(_("Error while preparing to %s:\n" "%s"),
clur->infinitive,
camel_exception_get_description (clur->ex));
err_dialog = gnome_error_dialog (msg);
g_free (msg);
gnome_dialog_set_close (GNOME_DIALOG (err_dialog),
TRUE);
gnome_dialog_run_and_close (GNOME_DIALOG (err_dialog));
g_warning ("Setup failed for `%s': %s",
clur->infinitive,
camel_exception_get_description (clur->
ex));
}
free_closure (clur);
return FALSE;
}
if (queue_len == 0) {
check_compipes ();
check_dispatcher ();
} /* else add self to queue */
pipe_write (DISPATCH_WRITER, clur, sizeof (closure_t));
/* dispatch allocates a separate buffer
* to hold the closure; it's in the pipe and
* can safely be freed
*/
g_free (clur);
queue_len++;
return TRUE;
}
#if 0
/**
* mail_op_set_percentage:
* @percentage: the percentage that will be displayed in the progress bar
*
* Set the percentage of the progress bar for the currently executing operation.
* Threadsafe for, nay, intended to be called by, the dispatching thread.
**/
void
mail_op_set_percentage (gfloat percentage)
{
com_msg_t msg;
msg.type = PERCENTAGE;
msg.percentage = percentage;
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
}
/**
* mail_op_hide_progressbar:
*
* Hide the progress bar in the status box
* Threadsafe for, nay, intended to be called by, the dispatching thread.
**/
void
mail_op_hide_progressbar (void)
{
com_msg_t msg;
msg.type = HIDE_PBAR;
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
}
/**
* mail_op_show_progressbar:
*
* Show the progress bar in the status box
* Threadsafe for, nay, intended to be called by, the dispatching thread.
**/
void
mail_op_show_progressbar (void)
{
com_msg_t msg;
msg.type = SHOW_PBAR;
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
}
#endif
/**
* mail_op_set_message:
* @str: message
*
* Set the message displayed above the progress bar for the currently
* executing operation.
* Threadsafe for, nay, intended to be called by, the dispatching thread.
**/
static void
set_message (gchar *str)
{
com_msg_t msg;
msg.type = MESSAGE;
msg.message = str;
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
}
void
mail_op_set_message_plain (const gchar *str)
{
set_message (g_strdup (str));
}
/**
* mail_op_set_message:
* @fmt: printf-style format string for the message
* @...: arguments to the format string
*
* Set the message displayed above the progress bar for the currently
* executing operation.
* Threadsafe for, nay, intended to be called by, the dispatching thread.
**/
void
mail_op_set_message (const gchar *fmt, ...)
{
gchar *str;
va_list val;
va_start (val, fmt);
str = g_strdup_vprintf (fmt, val);
va_end (val);
set_message (str);
}
/**
* mail_op_get_password:
* @prompt: the question put to the user
* @secret: whether the dialog box shold print stars when the user types
* @dest: where to store the reply
*
* Asks the user for a password (or string entry in general). Waits for
* the user's response. On success, returns TRUE and @dest contains the
* response. On failure, returns FALSE and @dest contains the error
* message.
**/
gboolean
mail_op_get_password (gchar * prompt, gboolean secret, gchar ** dest)
{
com_msg_t msg;
gboolean result;
msg.type = PASSWORD;
msg.secret = secret;
msg.message = prompt;
msg.reply = dest;
msg.success = &result;
(*dest) = NULL;
block_prepare (&modal_block);
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
block_wait (&modal_block);
return result;
}
/**
* mail_op_error:
* @fmt: printf-style format string for the error
* @...: arguments to the format string
*
* Opens an error dialog for the currently executing operation.
* Threadsafe for, nay, intended to be called by, the dispatching thread.
**/
void
mail_op_error (gchar * fmt, ...)
{
com_msg_t msg;
va_list val;
va_start (val, fmt);
msg.type = ERROR;
msg.message = g_strdup_vprintf (fmt, val);
va_end (val);
block_prepare (&modal_block);
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
block_wait (&modal_block);
}
/**
* mail_op_forward_event:
*
* Communicate a camel event over to the main thread.
**/
void
mail_op_forward_event (CamelObjectEventHookFunc func, CamelObject *o,
gpointer event_data, gpointer user_data)
{
com_msg_t msg;
msg.type = FORWARD_EVENT;
msg.event_hook = func;
msg.event_obj = o;
msg.event_event_data = event_data;
msg.event_user_data = user_data;
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
}
/**
* mail_operation_wait_for_finish:
*
* Waits for the currently executing async operations
* to finish executing
*/
void
mail_operation_wait_for_finish (void)
{
while (queue_len)
gtk_main_iteration ();
/* Sigh. Otherwise we deadlock upon exit. */
GDK_THREADS_LEAVE ();
}
/**
* mail_operations_are_executing:
*
* Returns TRUE if operations are being executed asynchronously
* when called, FALSE if not.
**/
gboolean
mail_operations_are_executing (void)
{
return (queue_len > 0);
}
/**
* mail_operations_terminate:
*
* Let the operations finish then terminate the dispatch thread
**/
void
mail_operations_terminate (void)
{
closure_t clur;
mail_operation_wait_for_finish();
memset (&clur, 0, sizeof (closure_t));
clur.spec = NULL;
/* DISPATCH_WRITER will only have been initialized if any
* calls have been made using the old thread system.
*/
if (DISPATCH_WRITER != -1) {
pipe_write (DISPATCH_WRITER, &clur, sizeof (closure_t));
close (DISPATCH_WRITER);
}
close (MAIN_READER);
}
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)
{
int res;
if (dispatch_thread_started)
return;
#if defined( G_THREADS_IMPL_POSIX )
res = pthread_create (&dispatch_thread, NULL,
(void *) &dispatch, NULL);
#elif defined( G_THREADS_IMPL_SOLARIS )
res = thr_create (NULL, 0, (void *) &dispatch, NULL, 0, &dispatch_thread);
#else /* no known impl */
Error_No_thread_create_implementation ();
choke on this;
#endif
if (res != 0) {
g_warning ("Error launching dispatch thread!");
/* FIXME: more error handling */
} else
dispatch_thread_started = TRUE;
}
/**
* check_compipes:
*
* Check and see if our pipe has been opened and open
* it if necessary.
**/
static void
check_compipes (void)
{
if (MAIN_READER < 0) {
if (pipe (main_compipe) < 0) {
g_warning ("Call to pipe(2) failed!");
/* FIXME: better error handling. How do we react? */
return;
}
chan_reader = g_io_channel_unix_new (MAIN_READER);
g_io_add_watch (chan_reader, G_IO_IN, read_msg, NULL);
}
if (DISPATCH_READER < 0) {
if (pipe (dispatch_compipe) < 0) {
g_warning ("Call to pipe(2) failed!");
/* FIXME: better error handling. How do we react? */
return;
}
}
}
/**
* dispatch:
* @clur: The operation to execute and its parameters
*
* Start a thread that executes the closure and exit
* it when done.
*/
static void *
dispatch (void *unused)
{
size_t len;
closure_t *clur;
com_msg_t msg;
/* Let the compipes be created */
sleep (1);
while (1) {
clur = g_new (closure_t, 1);
len = pipe_read (DISPATCH_READER, clur, sizeof (closure_t));
if (len <= 0)
break;
if (len != sizeof (closure_t)) {
g_warning ("dispatcher: Didn't read full message!");
continue;
}
if (clur->spec == NULL)
break;
msg.type = STARTING;
msg.message = g_strdup (clur->gerund);
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
(clur->spec->callback) (clur->in_data, clur->op_data, clur->ex);
if (camel_exception_is_set (clur->ex)) {
if (clur->ex->id != CAMEL_EXCEPTION_USER_CANCEL) {
g_warning ("Callback failed for `%s': %s",
clur->infinitive,
camel_exception_get_description (clur->
ex));
mail_op_error (_("Error while `%s':\n%s"),
clur->gerund,
camel_exception_get_description (clur->
ex));
}
}
msg.type = FINISHED;
msg.clur = clur;
/* Wait for the cleanup to finish before starting our next op */
block_prepare (&finish_block);
pipe_write (MAIN_WRITER, &msg, sizeof (msg));
block_wait (&finish_block);
}
close (DISPATCH_READER);
close (MAIN_WRITER);
#ifdef G_THREADS_IMPL_POSIX
pthread_exit (0);
#elif defined( G_THREADS_IMPL_SOLARIS )
thr_exit (NULL);
#else /* no known impl */
Error_No_thread_exit_implemented ();
choke on this;
#endif
return NULL;
/*NOTREACHED*/
}
/**
* read_msg:
* @source: the channel that has data to read
* @condition: the reason we were called
* @userdata: unused
*
* A message has been recieved on our pipe; perform the appropriate
* action.
**/
static gboolean
read_msg (GIOChannel * source, GIOCondition condition, gpointer userdata)
{
com_msg_t *msg;
guint size;
msg = g_new0 (com_msg_t, 1);
g_io_channel_read (source, (gchar *) msg,
sizeof (com_msg_t) / sizeof (gchar), &size);
if (size != sizeof (com_msg_t)) {
g_warning (_("Incomplete message written on pipe!"));
msg->type = ERROR;
msg->message =
g_strdup (_
("Error reading commands from dispatching thread."));
}
/* This is very important, though I'm not quite sure why
* it is as we are in the main thread right now.
*/
/*g_message ("DLG: IN: read_msg");*/
switch (msg->type) {
case STARTING:
DEBUG (("*** Message -- STARTING %s\n", msg->message));
ui_set_busy ();
ui_set_message (msg->message);
g_free (msg->message);
break;
#if 0
case PERCENTAGE:
DEBUG (("*** Message -- PERCENTAGE\n"));
g_warning ("PERCENTAGE operation unsupported");
break;
case HIDE_PBAR:
DEBUG (("*** Message -- HIDE_PBAR\n"));
g_warning ("HIDE_PBAR operation unsupported");
break;
case SHOW_PBAR:
DEBUG (("*** Message -- SHOW_PBAR\n"));
g_warning ("HIDE_PBAR operation unsupported");
break;
#endif
case MESSAGE:
DEBUG (("*** Message -- MESSAGE\n"));
ui_set_message (msg->message);
g_free (msg->message);
break;
case PASSWORD:
DEBUG (("*** Message -- PASSWORD\n"));
g_assert (msg->reply);
g_assert (msg->success);
get_password (msg);
break;
case ERROR:
DEBUG (("*** Message -- ERROR\n"));
show_error (msg);
break;
/* Don't fall through; dispatch_func does the FINISHED
* call for us
*/
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);
break;
case FINISHED:
DEBUG (("*** Message -- FINISH %s\n", msg->clur->gerund));
cleanup_op (msg);
break;
default:
g_warning (_("Corrupted message from dispatching thread?"));
break;
}
/*g_message ("DLG: OUT: read_msg");*/
g_free (msg);
return TRUE;
}
/**
* cleanup_op:
*
* Cleanup after a finished operation
**/
static void
cleanup_op (com_msg_t * msg)
{
block_hold (&finish_block);
/* Run the cleanup */
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 */
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));
}
free_closure (msg->clur);
queue_len--;
ui_unset_busy ();
ui_unset_message ();
}
/**
* show_error:
*
* Show the error dialog and wait for user OK
**/
static void
show_error (com_msg_t * msg)
{
GtkWidget *err_dialog;
/* Create the dialog */
err_dialog = gnome_error_dialog (msg->message);
g_free (msg->message);
/* Stop the other thread until the user reacts */
ui_unset_busy ();
block_hold (&modal_block);
/* Show the dialog. */
/* Do not GDK_THREADS_ENTER; we're inside the read_msg
* handler which takes care of this for us. Oh, if
* only GDK_THREADS_ENTER were recursive...
*/
gnome_dialog_run_and_close (GNOME_DIALOG (err_dialog));
/* Allow the other thread to proceed */
block_release (&modal_block);
ui_set_busy ();
}
static void
focus_on_entry(GtkWidget *widget, gpointer user_data)
{
if (GTK_IS_ENTRY(widget)) {
gtk_widget_grab_focus(widget);
}
}
/**
* get_password:
*
* Ask for a password and put the answer in *(msg->reply)
**/
static void
get_password (com_msg_t * msg)
{
GtkWidget *dialog;
int button;
/* Create the dialog */
dialog = gnome_request_dialog (msg->secret, msg->message, NULL,
0, get_password_cb, msg, NULL);
/* Stop the other thread */
ui_unset_busy ();
block_hold (&modal_block);
/* Show the dialog (or report an error) */
if (dialog == NULL) {
*(msg->success) = FALSE;
*(msg->reply) = g_strdup (_("Could not create dialog box."));
button = -1;
} else {
e_container_foreach_leaf (GTK_CONTAINER (dialog),
focus_on_entry, NULL);
*(msg->reply) = NULL;
button = gnome_dialog_run_and_close (GNOME_DIALOG (dialog));
}
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
get_password_cb (gchar * string, gpointer data)
{
com_msg_t *msg = (com_msg_t *) data;
if (string)
*(msg->reply) = g_strdup (string);
else
*(msg->reply) = NULL;
}
static closure_t *
new_closure (const mail_operation_spec * spec, gpointer input,
gboolean free_in_data)
{
closure_t *clur;
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 ();
clur->op_data = g_malloc (spec->datasize);
camel_exception_init (clur->ex);
clur->infinitive = (spec->describe) (input, FALSE);
clur->gerund = (spec->describe) (input, TRUE);
return clur;
}
static void
free_closure (closure_t *clur)
{
clur->spec = NULL;
if (clur->free_in_data)
g_free (clur->in_data);
clur->in_data = NULL;
g_free (clur->op_data);
clur->op_data = NULL;
camel_exception_free (clur->ex);
clur->ex = NULL;
g_free (clur->infinitive);
g_free (clur->gerund);
g_free (clur);
}
/* ******************** */
/**
*
* 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
block_prepare (block_info_t *info)
{
if (info->cond == NULL) {
info->cond = g_cond_new ();
info->mutex = g_mutex_new ();
}
g_mutex_lock (info->mutex);
info->val = FALSE;
}
static void
block_wait (block_info_t *info)
{
g_assert (info->cond);
while (info->val == FALSE)
g_cond_wait (info->cond, info->mutex);
g_mutex_unlock (info->mutex);
}
static void
block_hold (block_info_t *info)
{
g_assert (info->cond);
g_mutex_lock (info->mutex);
info->val = FALSE;
}
static void
block_release (block_info_t *info)
{
g_assert (info->cond);
info->val = TRUE;
g_cond_signal (info->cond);
g_mutex_unlock (info->mutex);
}
/* ******************** */
/* FIXME FIXME FIXME This is a totally evil hack. */
static GNOME_Evolution_ShellView
retrieve_shell_view_interface_from_control (BonoboControl *control)
{
Bonobo_ControlFrame control_frame;
GNOME_Evolution_ShellView shell_view_interface;
CORBA_Environment ev;
control_frame = bonobo_control_get_control_frame (control);
if (control_frame == NULL)
return CORBA_OBJECT_NIL;
CORBA_exception_init (&ev);
shell_view_interface = Bonobo_Unknown_queryInterface (control_frame,
"IDL:GNOME/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 shell_view_interface;
}
static void
update_active_views (void)
{
EList *controls;
EIterator *it;
controls = folder_browser_factory_get_control_list ();
for (it = e_list_get_iterator (controls); e_iterator_is_valid (it); e_iterator_next (it)) {
BonoboControl *control;
GNOME_Evolution_ShellView shell_view_interface;
CORBA_Environment ev;
control = BONOBO_CONTROL (e_iterator_get (it));
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) {
GNOME_Evolution_ShellView_unsetMessage (shell_view_interface, &ev);
} else {
if (current_message == NULL)
GNOME_Evolution_ShellView_setMessage (shell_view_interface,
"",
busy,
&ev);
else
GNOME_Evolution_ShellView_setMessage (shell_view_interface,
current_message,
busy,
&ev);
}
}
CORBA_exception_free (&ev);
}
gtk_object_unref(GTK_OBJECT(it));
}
static void
ui_set_busy (void)
{
busy = TRUE;
update_active_views ();
}
static void
ui_unset_busy (void)
{
busy = FALSE;
update_active_views ();
}
static void
ui_set_message (const char *message)
{
g_free (current_message);
current_message = g_strdup (message);
update_active_views ();
}
static void
ui_unset_message (void)
{
g_free (current_message);
current_message = NULL;
update_active_views ();
}
