cab9406217
2001-10-25 <NotZed@Ximian.com> * folder-browser-ui.c (fbui_sensitize_timeout): So apparently the uicomp can just 'vanish' while we're using it. Joy. Take care of that case here, fixes #13482. (fbui_sensitise_item): Check here too just for kicks. * mail-folder-cache.c (store_finalised): If we can't destroy our async event, then queue another one to do it. (store_finalised_finish): And handle it here, until we can, then free it. (mail_note_store): Queue an async event to get folderinfo, dont use mail_get_folderinfo. (update_folders_get): thread-async event to retrieve the folderinfo, and build it, then queues gui-async event to update the gui. (add_unmatched_info): Taken from mail-ops, adds unmatched if required. (add_vtrash_info): From mail-ops, add trash if required. (update_folders): Thread async event to update gui. (mail_note_store): Ref the store and storage when created. (update_1folder): Changed to assume we have info_lock, and store updates in an updates list. (setup_folder): Same. (folder_changed): Changed to call update_1folder directly. (real_folder_changed): Removed. (mail_note_folder): Changed to call update_1folder directly. (real_note_folder): Removed. (store_folder_subscribed): Call setup_folder directly. (real_folder_created): Removed. (real_flush_update): Function that actually does the updates in the gui thread. (mail_note_store): Go back to using mail_get_folderinfo. (update_folders): Fixed upf ro changed api's. (unset_folder_info): Changed to queue pending updates. (real_folder_deleted): Removed. (store_folder_unsubscribed): Do the removal work directly. (mail_note_store): Dont link to finalised event of store - we now ref it. (mail_note_store_remove): If we have any pending updates, clear them out. Also cancel any pending folderinfo retrieve operations. (update_folders): Remove our update from the storeinfo list, if it still exists. (update_1folder): Make 'sent folder shows all counts' optional via an environmental variable EVOLUTION_COUNT_SENT for all those bloody whinging lusers out there. (mail_note_store_remove): Unref the storage when done. * mail-mt.c (mail_async_event_emit): If we're in main and have a gui task, set it to run via an idle function. (idle_async_event): Wrapper for calling do_async_event from idle function, and freeing the message when done. (idle_async_event): Call mail_msg_free not free on the finished message. * component-factory.c (mail_remove_storage): Destroy the storage async. (store_disconnect): This does the work. (free_storage): Un-note the store when we remove it, so the store noting code can unref things properly. (idle_quit): Return false when done, dont loop. 2001-10-24 <NotZed@Ximian.com> * component-factory.c (owner_set_cb): Setup an async_event handler. (idle_quit): Try to destroy the async_event, or keep dropping out if it can't (deadlock). * mail-mt.c (do_async_event): Set the threadid of the thread we're running in so we know its running/which thread its in. (mail_async_event_emit): Added new argument 'type' which is the type of thread to execute against, gui or another one. Fixed all callers. (mail_async_event_destroy): Return -1 if this operation will fail (deadlock possibility). If we're in the thread of the task we're going to wait for, then return a failure (since we will deadlock). (mail_async_event_emit): Chagned to use MailAsyncFunc type as the function type, which just takes 3 void args, change args to suit. * mail-folder-cache.c (mail_note_store): Record the pending update events in a pending list. We should really be able to use an async event for this, but that doesn't return to the gui loop when done :-/ (update_folders): Remove from pending update when done. svn path=/trunk/; revision=14101
123 lines
4.3 KiB
C
123 lines
4.3 KiB
C
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
|
|
*
|
|
* Authors: Michael Zucchi <notzed@ximian.com>
|
|
*
|
|
* Copyright 2000, 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.
|
|
*
|
|
*/
|
|
|
|
#ifndef _MAIL_MT
|
|
#define _MAIL_MT
|
|
|
|
#include <pthread.h>
|
|
#include "camel/camel-exception.h"
|
|
#include "e-util/e-msgport.h"
|
|
#include "camel/camel-object.h"
|
|
#include "camel/camel-operation.h"
|
|
|
|
typedef struct _mail_msg {
|
|
EMsg msg; /* parent type */
|
|
struct _mail_msg_op *ops; /* operation functions */
|
|
unsigned int seq; /* seq number for synchronisation */
|
|
CamelOperation *cancel; /* a cancellation/status handle */
|
|
CamelException ex; /* an initialised camel exception, upto the caller to use this */
|
|
struct _mail_msg_priv *priv; /* private for internal use */
|
|
} mail_msg_t;
|
|
|
|
/* callback functions for thread message */
|
|
typedef struct _mail_msg_op {
|
|
char *(*describe_msg)(struct _mail_msg *msg, int complete);
|
|
|
|
void (*receive_msg)(struct _mail_msg *msg); /* message received */
|
|
void (*reply_msg)(struct _mail_msg *msg); /* message replied */
|
|
void (*destroy_msg)(struct _mail_msg *msg); /* finalise message */
|
|
} mail_msg_op_t;
|
|
|
|
/* setup ports */
|
|
void mail_msg_init(void);
|
|
void mail_msg_cleanup (void);
|
|
|
|
/* allocate a new message */
|
|
void *mail_msg_new(mail_msg_op_t *ops, EMsgPort *reply_port, size_t size);
|
|
void mail_msg_free(void *msg);
|
|
void mail_msg_check_error(void *msg);
|
|
void mail_msg_cancel(unsigned int msgid);
|
|
void mail_msg_wait(unsigned int msgid);
|
|
void mail_msg_wait_all(void);
|
|
int mail_msg_active(unsigned int msgid);
|
|
|
|
/* request a string/password */
|
|
char *mail_get_password (CamelService *service, const char *prompt,
|
|
gboolean secret, gboolean *cache);
|
|
|
|
/* present information and get an ok (or possibly cancel)
|
|
* "type" is as for gnome_message_box_new();
|
|
*/
|
|
gboolean mail_user_message (const char *type, const char *prompt, gboolean allow_cancel);
|
|
|
|
/* asynchronous event proxies */
|
|
typedef struct _MailAsyncEvent {
|
|
GMutex *lock;
|
|
GSList *tasks;
|
|
} MailAsyncEvent;
|
|
|
|
typedef enum _mail_async_event_t {
|
|
MAIL_ASYNC_GUI,
|
|
MAIL_ASYNC_THREAD,
|
|
} mail_async_event_t;
|
|
|
|
typedef void (*MailAsyncFunc)(void *, void *, void *);
|
|
|
|
/* create a new async event handler */
|
|
MailAsyncEvent *mail_async_event_new(void);
|
|
/* forward a camel event (or other call) to the gui thread */
|
|
int mail_async_event_emit(MailAsyncEvent *ea, mail_async_event_t type, MailAsyncFunc func, void *, void *, void *);
|
|
/* wait for all outstanding async events to complete */
|
|
int mail_async_event_destroy(MailAsyncEvent *ea);
|
|
|
|
/* Call a function in the gui thread, wait for it to return, type is the marshaller to use */
|
|
typedef enum {
|
|
MAIL_CALL_p_p,
|
|
MAIL_CALL_p_pp,
|
|
MAIL_CALL_p_ppp,
|
|
MAIL_CALL_p_pppp,
|
|
MAIL_CALL_p_ppippp,
|
|
} mail_call_t;
|
|
|
|
typedef void *(*MailMainFunc)();
|
|
|
|
void *mail_call_main(mail_call_t type, MailMainFunc func, ...);
|
|
|
|
/* a message port that receives messages in the gui thread, used for sending port */
|
|
extern EMsgPort *mail_gui_port;
|
|
/* a message port that receives messages in the gui thread, used for the reply port */
|
|
extern EMsgPort *mail_gui_reply_port;
|
|
|
|
/* some globally available threads */
|
|
extern EThread *mail_thread_queued; /* for operations that can (or should) be queued */
|
|
extern EThread *mail_thread_new; /* for operations that should run in a new thread each time */
|
|
extern EThread *mail_thread_queued_slow; /* for operations that can (or should) be queued, but take a long time */
|
|
|
|
/* The main thread. */
|
|
extern pthread_t mail_gui_thread;
|
|
|
|
/* A generic proxy event for anything that can be proxied during the life of the mailer (almost nothing) */
|
|
/* Note that almost all objects care about the lifecycle of their events, so this cannot be used */
|
|
extern MailAsyncEvent *mail_async_event;
|
|
|
|
#endif /* ! _MAIL_MT */
|