/* -*- 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 <glib.h>
#include "mail.h"
#include "mail-threads.h"
/* FIXME: support other thread types!!!! */
#define USE_PTHREADS
/**
* A function and its userdata
**/
typedef struct closure_s {
void (*func)( gpointer );
gpointer data;
} closure_t;
/**
* A command issued through the compipe
**/
typedef struct com_msg_s {
enum com_msg_type_e { STARTING, PERCENTAGE, HIDE_PBAR, SHOW_PBAR, MESSAGE, ERROR, FINISHED } type;
gfloat percentage;
gchar *message;
} com_msg_t;
/**
* @mail_operation_in_progress: When true, there's
* another thread executing a major ev-mail operation:
* fetch_mail, etc.
*
* 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 gboolean mail_operation_in_progress;
/**
* @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;
/**
* @op_queue: The list of operations the are scheduled
* to proceed after the currently executing one.
**/
static GSList *op_queue = NULL;
/**
* @compipe: The pipe through which the dispatcher communicates
* with the main thread for GTK+ calls
*
* @chan_reader: the GIOChannel that reads our pipe
*/
#define READER compipe[0]
#define WRITER compipe[1]
static int compipe[2] = { -1, -1 };
GIOChannel *chan_reader = NULL;
/**
* Static prototypes
**/
static void create_queue_window( void );
static void dispatch( closure_t *clur );
static void *dispatch_func( void *data );
static void check_compipe( void );
static gboolean read_msg( GIOChannel *source, GIOCondition condition, gpointer userdata );
static void remove_next_pending( void );
/* Pthread code */
#ifdef USE_PTHREADS
#include <pthread.h>
/**
* @dispatch_thread: the pthread_t (when using pthreads, of
* course) representing our dispatcher routine.
**/
static pthread_t dispatch_thread;
/* FIXME: do we need to set any attributes for our thread? */
#else /* defined USE_PTHREADS */
choke on this: no thread type defined
#endif
/**
* mail_operation_try:
* @description: A user-friendly string describing the operation.
* @callback: the function to call in another thread to start the operation
* @user_data: extra data passed to the callback
*
* Waits for the currently executing operation to finished, then
* executes the callback function in another thread. Returns TRUE
* on success, FALSE on some sort of queueing error.
**/
gboolean
mail_operation_try( const gchar *description, void (*callback)( gpointer ), gpointer user_data )
{
closure_t *clur;
g_assert( callback );
clur = g_new( closure_t, 1 );
clur->func = callback;
clur->data = user_data;
if( mail_operation_in_progress == FALSE ) {
/* We got the lock. Yippeee! This means that no operations
* are pending, either, so we'll create the queue window and
* show only the message and progress bar.
*/
mail_operation_in_progress = TRUE;
check_compipe();
create_queue_window();
gtk_widget_show_all( 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 );
gtk_widget_hide( queue_window_pending );
dispatch( clur );
} else {
GtkWidget *label;
/* Zut. We already have an operation running. Well,
* queue ourselves up. */
/* Yes, prepend is faster. But we pop operations
* off the beginning later and that's a lot easier.
*/
op_queue = g_slist_append( op_queue, clur );
/* Show us in the pending window. */
label = gtk_label_new( description );
gtk_misc_set_alignment( GTK_MISC( label ), 1.0, 0.5 );
gtk_box_pack_start( GTK_BOX( queue_window_pending ), label,
TRUE, TRUE, 2 );
/* 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_all( queue_window_pending );
}
return TRUE;
}
/**
* 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;
write( 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.
**/
/* 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 )
{
com_msg_t msg;
msg.type = HIDE_PBAR;
write( 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;
write( WRITER, &msg, sizeof( msg ) );
}
/**
* 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( gchar *fmt, ... )
{
com_msg_t msg;
va_list val;
va_start( val, fmt );
msg.type = MESSAGE;
msg.message = g_strdup_vprintf( fmt, val );
va_end( val );
write( WRITER, &msg, sizeof( msg ) );
}
/**
* 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 );
write( 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( mail_operation_in_progress ) {
while( gtk_events_pending() )
gtk_main_iteration();
}
}
/* ** Static functions **************************************************** */
/**
* create_queue_window:
*
* Creates the queue_window widget that displays the progress of the
* current operation.
*/
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 );
vbox = gtk_vbox_new( FALSE, 4 );
pending_vb = gtk_vbox_new( TRUE, 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,
TRUE, 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( _("Starting operation...") );
queue_window_message = progress_lb;
gtk_box_pack_start( GTK_BOX( vbox ), progress_lb,
TRUE, 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,
TRUE, TRUE, 4 );
gtk_container_add( GTK_CONTAINER( queue_window ), vbox );
}
/**
* check_compipe:
*
* Check and see if our pipe has been opened and open
* it if necessary.
**/
static void check_compipe( void )
{
if( READER > 0 )
return;
if( pipe( 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( READER );
g_io_add_watch( chan_reader, G_IO_IN, read_msg, NULL );
}
/**
* dispatch:
* @clur: The function to execute and its userdata
*
* Start a thread that executes the closure and exit
* it when done.
*/
static void dispatch( closure_t *clur )
{
int res;
res = pthread_create( &dispatch_thread, NULL, (void *) &dispatch_func, clur );
if( res != 0 ) {
g_warning( "Error launching dispatch thread!" );
/* FIXME: more error handling */
}
}
/**
* dispatch_func:
* @data: the closure to run
*
* Runs the closure and exits the thread.
*/
static void *dispatch_func( void *data )
{
com_msg_t msg;
closure_t *clur = (closure_t *) data;
msg.type = STARTING;
write( WRITER, &msg, sizeof( msg ) );
(clur->func)( clur->data );
msg.type = FINISHED;
write( WRITER, &msg, sizeof( msg ) );
g_free( data );
pthread_exit( 0 );
return NULL; /*NOTREACHED*/
}
/**
* read_msg:
* @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;
closure_t *clur;
GSList *temp;
guint size;
#if 0
GtkWidget *err_dialog;
#else
gchar *errmsg;
#endif
g_io_channel_read( source, (gchar *) &msg,
sizeof( msg ) / sizeof( gchar ),
&size );
if( size != sizeof( msg ) ) {
g_warning( _("Incomplete message written on pipe!") );
msg.type = ERROR;
msg.message = g_strdup( _("Error reading commands from dispatching thread.") );
}
switch( msg.type ) {
case STARTING:
gtk_label_set_text( GTK_LABEL( queue_window_message ),
_("Starting operation...") );
gtk_progress_bar_update( GTK_PROGRESS_BAR( queue_window_progress ), 0.0 );
break;
case PERCENTAGE:
gtk_progress_bar_update( GTK_PROGRESS_BAR( queue_window_progress ), msg.percentage );
break;
case HIDE_PBAR:
gtk_widget_hide( GTK_WIDGET( queue_window_progress ) );
break;
case SHOW_PBAR:
gtk_widget_show( GTK_WIDGET( queue_window_progress ) );
break;
case MESSAGE:
gtk_label_set_text( GTK_LABEL( queue_window_message ),
msg.message );
g_free( msg.message );
break;
case ERROR:
#if 0
/* FIXME FIXME: the gnome_dialog_ functions are causing coredumps
* on my machine! Every time, threads or not... "IMLIB ERROR: Cannot
* allocate XImage buffer". Until then, work around
*/
err_dialog = gnome_error_dialog( msg.message );
gnome_dialog_run_and_close( GNOME_DIALOG( err_dialog ) );
#else
errmsg = g_strdup_printf( "ERROR: %s", msg.message );
gtk_label_set_text( GTK_LABEL( queue_window_message ),
errmsg );
g_free( errmsg );
#endif
g_free( msg.message );
break;
/* Don't fall through; dispatch_func does the FINISHED
* call for us
*/
case FINISHED:
if( op_queue == NULL ) {
/* All done! */
gtk_widget_hide( queue_window );
mail_operation_in_progress = FALSE;
} else {
/* There's another operation left */
/* Pop it off the front */
clur = op_queue->data;
temp = g_slist_next( op_queue );
g_slist_free_1( op_queue );
op_queue = temp;
/* Clear it out of the 'pending' vbox */
remove_next_pending();
/* Run run run little process */
dispatch( clur );
}
break;
default:
g_warning( _("Corrupted message from dispatching thread?") );
break;
}
return TRUE;
}
/**
* remove_next_pending:
*
* Remove an item from the list of pending items. If
* that's the last one, additionally hide the little
* 'pending' message.
**/
static void remove_next_pending( void )
{
GList *children;
children = gtk_container_children( GTK_CONTAINER( queue_window_pending ) );
/* Skip past the header label */
children = g_list_first( children );
children = g_list_next( children );
/* Nuke the one on top */
gtk_container_remove( GTK_CONTAINER( queue_window_pending ),
GTK_WIDGET( children->data ) );
/* Hide it? */
if( g_list_next( children ) == NULL )
gtk_widget_hide( queue_window_pending );
/* FIXME: The window gets really messed up here */
gtk_container_resize_children( GTK_CONTAINER( queue_window_pending ) );
gtk_container_resize_children( GTK_CONTAINER( queue_window ) );
}
