7151 lines
206 KiB
Diff
7151 lines
206 KiB
Diff
--- evolution-2.11.3/mail/mail-send-recv.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-send-recv.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -764,23 +764,22 @@ receive_get_folder(CamelFilterDriver *d,
|
||
/* ********************************************************************** */
|
||
|
||
struct _refresh_folders_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
struct _send_info *info;
|
||
GPtrArray *folders;
|
||
CamelStore *store;
|
||
};
|
||
|
||
-static char *
|
||
-refresh_folders_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+refresh_folders_desc (struct _refresh_folders_msg *m)
|
||
{
|
||
return g_strdup_printf(_("Checking for new mail"));
|
||
}
|
||
|
||
static void
|
||
-refresh_folders_get (struct _mail_msg *mm)
|
||
+refresh_folders_exec (struct _refresh_folders_msg *m)
|
||
{
|
||
- struct _refresh_folders_msg *m = (struct _refresh_folders_msg *)mm;
|
||
int i;
|
||
CamelFolder *folder;
|
||
CamelException ex = CAMEL_EXCEPTION_INITIALISER;
|
||
@@ -802,17 +801,14 @@ refresh_folders_get (struct _mail_msg *m
|
||
}
|
||
|
||
static void
|
||
-refresh_folders_got (struct _mail_msg *mm)
|
||
+refresh_folders_done (struct _refresh_folders_msg *m)
|
||
{
|
||
- struct _refresh_folders_msg *m = (struct _refresh_folders_msg *)mm;
|
||
-
|
||
receive_done("", m->info);
|
||
}
|
||
|
||
static void
|
||
-refresh_folders_free (struct _mail_msg *mm)
|
||
+refresh_folders_free (struct _refresh_folders_msg *m)
|
||
{
|
||
- struct _refresh_folders_msg *m = (struct _refresh_folders_msg *)mm;
|
||
int i;
|
||
|
||
for (i=0;i<m->folders->len;i++)
|
||
@@ -821,11 +817,12 @@ refresh_folders_free (struct _mail_msg *
|
||
camel_object_unref(m->store);
|
||
}
|
||
|
||
-static struct _mail_msg_op refresh_folders_op = {
|
||
- refresh_folders_desc,
|
||
- refresh_folders_get,
|
||
- refresh_folders_got,
|
||
- refresh_folders_free,
|
||
+static MailMsgInfo refresh_folders_info = {
|
||
+ sizeof (struct _refresh_folders_msg),
|
||
+ (MailMsgDescFunc) refresh_folders_desc,
|
||
+ (MailMsgExecFunc) refresh_folders_exec,
|
||
+ (MailMsgDoneFunc) refresh_folders_done,
|
||
+ (MailMsgFreeFunc) refresh_folders_free
|
||
};
|
||
|
||
static void
|
||
@@ -858,13 +855,13 @@ receive_update_got_folderinfo(CamelStore
|
||
|
||
get_folders(store, folders, info);
|
||
|
||
- m = mail_msg_new(&refresh_folders_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&refresh_folders_info);
|
||
m->store = store;
|
||
camel_object_ref(store);
|
||
m->folders = folders;
|
||
m->info = sinfo;
|
||
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
} else {
|
||
receive_done ("", data);
|
||
}
|
||
--- evolution-2.11.3/mail/mail-component.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-component.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -1014,7 +1014,7 @@ impl_handleURI (PortableServer_Servant s
|
||
if (camel_url_get_param(url, "uid") != NULL) {
|
||
char *curi = em_uri_to_camel(uri);
|
||
|
||
- mail_get_folder(curi, 0, handleuri_got_folder, url, mail_thread_new);
|
||
+ mail_get_folder(curi, 0, handleuri_got_folder, url, mail_msg_unordered_push);
|
||
g_free(curi);
|
||
} else {
|
||
g_warning("email uri's must include a uid parameter");
|
||
--- evolution-2.11.3/mail/mail-ops.c.kill-ethread 2007-06-01 03:08:56.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-ops.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -75,7 +75,7 @@
|
||
/* used for both just filtering a folder + uid's, and for filtering a whole folder */
|
||
/* used both for fetching mail, and for filtering mail */
|
||
struct _filter_mail_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *source_folder; /* where they come from */
|
||
GPtrArray *source_uids; /* uids to copy, or NULL == copy all */
|
||
@@ -99,8 +99,8 @@ struct _fetch_mail_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-em_filter_folder_element_describe (struct _mail_msg *mm, int complete)
|
||
+static gchar *
|
||
+em_filter_folder_element_desc (struct _filter_mail_msg *m)
|
||
{
|
||
return g_strdup (_("Filtering Selected Messages"));
|
||
}
|
||
@@ -108,9 +108,8 @@ em_filter_folder_element_describe (struc
|
||
/* filter a folder, or a subset thereof, uses source_folder/source_uids */
|
||
/* this is shared with fetch_mail */
|
||
static void
|
||
-em_filter_folder_element_filter (struct _mail_msg *mm)
|
||
+em_filter_folder_element_exec (struct _filter_mail_msg *m)
|
||
{
|
||
- struct _filter_mail_msg *m = (struct _filter_mail_msg *)mm;
|
||
CamelFolder *folder;
|
||
GPtrArray *uids, *folder_uids = NULL;
|
||
|
||
@@ -137,15 +136,15 @@ em_filter_folder_element_filter (struct
|
||
else
|
||
folder_uids = uids = camel_folder_get_uids (folder);
|
||
|
||
- camel_filter_driver_filter_folder (m->driver, folder, m->cache, uids, m->delete, &mm->ex);
|
||
- camel_filter_driver_flush (m->driver, &mm->ex);
|
||
+ camel_filter_driver_filter_folder (m->driver, folder, m->cache, uids, m->delete, &m->base.ex);
|
||
+ camel_filter_driver_flush (m->driver, &m->base.ex);
|
||
|
||
if (folder_uids)
|
||
camel_folder_free_uids (folder, folder_uids);
|
||
|
||
/* sync our source folder */
|
||
if (!m->cache)
|
||
- camel_folder_sync (folder, FALSE, camel_exception_is_set (&mm->ex) ? NULL : &mm->ex);
|
||
+ camel_folder_sync (folder, FALSE, camel_exception_is_set (&m->base.ex) ? NULL : &m->base.ex);
|
||
camel_folder_thaw (folder);
|
||
|
||
if (m->destination)
|
||
@@ -161,15 +160,13 @@ em_filter_folder_element_filter (struct
|
||
}
|
||
|
||
static void
|
||
-em_filter_folder_element_filtered (struct _mail_msg *mm)
|
||
+em_filter_folder_element_done (struct _filter_mail_msg *m)
|
||
{
|
||
}
|
||
|
||
static void
|
||
-em_filter_folder_element_free (struct _mail_msg *mm)
|
||
+em_filter_folder_element_free (struct _filter_mail_msg *m)
|
||
{
|
||
- struct _filter_mail_msg *m = (struct _filter_mail_msg *)mm;
|
||
-
|
||
if (m->source_folder)
|
||
camel_object_unref (m->source_folder);
|
||
|
||
@@ -188,11 +185,12 @@ em_filter_folder_element_free (struct _m
|
||
mail_session_flush_filter_log ();
|
||
}
|
||
|
||
-static struct _mail_msg_op em_filter_folder_element_op = {
|
||
- em_filter_folder_element_describe, /* we do our own progress reporting? */
|
||
- em_filter_folder_element_filter,
|
||
- em_filter_folder_element_filtered,
|
||
- em_filter_folder_element_free,
|
||
+static MailMsgInfo em_filter_folder_element_info = {
|
||
+ sizeof (struct _filter_mail_msg),
|
||
+ (MailMsgDescFunc) em_filter_folder_element_desc, /* we do our own progress reporting? */
|
||
+ (MailMsgExecFunc) em_filter_folder_element_exec,
|
||
+ (MailMsgDoneFunc) em_filter_folder_element_done,
|
||
+ (MailMsgFreeFunc) em_filter_folder_element_free
|
||
};
|
||
|
||
void
|
||
@@ -202,7 +200,7 @@ mail_filter_folder (CamelFolder *source_
|
||
{
|
||
struct _filter_mail_msg *m;
|
||
|
||
- m = mail_msg_new (&em_filter_folder_element_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new (&em_filter_folder_element_info);
|
||
m->source_folder = source_folder;
|
||
camel_object_ref (source_folder);
|
||
m->source_uids = uids;
|
||
@@ -221,7 +219,7 @@ mail_filter_folder (CamelFolder *source_
|
||
camel_filter_driver_remove_rule_by_name (m->driver, "new-mail-notification");
|
||
}
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
/* convenience functions for it */
|
||
@@ -260,17 +258,16 @@ uid_cachename_hack (CamelStore *store)
|
||
return filename;
|
||
}
|
||
|
||
-static char *
|
||
-fetch_mail_describe (struct _mail_msg *mm, int complete)
|
||
+static gchar *
|
||
+fetch_mail_desc (struct _fetch_mail_msg *m)
|
||
{
|
||
return g_strdup (_("Fetching Mail"));
|
||
}
|
||
|
||
static void
|
||
-fetch_mail_fetch (struct _mail_msg *mm)
|
||
+fetch_mail_exec (struct _fetch_mail_msg *m)
|
||
{
|
||
- struct _fetch_mail_msg *m = (struct _fetch_mail_msg *)mm;
|
||
- struct _filter_mail_msg *fm = (struct _filter_mail_msg *)mm;
|
||
+ struct _filter_mail_msg *fm = (struct _filter_mail_msg *)m;
|
||
int i;
|
||
|
||
if (m->cancel)
|
||
@@ -283,20 +280,20 @@ fetch_mail_fetch (struct _mail_msg *mm)
|
||
/* FIXME: this should support keep_on_server too, which would then perform a spool
|
||
access thingy, right? problem is matching raw messages to uid's etc. */
|
||
if (!strncmp (m->source_uri, "mbox:", 5)) {
|
||
- char *path = mail_tool_do_movemail (m->source_uri, &mm->ex);
|
||
+ char *path = mail_tool_do_movemail (m->source_uri, &fm->base.ex);
|
||
|
||
- if (path && !camel_exception_is_set (&mm->ex)) {
|
||
+ if (path && !camel_exception_is_set (&fm->base.ex)) {
|
||
camel_folder_freeze (fm->destination);
|
||
camel_filter_driver_set_default_folder (fm->driver, fm->destination);
|
||
- camel_filter_driver_filter_mbox (fm->driver, path, m->source_uri, &mm->ex);
|
||
+ camel_filter_driver_filter_mbox (fm->driver, path, m->source_uri, &fm->base.ex);
|
||
camel_folder_thaw (fm->destination);
|
||
|
||
- if (!camel_exception_is_set (&mm->ex))
|
||
+ if (!camel_exception_is_set (&fm->base.ex))
|
||
g_unlink (path);
|
||
}
|
||
g_free (path);
|
||
} else {
|
||
- CamelFolder *folder = fm->source_folder = mail_tool_get_inbox (m->source_uri, &mm->ex);
|
||
+ CamelFolder *folder = fm->source_folder = mail_tool_get_inbox (m->source_uri, &fm->base.ex);
|
||
|
||
if (folder) {
|
||
/* this handles 'keep on server' stuff, if we have any new uid's to copy
|
||
@@ -322,17 +319,17 @@ fetch_mail_fetch (struct _mail_msg *mm)
|
||
camel_uid_cache_free_uids (cache_uids);
|
||
|
||
fm->cache = cache;
|
||
- em_filter_folder_element_filter (mm);
|
||
+ em_filter_folder_element_exec (&fm->base);
|
||
|
||
/* need to uncancel so writes/etc. don't fail */
|
||
- if (mm->ex.id == CAMEL_EXCEPTION_USER_CANCEL)
|
||
+ if (fm->base.ex.id == CAMEL_EXCEPTION_USER_CANCEL)
|
||
camel_operation_uncancel(NULL);
|
||
|
||
/* save the cache of uids that we've just downloaded */
|
||
camel_uid_cache_save (cache);
|
||
}
|
||
|
||
- if (fm->delete && mm->ex.id == CAMEL_EXCEPTION_NONE) {
|
||
+ if (fm->delete && fm->base.ex.id == CAMEL_EXCEPTION_NONE) {
|
||
/* not keep on server - just delete all the actual messages on the server */
|
||
for (i=0;i<folder_uids->len;i++) {
|
||
d(printf("force delete uid '%s'\n", (char *)folder_uids->pdata[i]));
|
||
@@ -348,7 +345,7 @@ fetch_mail_fetch (struct _mail_msg *mm)
|
||
camel_uid_cache_destroy (cache);
|
||
camel_folder_free_uids (folder, folder_uids);
|
||
} else {
|
||
- em_filter_folder_element_filter (mm);
|
||
+ em_filter_folder_element_exec (&fm->base);
|
||
}
|
||
|
||
/* we unref the source folder here since we
|
||
@@ -372,31 +369,28 @@ fail:
|
||
}
|
||
|
||
static void
|
||
-fetch_mail_fetched (struct _mail_msg *mm)
|
||
+fetch_mail_done (struct _fetch_mail_msg *m)
|
||
{
|
||
- struct _fetch_mail_msg *m = (struct _fetch_mail_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done (m->source_uri, m->data);
|
||
}
|
||
|
||
static void
|
||
-fetch_mail_free (struct _mail_msg *mm)
|
||
+fetch_mail_free (struct _fetch_mail_msg *m)
|
||
{
|
||
- struct _fetch_mail_msg *m = (struct _fetch_mail_msg *)mm;
|
||
-
|
||
g_free (m->source_uri);
|
||
if (m->cancel)
|
||
camel_operation_unref (m->cancel);
|
||
|
||
- em_filter_folder_element_free (mm);
|
||
+ em_filter_folder_element_free (&m->fmsg.base);
|
||
}
|
||
|
||
-static struct _mail_msg_op fetch_mail_op = {
|
||
- fetch_mail_describe, /* we do our own progress reporting */
|
||
- fetch_mail_fetch,
|
||
- fetch_mail_fetched,
|
||
- fetch_mail_free,
|
||
+static MailMsgInfo fetch_mail_info = {
|
||
+ sizeof (struct _fetch_mail_msg),
|
||
+ (MailMsgDescFunc) fetch_mail_desc,
|
||
+ (MailMsgExecFunc) fetch_mail_exec,
|
||
+ (MailMsgDoneFunc) fetch_mail_done,
|
||
+ (MailMsgFreeFunc) fetch_mail_free
|
||
};
|
||
|
||
/* ouch, a 'do everything' interface ... */
|
||
@@ -409,7 +403,7 @@ mail_fetch_mail (const char *source, int
|
||
struct _fetch_mail_msg *m;
|
||
struct _filter_mail_msg *fm;
|
||
|
||
- m = mail_msg_new (&fetch_mail_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new (&fetch_mail_info);
|
||
fm = (struct _filter_mail_msg *)m;
|
||
m->source_uri = g_strdup (source);
|
||
fm->delete = !keep;
|
||
@@ -426,7 +420,7 @@ mail_fetch_mail (const char *source, int
|
||
if (status)
|
||
camel_filter_driver_set_status_func (fm->driver, status, status_data);
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
/* ********************************************************************** */
|
||
@@ -657,7 +651,7 @@ exit:
|
||
/* ** SEND MAIL QUEUE ***************************************************** */
|
||
|
||
struct _send_queue_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *queue;
|
||
char *destination;
|
||
@@ -689,9 +683,8 @@ report_status (struct _send_queue_msg *m
|
||
}
|
||
|
||
static void
|
||
-send_queue_send(struct _mail_msg *mm)
|
||
+send_queue_exec (struct _send_queue_msg *m)
|
||
{
|
||
- struct _send_queue_msg *m = (struct _send_queue_msg *)mm;
|
||
CamelFolder *sent_folder = mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_SENT);
|
||
GPtrArray *uids, *send_uids = NULL;
|
||
CamelException ex;
|
||
@@ -739,17 +732,17 @@ send_queue_send(struct _mail_msg *mm)
|
||
if (camel_exception_is_set (&ex)) {
|
||
if (ex.id != CAMEL_EXCEPTION_USER_CANCEL) {
|
||
/* merge exceptions into one */
|
||
- if (camel_exception_is_set (&mm->ex))
|
||
- camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM, "%s\n\n%s", mm->ex.desc, ex.desc);
|
||
+ if (camel_exception_is_set (&m->base.ex))
|
||
+ camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM, "%s\n\n%s", m->base.ex.desc, ex.desc);
|
||
else
|
||
- camel_exception_xfer (&mm->ex, &ex);
|
||
+ camel_exception_xfer (&m->base.ex, &ex);
|
||
camel_exception_clear (&ex);
|
||
|
||
/* keep track of the number of failures */
|
||
j++;
|
||
} else {
|
||
/* transfer the USER_CANCEL exeption to the async op exception and then break */
|
||
- camel_exception_xfer (&mm->ex, &ex);
|
||
+ camel_exception_xfer (&m->base.ex, &ex);
|
||
break;
|
||
}
|
||
}
|
||
@@ -759,7 +752,7 @@ send_queue_send(struct _mail_msg *mm)
|
||
|
||
if (j > 0)
|
||
report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Failed to send %d of %d messages"), j, send_uids->len);
|
||
- else if (mm->ex.id == CAMEL_EXCEPTION_USER_CANCEL)
|
||
+ else if (m->base.ex.id == CAMEL_EXCEPTION_USER_CANCEL)
|
||
report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Canceled."));
|
||
else
|
||
report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Complete."));
|
||
@@ -785,19 +778,15 @@ send_queue_send(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-send_queue_sent(struct _mail_msg *mm)
|
||
+send_queue_done (struct _send_queue_msg *m)
|
||
{
|
||
- struct _send_queue_msg *m = (struct _send_queue_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->destination, m->data);
|
||
}
|
||
|
||
static void
|
||
-send_queue_free(struct _mail_msg *mm)
|
||
+send_queue_free (struct _send_queue_msg *m)
|
||
{
|
||
- struct _send_queue_msg *m = (struct _send_queue_msg *)mm;
|
||
-
|
||
if (m->driver)
|
||
camel_object_unref(m->driver);
|
||
camel_object_unref(m->queue);
|
||
@@ -806,11 +795,12 @@ send_queue_free(struct _mail_msg *mm)
|
||
camel_operation_unref(m->cancel);
|
||
}
|
||
|
||
-static struct _mail_msg_op send_queue_op = {
|
||
- NULL, /* do our own reporting, as with fetch mail */
|
||
- send_queue_send,
|
||
- send_queue_sent,
|
||
- send_queue_free,
|
||
+static MailMsgInfo send_queue_info = {
|
||
+ sizeof (struct _send_queue_msg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) send_queue_exec,
|
||
+ (MailMsgDoneFunc) send_queue_done,
|
||
+ (MailMsgFreeFunc) send_queue_free
|
||
};
|
||
|
||
/* same interface as fetch_mail, just 'cause i'm lazy today (and we need to run it from the same spot?) */
|
||
@@ -823,7 +813,7 @@ mail_send_queue(CamelFolder *queue, cons
|
||
{
|
||
struct _send_queue_msg *m;
|
||
|
||
- m = mail_msg_new(&send_queue_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&send_queue_info);
|
||
m->queue = queue;
|
||
camel_object_ref(queue);
|
||
m->destination = g_strdup(destination);
|
||
@@ -839,13 +829,13 @@ mail_send_queue(CamelFolder *queue, cons
|
||
m->driver = camel_session_get_filter_driver (session, type, NULL);
|
||
camel_filter_driver_set_folder_func (m->driver, get_folder, get_data);
|
||
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
/* ** APPEND MESSAGE TO FOLDER ******************************************** */
|
||
|
||
struct _append_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *folder;
|
||
CamelMimeMessage *message;
|
||
@@ -856,45 +846,40 @@ struct _append_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-append_mail_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+append_mail_desc (struct _append_msg *m)
|
||
{
|
||
return g_strdup (_("Saving message to folder"));
|
||
}
|
||
|
||
static void
|
||
-append_mail_append (struct _mail_msg *mm)
|
||
+append_mail_exec (struct _append_msg *m)
|
||
{
|
||
- struct _append_msg *m = (struct _append_msg *)mm;
|
||
-
|
||
camel_mime_message_set_date(m->message, CAMEL_MESSAGE_DATE_CURRENT, 0);
|
||
- camel_folder_append_message(m->folder, m->message, m->info, &m->appended_uid, &mm->ex);
|
||
+ camel_folder_append_message(m->folder, m->message, m->info, &m->appended_uid, &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-append_mail_appended (struct _mail_msg *mm)
|
||
+append_mail_done (struct _append_msg *m)
|
||
{
|
||
- struct _append_msg *m = (struct _append_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
- m->done(m->folder, m->message, m->info, !camel_exception_is_set(&mm->ex), m->appended_uid, m->data);
|
||
+ m->done(m->folder, m->message, m->info, !camel_exception_is_set(&m->base.ex), m->appended_uid, m->data);
|
||
}
|
||
|
||
static void
|
||
-append_mail_free (struct _mail_msg *mm)
|
||
+append_mail_free (struct _append_msg *m)
|
||
{
|
||
- struct _append_msg *m = (struct _append_msg *)mm;
|
||
-
|
||
camel_object_unref(m->message);
|
||
camel_object_unref(m->folder);
|
||
g_free (m->appended_uid);
|
||
}
|
||
|
||
-static struct _mail_msg_op append_mail_op = {
|
||
- append_mail_desc,
|
||
- append_mail_append,
|
||
- append_mail_appended,
|
||
- append_mail_free
|
||
+static MailMsgInfo append_mail_info = {
|
||
+ sizeof (struct _append_msg),
|
||
+ (MailMsgDescFunc) append_mail_desc,
|
||
+ (MailMsgExecFunc) append_mail_exec,
|
||
+ (MailMsgDoneFunc) append_mail_done,
|
||
+ (MailMsgFreeFunc) append_mail_free
|
||
};
|
||
|
||
void
|
||
@@ -911,7 +896,7 @@ mail_append_mail (CamelFolder *folder, C
|
||
camel_medium_set_header (CAMEL_MEDIUM (message), "X-Mailer",
|
||
"Evolution " VERSION SUB_VERSION " " VERSION_COMMENT);
|
||
|
||
- m = mail_msg_new (&append_mail_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new (&append_mail_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->message = message;
|
||
@@ -921,13 +906,13 @@ mail_append_mail (CamelFolder *folder, C
|
||
m->done = done;
|
||
m->data = data;
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
/* ** TRANSFER MESSAGES **************************************************** */
|
||
|
||
struct _transfer_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *source;
|
||
GPtrArray *uids;
|
||
@@ -939,24 +924,21 @@ struct _transfer_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-transfer_messages_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+transfer_messages_desc (struct _transfer_msg *m)
|
||
{
|
||
- struct _transfer_msg *m = (struct _transfer_msg *)mm;
|
||
-
|
||
return g_strdup_printf(m->delete?_("Moving messages to %s"):_("Copying messages to %s"),
|
||
m->dest_uri);
|
||
|
||
}
|
||
|
||
static void
|
||
-transfer_messages_transfer (struct _mail_msg *mm)
|
||
+transfer_messages_exec (struct _transfer_msg *m)
|
||
{
|
||
- struct _transfer_msg *m = (struct _transfer_msg *)mm;
|
||
CamelFolder *dest;
|
||
|
||
- dest = mail_tool_uri_to_folder (m->dest_uri, m->dest_flags, &mm->ex);
|
||
- if (camel_exception_is_set (&mm->ex))
|
||
+ dest = mail_tool_uri_to_folder (m->dest_uri, m->dest_flags, &m->base.ex);
|
||
+ if (camel_exception_is_set (&m->base.ex))
|
||
return;
|
||
|
||
if (dest == m->source) {
|
||
@@ -968,7 +950,7 @@ transfer_messages_transfer (struct _mail
|
||
camel_folder_freeze (m->source);
|
||
camel_folder_freeze (dest);
|
||
|
||
- camel_folder_transfer_messages_to (m->source, m->uids, dest, NULL, m->delete, &mm->ex);
|
||
+ camel_folder_transfer_messages_to (m->source, m->uids, dest, NULL, m->delete, &m->base.ex);
|
||
|
||
/* make sure all deleted messages are marked as seen */
|
||
|
||
@@ -987,29 +969,26 @@ transfer_messages_transfer (struct _mail
|
||
}
|
||
|
||
static void
|
||
-transfer_messages_transferred (struct _mail_msg *mm)
|
||
+transfer_messages_done (struct _transfer_msg *m)
|
||
{
|
||
- struct _transfer_msg *m = (struct _transfer_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
- m->done (!camel_exception_is_set (&mm->ex), m->data);
|
||
+ m->done (!camel_exception_is_set (&m->base.ex), m->data);
|
||
}
|
||
|
||
static void
|
||
-transfer_messages_free (struct _mail_msg *mm)
|
||
+transfer_messages_free (struct _transfer_msg *m)
|
||
{
|
||
- struct _transfer_msg *m = (struct _transfer_msg *)mm;
|
||
-
|
||
camel_object_unref (m->source);
|
||
g_free (m->dest_uri);
|
||
em_utils_uids_free (m->uids);
|
||
}
|
||
|
||
-static struct _mail_msg_op transfer_messages_op = {
|
||
- transfer_messages_desc,
|
||
- transfer_messages_transfer,
|
||
- transfer_messages_transferred,
|
||
- transfer_messages_free,
|
||
+static MailMsgInfo transfer_messages_info = {
|
||
+ sizeof (struct _transfer_msg),
|
||
+ (MailMsgDescFunc) transfer_messages_desc,
|
||
+ (MailMsgExecFunc) transfer_messages_exec,
|
||
+ (MailMsgDoneFunc) transfer_messages_done,
|
||
+ (MailMsgFreeFunc) transfer_messages_free
|
||
};
|
||
|
||
void
|
||
@@ -1026,7 +1005,7 @@ mail_transfer_messages (CamelFolder *sou
|
||
g_assert(uids != NULL);
|
||
g_assert(dest_uri != NULL);
|
||
|
||
- m = mail_msg_new(&transfer_messages_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&transfer_messages_info);
|
||
m->source = source;
|
||
camel_object_ref (source);
|
||
m->uids = uids;
|
||
@@ -1036,13 +1015,13 @@ mail_transfer_messages (CamelFolder *sou
|
||
m->done = done;
|
||
m->data = data;
|
||
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
/* ** SCAN SUBFOLDERS ***************************************************** */
|
||
|
||
struct _get_folderinfo_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelStore *store;
|
||
CamelFolderInfo *info;
|
||
@@ -1050,10 +1029,9 @@ struct _get_folderinfo_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-get_folderinfo_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+get_folderinfo_desc (struct _get_folderinfo_msg *m)
|
||
{
|
||
- struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
|
||
char *ret, *name;
|
||
|
||
name = camel_service_get_name((CamelService *)m->store, TRUE);
|
||
@@ -1063,25 +1041,22 @@ get_folderinfo_desc (struct _mail_msg *m
|
||
}
|
||
|
||
static void
|
||
-get_folderinfo_get (struct _mail_msg *mm)
|
||
+get_folderinfo_exec (struct _get_folderinfo_msg *m)
|
||
{
|
||
- struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
|
||
guint32 flags = CAMEL_STORE_FOLDER_INFO_RECURSIVE|CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;
|
||
|
||
- m->info = camel_store_get_folder_info (m->store, NULL, flags, &mm->ex);
|
||
+ m->info = camel_store_get_folder_info (m->store, NULL, flags, &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-get_folderinfo_got (struct _mail_msg *mm)
|
||
+get_folderinfo_done (struct _get_folderinfo_msg *m)
|
||
{
|
||
- struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
|
||
-
|
||
- if (!m->info && camel_exception_is_set (&mm->ex)) {
|
||
+ if (!m->info && camel_exception_is_set (&m->base.ex)) {
|
||
char *url;
|
||
|
||
url = camel_service_get_url (CAMEL_SERVICE (m->store));
|
||
w(g_warning ("Error getting folder info from store at %s: %s",
|
||
- url, camel_exception_get_description (&mm->ex)));
|
||
+ url, camel_exception_get_description (&m->base.ex)));
|
||
g_free (url);
|
||
}
|
||
|
||
@@ -1090,20 +1065,19 @@ get_folderinfo_got (struct _mail_msg *mm
|
||
}
|
||
|
||
static void
|
||
-get_folderinfo_free (struct _mail_msg *mm)
|
||
+get_folderinfo_free (struct _get_folderinfo_msg *m)
|
||
{
|
||
- struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
|
||
-
|
||
if (m->info)
|
||
camel_store_free_folder_info(m->store, m->info);
|
||
camel_object_unref(m->store);
|
||
}
|
||
|
||
-static struct _mail_msg_op get_folderinfo_op = {
|
||
- get_folderinfo_desc,
|
||
- get_folderinfo_get,
|
||
- get_folderinfo_got,
|
||
- get_folderinfo_free,
|
||
+static MailMsgInfo get_folderinfo_info = {
|
||
+ sizeof (struct _get_folderinfo_msg),
|
||
+ (MailMsgDescFunc) get_folderinfo_desc,
|
||
+ (MailMsgExecFunc) get_folderinfo_exec,
|
||
+ (MailMsgDoneFunc) get_folderinfo_done,
|
||
+ (MailMsgFreeFunc) get_folderinfo_free
|
||
};
|
||
|
||
int
|
||
@@ -1112,19 +1086,19 @@ mail_get_folderinfo (CamelStore *store,
|
||
struct _get_folderinfo_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&get_folderinfo_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&get_folderinfo_info);
|
||
if (op) {
|
||
- camel_operation_unref(m->msg.cancel);
|
||
- m->msg.cancel = op;
|
||
+ camel_operation_unref(m->base.cancel);
|
||
+ m->base.cancel = op;
|
||
camel_operation_ref(op);
|
||
}
|
||
m->store = store;
|
||
camel_object_ref(store);
|
||
m->done = done;
|
||
m->data = data;
|
||
- id = m->msg.seq;
|
||
+ id = m->base.seq;
|
||
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -1196,7 +1170,7 @@ mail_build_attachment(CamelFolder *folde
|
||
presumably create a folder ... */
|
||
|
||
struct _get_folder_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
char *uri;
|
||
guint32 flags;
|
||
@@ -1205,71 +1179,64 @@ struct _get_folder_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-get_folder_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+get_folder_desc (struct _get_folder_msg *m)
|
||
{
|
||
- struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
|
||
-
|
||
return g_strdup_printf(_("Opening folder %s"), m->uri);
|
||
}
|
||
|
||
static void
|
||
-get_folder_get (struct _mail_msg *mm)
|
||
+get_folder_exec (struct _get_folder_msg *m)
|
||
{
|
||
- struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
|
||
-
|
||
- m->folder = mail_tool_uri_to_folder (m->uri, m->flags, &mm->ex);
|
||
+ m->folder = mail_tool_uri_to_folder (m->uri, m->flags, &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-get_folder_got (struct _mail_msg *mm)
|
||
+get_folder_done (struct _get_folder_msg *m)
|
||
{
|
||
- struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done (m->uri, m->folder, m->data);
|
||
}
|
||
|
||
static void
|
||
-get_folder_free (struct _mail_msg *mm)
|
||
+get_folder_free (struct _get_folder_msg *m)
|
||
{
|
||
- struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
|
||
-
|
||
g_free (m->uri);
|
||
if (m->folder)
|
||
camel_object_unref (m->folder);
|
||
}
|
||
|
||
-static struct _mail_msg_op get_folder_op = {
|
||
- get_folder_desc,
|
||
- get_folder_get,
|
||
- get_folder_got,
|
||
- get_folder_free,
|
||
+static MailMsgInfo get_folder_info = {
|
||
+ sizeof (struct _get_folder_msg),
|
||
+ (MailMsgDescFunc) get_folder_desc,
|
||
+ (MailMsgExecFunc) get_folder_exec,
|
||
+ (MailMsgDoneFunc) get_folder_done,
|
||
+ (MailMsgFreeFunc) get_folder_free
|
||
};
|
||
|
||
int
|
||
mail_get_folder (const char *uri, guint32 flags,
|
||
void (*done)(char *uri, CamelFolder *folder, void *data),
|
||
- void *data, EThread *thread)
|
||
+ void *data, MailMsgDispatchFunc dispatch)
|
||
{
|
||
struct _get_folder_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&get_folder_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&get_folder_info);
|
||
m->uri = g_strdup (uri);
|
||
m->flags = flags;
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(thread, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ dispatch (m);
|
||
return id;
|
||
}
|
||
|
||
/* ** GET STORE ******************************************************* */
|
||
|
||
struct _get_store_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
char *uri;
|
||
CamelStore *store;
|
||
@@ -1277,50 +1244,43 @@ struct _get_store_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-get_store_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+get_store_desc (struct _get_store_msg *m)
|
||
{
|
||
- struct _get_store_msg *m = (struct _get_store_msg *)mm;
|
||
-
|
||
return g_strdup_printf(_("Opening store %s"), m->uri);
|
||
}
|
||
|
||
static void
|
||
-get_store_get (struct _mail_msg *mm)
|
||
+get_store_exec (struct _get_store_msg *m)
|
||
{
|
||
- struct _get_store_msg *m = (struct _get_store_msg *)mm;
|
||
-
|
||
/*camel_session_get_store connects us, which we don't want to do on startup. */
|
||
|
||
m->store = (CamelStore *) camel_session_get_service (session, m->uri,
|
||
CAMEL_PROVIDER_STORE,
|
||
- &mm->ex);
|
||
+ &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-get_store_got (struct _mail_msg *mm)
|
||
+get_store_done (struct _get_store_msg *m)
|
||
{
|
||
- struct _get_store_msg *m = (struct _get_store_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done (m->uri, m->store, m->data);
|
||
}
|
||
|
||
static void
|
||
-get_store_free (struct _mail_msg *mm)
|
||
+get_store_free (struct _get_store_msg *m)
|
||
{
|
||
- struct _get_store_msg *m = (struct _get_store_msg *)mm;
|
||
-
|
||
g_free (m->uri);
|
||
if (m->store)
|
||
camel_object_unref (m->store);
|
||
}
|
||
|
||
-static struct _mail_msg_op get_store_op = {
|
||
- get_store_desc,
|
||
- get_store_get,
|
||
- get_store_got,
|
||
- get_store_free,
|
||
+static MailMsgInfo get_store_info = {
|
||
+ sizeof (struct _get_store_msg),
|
||
+ (MailMsgDescFunc) get_store_desc,
|
||
+ (MailMsgExecFunc) get_store_exec,
|
||
+ (MailMsgDoneFunc) get_store_done,
|
||
+ (MailMsgFreeFunc) get_store_free
|
||
};
|
||
|
||
int
|
||
@@ -1329,25 +1289,25 @@ mail_get_store (const char *uri, CamelOp
|
||
struct _get_store_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new (&get_store_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new (&get_store_info);
|
||
if (op) {
|
||
- camel_operation_unref(m->msg.cancel);
|
||
- m->msg.cancel = op;
|
||
+ camel_operation_unref(m->base.cancel);
|
||
+ m->base.cancel = op;
|
||
camel_operation_ref(op);
|
||
}
|
||
m->uri = g_strdup (uri);
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
return id;
|
||
}
|
||
|
||
/* ** REMOVE FOLDER ******************************************************* */
|
||
|
||
struct _remove_folder_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
char *uri;
|
||
gboolean removed;
|
||
@@ -1355,18 +1315,15 @@ struct _remove_folder_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-remove_folder_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+remove_folder_desc (struct _remove_folder_msg *m)
|
||
{
|
||
- struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
|
||
-
|
||
return g_strdup_printf (_("Removing folder %s"), m->uri);
|
||
}
|
||
|
||
static void
|
||
-remove_folder_get (struct _mail_msg *mm)
|
||
+remove_folder_exec (struct _remove_folder_msg *m)
|
||
{
|
||
- struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
|
||
CamelStore *store;
|
||
CamelFolder *folder;
|
||
GPtrArray *uids;
|
||
@@ -1374,7 +1331,7 @@ remove_folder_get (struct _mail_msg *mm)
|
||
|
||
m->removed = FALSE;
|
||
|
||
- folder = mail_tool_uri_to_folder (m->uri, 0, &mm->ex);
|
||
+ folder = mail_tool_uri_to_folder (m->uri, 0, &m->base.ex);
|
||
if (!folder)
|
||
return;
|
||
|
||
@@ -1394,16 +1351,14 @@ remove_folder_get (struct _mail_msg *mm)
|
||
camel_store_unsubscribe_folder (store, folder->full_name, NULL);
|
||
|
||
/* Then delete the folder from the store */
|
||
- camel_store_delete_folder (store, folder->full_name, &mm->ex);
|
||
- m->removed = !camel_exception_is_set (&mm->ex);
|
||
+ camel_store_delete_folder (store, folder->full_name, &m->base.ex);
|
||
+ m->removed = !camel_exception_is_set (&m->base.ex);
|
||
camel_object_unref (folder);
|
||
}
|
||
|
||
static void
|
||
-remove_folder_got (struct _mail_msg *mm)
|
||
+remove_folder_done (struct _remove_folder_msg *m)
|
||
{
|
||
- struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
|
||
-
|
||
if (m->removed) {
|
||
/* FIXME: Remove this folder from the folder cache ??? */
|
||
}
|
||
@@ -1413,18 +1368,17 @@ remove_folder_got (struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-remove_folder_free (struct _mail_msg *mm)
|
||
+remove_folder_free (struct _remove_folder_msg *m)
|
||
{
|
||
- struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
|
||
-
|
||
g_free (m->uri);
|
||
}
|
||
|
||
-static struct _mail_msg_op remove_folder_op = {
|
||
- remove_folder_desc,
|
||
- remove_folder_get,
|
||
- remove_folder_got,
|
||
- remove_folder_free,
|
||
+static MailMsgInfo remove_folder_info = {
|
||
+ sizeof (struct _remove_folder_msg),
|
||
+ (MailMsgDescFunc) remove_folder_desc,
|
||
+ (MailMsgExecFunc) remove_folder_exec,
|
||
+ (MailMsgDoneFunc) remove_folder_done,
|
||
+ (MailMsgFreeFunc) remove_folder_free
|
||
};
|
||
|
||
void
|
||
@@ -1432,59 +1386,56 @@ mail_remove_folder (const char *uri, voi
|
||
{
|
||
struct _remove_folder_msg *m;
|
||
|
||
- m = mail_msg_new (&remove_folder_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new (&remove_folder_info);
|
||
m->uri = g_strdup (uri);
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
/* ** SYNC FOLDER ********************************************************* */
|
||
|
||
struct _sync_folder_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *folder;
|
||
void (*done) (CamelFolder *folder, void *data);
|
||
void *data;
|
||
};
|
||
|
||
-static char *sync_folder_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+sync_folder_desc (struct _sync_folder_msg *m)
|
||
{
|
||
- struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
|
||
-
|
||
return g_strdup_printf (_("Storing folder \'%s\'"),
|
||
camel_folder_get_full_name (m->folder));
|
||
}
|
||
|
||
-static void sync_folder_sync(struct _mail_msg *mm)
|
||
+static void
|
||
+sync_folder_exec (struct _sync_folder_msg *m)
|
||
{
|
||
- struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
|
||
-
|
||
- camel_folder_sync(m->folder, FALSE, &mm->ex);
|
||
+ camel_folder_sync(m->folder, FALSE, &m->base.ex);
|
||
}
|
||
|
||
-static void sync_folder_synced(struct _mail_msg *mm)
|
||
+static void
|
||
+sync_folder_done (struct _sync_folder_msg *m)
|
||
{
|
||
- struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->folder, m->data);
|
||
}
|
||
|
||
-static void sync_folder_free(struct _mail_msg *mm)
|
||
+static void
|
||
+sync_folder_free (struct _sync_folder_msg *m)
|
||
{
|
||
- struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
|
||
-
|
||
camel_object_unref((CamelObject *)m->folder);
|
||
}
|
||
|
||
-static struct _mail_msg_op sync_folder_op = {
|
||
- sync_folder_desc,
|
||
- sync_folder_sync,
|
||
- sync_folder_synced,
|
||
- sync_folder_free,
|
||
+static MailMsgInfo sync_folder_info = {
|
||
+ sizeof (struct _sync_folder_msg),
|
||
+ (MailMsgDescFunc) sync_folder_desc,
|
||
+ (MailMsgExecFunc) sync_folder_exec,
|
||
+ (MailMsgDoneFunc) sync_folder_done,
|
||
+ (MailMsgFreeFunc) sync_folder_free
|
||
};
|
||
|
||
void
|
||
@@ -1492,19 +1443,19 @@ mail_sync_folder(CamelFolder *folder, vo
|
||
{
|
||
struct _sync_folder_msg *m;
|
||
|
||
- m = mail_msg_new(&sync_folder_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&sync_folder_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
/* ** SYNC STORE ********************************************************* */
|
||
|
||
struct _sync_store_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelStore *store;
|
||
int expunge;
|
||
@@ -1512,9 +1463,9 @@ struct _sync_store_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *sync_store_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+sync_store_desc (struct _sync_store_msg *m)
|
||
{
|
||
- struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
|
||
char *uri, *res;
|
||
|
||
uri = camel_url_to_string(((CamelService *)m->store)->url, CAMEL_URL_HIDE_ALL);
|
||
@@ -1527,33 +1478,31 @@ static char *sync_store_desc(struct _mai
|
||
return res;
|
||
}
|
||
|
||
-static void sync_store_sync(struct _mail_msg *mm)
|
||
+static void
|
||
+sync_store_exec (struct _sync_store_msg *m)
|
||
{
|
||
- struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
|
||
-
|
||
- camel_store_sync(m->store, m->expunge, &mm->ex);
|
||
+ camel_store_sync(m->store, m->expunge, &m->base.ex);
|
||
}
|
||
|
||
-static void sync_store_synced(struct _mail_msg *mm)
|
||
+static void
|
||
+sync_store_done (struct _sync_store_msg *m)
|
||
{
|
||
- struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->store, m->data);
|
||
}
|
||
|
||
-static void sync_store_free(struct _mail_msg *mm)
|
||
+static void
|
||
+sync_store_free (struct _sync_store_msg *m)
|
||
{
|
||
- struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
|
||
-
|
||
camel_object_unref(m->store);
|
||
}
|
||
|
||
-static struct _mail_msg_op sync_store_op = {
|
||
- sync_store_desc,
|
||
- sync_store_sync,
|
||
- sync_store_synced,
|
||
- sync_store_free,
|
||
+static MailMsgInfo sync_store_info = {
|
||
+ sizeof (struct _sync_store_msg),
|
||
+ (MailMsgDescFunc) sync_store_desc,
|
||
+ (MailMsgExecFunc) sync_store_exec,
|
||
+ (MailMsgDoneFunc) sync_store_done,
|
||
+ (MailMsgFreeFunc) sync_store_free
|
||
};
|
||
|
||
void
|
||
@@ -1561,36 +1510,37 @@ mail_sync_store(CamelStore *store, int e
|
||
{
|
||
struct _sync_store_msg *m;
|
||
|
||
- m = mail_msg_new(&sync_store_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&sync_store_info);
|
||
m->store = store;
|
||
m->expunge = expunge;
|
||
camel_object_ref(store);
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
/* ******************************************************************************** */
|
||
|
||
-static char *refresh_folder_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+refresh_folder_desc (struct _sync_folder_msg *m)
|
||
{
|
||
return g_strdup(_("Refreshing folder"));
|
||
}
|
||
|
||
-static void refresh_folder_refresh(struct _mail_msg *mm)
|
||
+static void
|
||
+refresh_folder_exec (struct _sync_folder_msg *m)
|
||
{
|
||
- struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
|
||
-
|
||
- camel_folder_refresh_info(m->folder, &mm->ex);
|
||
+ camel_folder_refresh_info(m->folder, &m->base.ex);
|
||
}
|
||
|
||
/* we just use the sync stuff where we can, since it would be the same */
|
||
-static struct _mail_msg_op refresh_folder_op = {
|
||
- refresh_folder_desc,
|
||
- refresh_folder_refresh,
|
||
- sync_folder_synced,
|
||
- sync_folder_free,
|
||
+static MailMsgInfo refresh_folder_info = {
|
||
+ sizeof (struct _sync_folder_msg),
|
||
+ (MailMsgDescFunc) refresh_folder_desc,
|
||
+ (MailMsgExecFunc) refresh_folder_exec,
|
||
+ (MailMsgDoneFunc) sync_folder_done,
|
||
+ (MailMsgFreeFunc) sync_folder_free
|
||
};
|
||
|
||
void
|
||
@@ -1598,35 +1548,36 @@ mail_refresh_folder(CamelFolder *folder,
|
||
{
|
||
struct _sync_folder_msg *m;
|
||
|
||
- m = mail_msg_new(&refresh_folder_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&refresh_folder_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
/* ******************************************************************************** */
|
||
|
||
-static char *expunge_folder_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+expunge_folder_desc (struct _sync_folder_msg *m)
|
||
{
|
||
return g_strdup(_("Expunging folder"));
|
||
}
|
||
|
||
-static void expunge_folder_expunge(struct _mail_msg *mm)
|
||
+static void
|
||
+expunge_folder_exec (struct _sync_folder_msg *m)
|
||
{
|
||
- struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
|
||
-
|
||
- camel_folder_expunge(m->folder, &mm->ex);
|
||
+ camel_folder_expunge(m->folder, &m->base.ex);
|
||
}
|
||
|
||
/* we just use the sync stuff where we can, since it would be the same */
|
||
-static struct _mail_msg_op expunge_folder_op = {
|
||
- expunge_folder_desc,
|
||
- expunge_folder_expunge,
|
||
- sync_folder_synced,
|
||
- sync_folder_free,
|
||
+static MailMsgInfo expunge_folder_info = {
|
||
+ sizeof (struct _sync_folder_msg),
|
||
+ (MailMsgDescFunc) expunge_folder_desc,
|
||
+ (MailMsgExecFunc) expunge_folder_exec,
|
||
+ (MailMsgDoneFunc) sync_folder_done,
|
||
+ (MailMsgFreeFunc) sync_folder_free
|
||
};
|
||
|
||
void
|
||
@@ -1634,31 +1585,30 @@ mail_expunge_folder(CamelFolder *folder,
|
||
{
|
||
struct _sync_folder_msg *m;
|
||
|
||
- m = mail_msg_new(&expunge_folder_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&expunge_folder_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
/* ******************************************************************************** */
|
||
|
||
struct _empty_trash_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
EAccount *account;
|
||
void (*done) (EAccount *account, void *data);
|
||
void *data;
|
||
};
|
||
|
||
-static char *empty_trash_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+empty_trash_desc (struct _empty_trash_msg *m)
|
||
{
|
||
/* FIXME after 1.4 is out and we're not in string freeze any more. */
|
||
#if 0
|
||
- struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
|
||
-
|
||
return g_strdup_printf (_("Emptying trash in \'%s\'"),
|
||
m->account ? m->account->name : _("Local Folders"));
|
||
#else
|
||
@@ -1666,49 +1616,48 @@ static char *empty_trash_desc(struct _ma
|
||
#endif
|
||
}
|
||
|
||
-static void empty_trash_empty(struct _mail_msg *mm)
|
||
+static void
|
||
+empty_trash_exec (struct _empty_trash_msg *m)
|
||
{
|
||
- struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
|
||
const char *evolution_dir;
|
||
CamelFolder *trash;
|
||
char *uri;
|
||
|
||
if (m->account) {
|
||
- trash = mail_tool_get_trash (m->account->source->url, FALSE, &mm->ex);
|
||
+ trash = mail_tool_get_trash (m->account->source->url, FALSE, &m->base.ex);
|
||
} else {
|
||
evolution_dir = mail_component_peek_base_directory (mail_component_peek ());
|
||
uri = g_strdup_printf ("mbox:%s/mail/local", evolution_dir);
|
||
- trash = mail_tool_get_trash (uri, TRUE, &mm->ex);
|
||
+ trash = mail_tool_get_trash (uri, TRUE, &m->base.ex);
|
||
g_free (uri);
|
||
}
|
||
|
||
if (trash)
|
||
- camel_folder_expunge (trash, &mm->ex);
|
||
+ camel_folder_expunge (trash, &m->base.ex);
|
||
|
||
camel_object_unref (trash);
|
||
}
|
||
|
||
-static void empty_trash_emptied(struct _mail_msg *mm)
|
||
+static void
|
||
+empty_trash_done (struct _empty_trash_msg *m)
|
||
{
|
||
- struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->account, m->data);
|
||
}
|
||
|
||
-static void empty_trash_free(struct _mail_msg *mm)
|
||
+static void
|
||
+empty_trash_free (struct _empty_trash_msg *m)
|
||
{
|
||
- struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
|
||
-
|
||
if (m->account)
|
||
g_object_unref(m->account);
|
||
}
|
||
|
||
-static struct _mail_msg_op empty_trash_op = {
|
||
- empty_trash_desc,
|
||
- empty_trash_empty,
|
||
- empty_trash_emptied,
|
||
- empty_trash_free,
|
||
+static MailMsgInfo empty_trash_info = {
|
||
+ sizeof (struct _empty_trash_msg),
|
||
+ (MailMsgDescFunc) empty_trash_desc,
|
||
+ (MailMsgExecFunc) empty_trash_exec,
|
||
+ (MailMsgDoneFunc) empty_trash_done,
|
||
+ (MailMsgFreeFunc) empty_trash_free
|
||
};
|
||
|
||
void
|
||
@@ -1716,20 +1665,20 @@ mail_empty_trash(EAccount *account, void
|
||
{
|
||
struct _empty_trash_msg *m;
|
||
|
||
- m = mail_msg_new(&empty_trash_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&empty_trash_info);
|
||
m->account = account;
|
||
if (account)
|
||
g_object_ref(account);
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
/* ** GET MESSAGE(s) ***************************************************** */
|
||
|
||
struct _get_message_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *folder;
|
||
char *uid;
|
||
@@ -1739,32 +1688,28 @@ struct _get_message_msg {
|
||
CamelOperation *cancel;
|
||
};
|
||
|
||
-static char *get_message_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+get_message_desc (struct _get_message_msg *m)
|
||
{
|
||
- struct _get_message_msg *m = (struct _get_message_msg *)mm;
|
||
-
|
||
return g_strdup_printf(_("Retrieving message %s"), m->uid);
|
||
}
|
||
|
||
-static void get_message_get(struct _mail_msg *mm)
|
||
+static void
|
||
+get_message_exec (struct _get_message_msg *m)
|
||
{
|
||
- struct _get_message_msg *m = (struct _get_message_msg *)mm;
|
||
-
|
||
- m->message = camel_folder_get_message(m->folder, m->uid, &mm->ex);
|
||
+ m->message = camel_folder_get_message(m->folder, m->uid, &m->base.ex);
|
||
}
|
||
|
||
-static void get_message_got(struct _mail_msg *mm)
|
||
+static void
|
||
+get_message_done (struct _get_message_msg *m)
|
||
{
|
||
- struct _get_message_msg *m = (struct _get_message_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->folder, m->uid, m->message, m->data);
|
||
}
|
||
|
||
-static void get_message_free(struct _mail_msg *mm)
|
||
+static void
|
||
+get_message_free (struct _get_message_msg *m)
|
||
{
|
||
- struct _get_message_msg *m = (struct _get_message_msg *)mm;
|
||
-
|
||
g_free (m->uid);
|
||
camel_object_unref (m->folder);
|
||
camel_operation_unref (m->cancel);
|
||
@@ -1773,21 +1718,22 @@ static void get_message_free(struct _mai
|
||
camel_object_unref (m->message);
|
||
}
|
||
|
||
-static struct _mail_msg_op get_message_op = {
|
||
- get_message_desc,
|
||
- get_message_get,
|
||
- get_message_got,
|
||
- get_message_free,
|
||
+static MailMsgInfo get_message_info = {
|
||
+ sizeof (struct _get_message_msg),
|
||
+ (MailMsgDescFunc) get_message_desc,
|
||
+ (MailMsgExecFunc) get_message_exec,
|
||
+ (MailMsgDoneFunc) get_message_done,
|
||
+ (MailMsgFreeFunc) get_message_free
|
||
};
|
||
|
||
void
|
||
mail_get_message(CamelFolder *folder, const char *uid, void (*done) (CamelFolder *folder, const char *uid,
|
||
CamelMimeMessage *msg, void *data),
|
||
- void *data, EThread *thread)
|
||
+ void *data, MailMsgDispatchFunc dispatch)
|
||
{
|
||
struct _get_message_msg *m;
|
||
|
||
- m = mail_msg_new(&get_message_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&get_message_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->uid = g_strdup(uid);
|
||
@@ -1795,37 +1741,37 @@ mail_get_message(CamelFolder *folder, co
|
||
m->done = (void (*) (CamelFolder *, const char *, CamelMimeMessage *, void *)) done;
|
||
m->cancel = camel_operation_new(NULL, NULL);
|
||
|
||
- e_thread_put(thread, (EMsg *)m);
|
||
+ dispatch (m);
|
||
}
|
||
|
||
typedef void (*get_done)(CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data, CamelException *);
|
||
|
||
-static void get_messagex_got(struct _mail_msg *mm)
|
||
+static void
|
||
+get_messagex_done (struct _get_message_msg *m)
|
||
{
|
||
- struct _get_message_msg *m = (struct _get_message_msg *)mm;
|
||
-
|
||
if (m->done) {
|
||
get_done done = (get_done)m->done;
|
||
- done(m->folder, m->uid, m->message, m->data, &mm->ex);
|
||
+ done(m->folder, m->uid, m->message, m->data, &m->base.ex);
|
||
}
|
||
}
|
||
|
||
-static struct _mail_msg_op get_messagex_op = {
|
||
- get_message_desc,
|
||
- get_message_get,
|
||
- get_messagex_got,
|
||
- get_message_free,
|
||
+static MailMsgInfo get_messagex_info = {
|
||
+ sizeof (struct _get_message_msg),
|
||
+ (MailMsgDescFunc) get_message_desc,
|
||
+ (MailMsgExecFunc) get_message_exec,
|
||
+ (MailMsgDoneFunc) get_messagex_done,
|
||
+ (MailMsgFreeFunc) get_message_free
|
||
};
|
||
|
||
/* This is temporary, to avoid having to rewrite everything that uses
|
||
mail_get_message; it adds an exception argument to the callback */
|
||
void
|
||
mail_get_messagex(CamelFolder *folder, const char *uid, void (*done) (CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data, CamelException *),
|
||
- void *data, EThread *thread)
|
||
+ void *data, MailMsgDispatchFunc dispatch)
|
||
{
|
||
struct _get_message_msg *m;
|
||
|
||
- m = mail_msg_new(&get_messagex_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&get_messagex_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->uid = g_strdup(uid);
|
||
@@ -1833,13 +1779,13 @@ mail_get_messagex(CamelFolder *folder, c
|
||
m->done = (void (*) (CamelFolder *, const char *, CamelMimeMessage *, void *)) done;
|
||
m->cancel = camel_operation_new(NULL, NULL);
|
||
|
||
- e_thread_put(thread, (EMsg *)m);
|
||
+ dispatch (m);
|
||
}
|
||
|
||
/* ********************************************************************** */
|
||
|
||
struct _get_messages_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *folder;
|
||
GPtrArray *uids;
|
||
@@ -1849,26 +1795,25 @@ struct _get_messages_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char * get_messages_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+get_messages_desc (struct _get_messages_msg *m)
|
||
{
|
||
- struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
|
||
-
|
||
return g_strdup_printf(ngettext("Retrieving %d message",
|
||
"Retrieving %d messages", m->uids->len),
|
||
m->uids->len);
|
||
}
|
||
|
||
-static void get_messages_get(struct _mail_msg *mm)
|
||
+static void
|
||
+get_messages_exec (struct _get_messages_msg *m)
|
||
{
|
||
- struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
|
||
int i;
|
||
CamelMimeMessage *message;
|
||
|
||
for (i=0; i<m->uids->len; i++) {
|
||
int pc = ((i+1) * 100) / m->uids->len;
|
||
|
||
- message = camel_folder_get_message(m->folder, m->uids->pdata[i], &mm->ex);
|
||
- camel_operation_progress(mm->cancel, pc);
|
||
+ message = camel_folder_get_message(m->folder, m->uids->pdata[i], &m->base.ex);
|
||
+ camel_operation_progress(m->base.cancel, pc);
|
||
if (message == NULL)
|
||
break;
|
||
|
||
@@ -1876,17 +1821,16 @@ static void get_messages_get(struct _mai
|
||
}
|
||
}
|
||
|
||
-static void get_messages_got(struct _mail_msg *mm)
|
||
+static void
|
||
+get_messages_done (struct _get_messages_msg *m)
|
||
{
|
||
- struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->folder, m->uids, m->messages, m->data);
|
||
}
|
||
|
||
-static void get_messages_free(struct _mail_msg *mm)
|
||
+static void
|
||
+get_messages_free (struct _get_messages_msg *m)
|
||
{
|
||
- struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
|
||
int i;
|
||
|
||
em_utils_uids_free (m->uids);
|
||
@@ -1898,11 +1842,12 @@ static void get_messages_free(struct _ma
|
||
camel_object_unref(m->folder);
|
||
}
|
||
|
||
-static struct _mail_msg_op get_messages_op = {
|
||
- get_messages_desc,
|
||
- get_messages_get,
|
||
- get_messages_got,
|
||
- get_messages_free,
|
||
+static MailMsgInfo get_messages_info = {
|
||
+ sizeof (struct _get_messages_msg),
|
||
+ (MailMsgDescFunc) get_messages_desc,
|
||
+ (MailMsgExecFunc) get_messages_exec,
|
||
+ (MailMsgDoneFunc) get_messages_done,
|
||
+ (MailMsgFreeFunc) get_messages_free
|
||
};
|
||
|
||
void
|
||
@@ -1912,7 +1857,7 @@ mail_get_messages(CamelFolder *folder, G
|
||
{
|
||
struct _get_messages_msg *m;
|
||
|
||
- m = mail_msg_new(&get_messages_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&get_messages_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->uids = uids;
|
||
@@ -1920,13 +1865,13 @@ mail_get_messages(CamelFolder *folder, G
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
/* ** SAVE MESSAGES ******************************************************* */
|
||
|
||
struct _save_messages_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *folder;
|
||
GPtrArray *uids;
|
||
@@ -1935,10 +1880,9 @@ struct _save_messages_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *save_messages_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+save_messages_desc (struct _save_messages_msg *m)
|
||
{
|
||
- struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
|
||
-
|
||
return g_strdup_printf(ngettext("Saving %d message",
|
||
"Saving %d messsages", m->uids->len),
|
||
m->uids->len);
|
||
@@ -1977,9 +1921,8 @@ save_prepare_part (CamelMimePart *mime_p
|
||
}
|
||
|
||
static void
|
||
-save_messages_save (struct _mail_msg *mm)
|
||
+save_messages_exec (struct _save_messages_msg *m)
|
||
{
|
||
- struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
|
||
CamelStreamFilter *filtered_stream;
|
||
CamelMimeFilterFrom *from_filter;
|
||
CamelStream *stream;
|
||
@@ -1996,8 +1939,8 @@ save_messages_save (struct _mail_msg *mm
|
||
CamelMimeMessage *message;
|
||
int pc = ((i+1) * 100) / m->uids->len;
|
||
|
||
- message = camel_folder_get_message(m->folder, m->uids->pdata[i], &mm->ex);
|
||
- camel_operation_progress(mm->cancel, pc);
|
||
+ message = camel_folder_get_message(m->folder, m->uids->pdata[i], &m->base.ex);
|
||
+ camel_operation_progress(m->base.cancel, pc);
|
||
if (message == NULL)
|
||
break;
|
||
|
||
@@ -2009,7 +1952,7 @@ save_messages_save (struct _mail_msg *mm
|
||
|| camel_stream_flush(stream) == -1
|
||
|| camel_data_wrapper_write_to_stream((CamelDataWrapper *)message, (CamelStream *)filtered_stream) == -1
|
||
|| camel_stream_flush((CamelStream *)filtered_stream) == -1) {
|
||
- camel_exception_setv(&mm->ex, CAMEL_EXCEPTION_SYSTEM,
|
||
+ camel_exception_setv(&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
|
||
_("Error saving messages to: %s:\n %s"), m->path, strerror(errno));
|
||
g_free(from);
|
||
camel_object_unref((CamelObject *)message);
|
||
@@ -2023,28 +1966,27 @@ save_messages_save (struct _mail_msg *mm
|
||
camel_object_unref(stream);
|
||
}
|
||
|
||
-static void save_messages_saved(struct _mail_msg *mm)
|
||
+static void
|
||
+save_messages_done (struct _save_messages_msg *m)
|
||
{
|
||
- struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->folder, m->uids, m->path, m->data);
|
||
}
|
||
|
||
-static void save_messages_free(struct _mail_msg *mm)
|
||
+static void
|
||
+save_messages_free (struct _save_messages_msg *m)
|
||
{
|
||
- struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
|
||
-
|
||
em_utils_uids_free (m->uids);
|
||
camel_object_unref(m->folder);
|
||
g_free(m->path);
|
||
}
|
||
|
||
-static struct _mail_msg_op save_messages_op = {
|
||
- save_messages_desc,
|
||
- save_messages_save,
|
||
- save_messages_saved,
|
||
- save_messages_free,
|
||
+static MailMsgInfo save_messages_info = {
|
||
+ sizeof (struct _save_messages_msg),
|
||
+ (MailMsgDescFunc) save_messages_desc,
|
||
+ (MailMsgExecFunc) save_messages_exec,
|
||
+ (MailMsgDoneFunc) save_messages_done,
|
||
+ (MailMsgFreeFunc) save_messages_free
|
||
};
|
||
|
||
int
|
||
@@ -2054,7 +1996,7 @@ mail_save_messages(CamelFolder *folder,
|
||
struct _save_messages_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&save_messages_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&save_messages_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->uids = uids;
|
||
@@ -2062,8 +2004,8 @@ mail_save_messages(CamelFolder *folder,
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -2071,7 +2013,7 @@ mail_save_messages(CamelFolder *folder,
|
||
/* ** SAVE PART ******************************************************* */
|
||
|
||
struct _save_part_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelMimePart *part;
|
||
char *path;
|
||
@@ -2080,27 +2022,27 @@ struct _save_part_msg {
|
||
gboolean readonly;
|
||
};
|
||
|
||
-static char *save_part_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+save_part_desc (struct _save_part_msg *m)
|
||
{
|
||
return g_strdup(_("Saving attachment"));
|
||
}
|
||
|
||
static void
|
||
-save_part_save (struct _mail_msg *mm)
|
||
+save_part_exec (struct _save_part_msg *m)
|
||
{
|
||
- struct _save_part_msg *m = (struct _save_part_msg *)mm;
|
||
CamelDataWrapper *content;
|
||
CamelStream *stream;
|
||
|
||
if(!m->readonly){
|
||
if (!(stream = camel_stream_vfs_new_with_uri (m->path, O_WRONLY | O_CREAT | O_TRUNC, 0644))) {
|
||
- camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
|
||
+ camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
|
||
_("Cannot create output file: %s:\n %s"),
|
||
m->path, g_strerror (errno));
|
||
return;
|
||
}
|
||
} else if (!(stream = camel_stream_vfs_new_with_uri (m->path, O_WRONLY | O_CREAT | O_TRUNC, 0444))) {
|
||
- camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
|
||
+ camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
|
||
_("Cannot create output file: %s:\n %s"),
|
||
m->path, g_strerror (errno));
|
||
return;
|
||
@@ -2110,7 +2052,7 @@ save_part_save (struct _mail_msg *mm)
|
||
|
||
if (camel_data_wrapper_decode_to_stream (content, stream) == -1
|
||
|| camel_stream_flush (stream) == -1)
|
||
- camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
|
||
+ camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
|
||
_("Could not write data: %s"),
|
||
g_strerror (errno));
|
||
|
||
@@ -2118,27 +2060,25 @@ save_part_save (struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-save_part_saved (struct _mail_msg *mm)
|
||
+save_part_done (struct _save_part_msg *m)
|
||
{
|
||
- struct _save_part_msg *m = (struct _save_part_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
- m->done (m->part, m->path, !camel_exception_is_set (&mm->ex), m->data);
|
||
+ m->done (m->part, m->path, !camel_exception_is_set (&m->base.ex), m->data);
|
||
}
|
||
|
||
static void
|
||
-save_part_free (struct _mail_msg *mm)
|
||
+save_part_free (struct _save_part_msg *m)
|
||
{
|
||
- struct _save_part_msg *m = (struct _save_part_msg *)mm;
|
||
camel_object_unref (m->part);
|
||
g_free (m->path);
|
||
}
|
||
|
||
-static struct _mail_msg_op save_part_op = {
|
||
- save_part_desc,
|
||
- save_part_save,
|
||
- save_part_saved,
|
||
- save_part_free,
|
||
+static MailMsgInfo save_part_info = {
|
||
+ sizeof (struct _save_part_msg),
|
||
+ (MailMsgDescFunc) save_part_desc,
|
||
+ (MailMsgExecFunc) save_part_exec,
|
||
+ (MailMsgDoneFunc) save_part_done,
|
||
+ (MailMsgFreeFunc) save_part_free
|
||
};
|
||
|
||
int
|
||
@@ -2147,7 +2087,7 @@ mail_save_part (CamelMimePart *part, con
|
||
{
|
||
struct _save_part_msg *m;
|
||
int id;
|
||
- m = mail_msg_new (&save_part_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new (&save_part_info);
|
||
m->part = part;
|
||
camel_object_ref (part);
|
||
m->path = g_strdup (path);
|
||
@@ -2155,8 +2095,8 @@ mail_save_part (CamelMimePart *part, con
|
||
m->done = done;
|
||
m->readonly = readonly;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -2165,7 +2105,7 @@ mail_save_part (CamelMimePart *part, con
|
||
/* ** PREPARE OFFLINE ***************************************************** */
|
||
|
||
struct _prep_offline_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelOperation *cancel;
|
||
char *uri;
|
||
@@ -2173,22 +2113,22 @@ struct _prep_offline_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static void prep_offline_do(struct _mail_msg *mm)
|
||
+static void
|
||
+prep_offline_exec (struct _prep_offline_msg *m)
|
||
{
|
||
- struct _prep_offline_msg *m = (struct _prep_offline_msg *)mm;
|
||
CamelFolder *folder;
|
||
|
||
if (m->cancel)
|
||
camel_operation_register(m->cancel);
|
||
|
||
- folder = mail_tool_uri_to_folder(m->uri, 0, &mm->ex);
|
||
+ folder = mail_tool_uri_to_folder(m->uri, 0, &m->base.ex);
|
||
if (folder) {
|
||
if (CAMEL_IS_DISCO_FOLDER(folder)) {
|
||
camel_disco_folder_prepare_for_offline((CamelDiscoFolder *)folder,
|
||
"(match-all)",
|
||
- &mm->ex);
|
||
+ &m->base.ex);
|
||
} else if (CAMEL_IS_OFFLINE_FOLDER (folder)) {
|
||
- camel_offline_folder_downsync ((CamelOfflineFolder *) folder, "(match-all)", &mm->ex);
|
||
+ camel_offline_folder_downsync ((CamelOfflineFolder *) folder, "(match-all)", &m->base.ex);
|
||
}
|
||
/* prepare_for_offline should do this? */
|
||
/* of course it should all be atomic, but ... */
|
||
@@ -2200,28 +2140,27 @@ static void prep_offline_do(struct _mail
|
||
camel_operation_unregister(m->cancel);
|
||
}
|
||
|
||
-static void prep_offline_done(struct _mail_msg *mm)
|
||
+static void
|
||
+prep_offline_done (struct _prep_offline_msg *m)
|
||
{
|
||
- struct _prep_offline_msg *m = (struct _prep_offline_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->uri, m->data);
|
||
}
|
||
|
||
-static void prep_offline_free(struct _mail_msg *mm)
|
||
+static void
|
||
+prep_offline_free (struct _prep_offline_msg *m)
|
||
{
|
||
- struct _prep_offline_msg *m = (struct _prep_offline_msg *)mm;
|
||
-
|
||
if (m->cancel)
|
||
camel_operation_unref(m->cancel);
|
||
g_free(m->uri);
|
||
}
|
||
|
||
-static struct _mail_msg_op prep_offline_op = {
|
||
- NULL, /* DO NOT CHANGE THIS, IT MUST BE NULL FOR CANCELLATION TO WORK */
|
||
- prep_offline_do,
|
||
- prep_offline_done,
|
||
- prep_offline_free,
|
||
+static MailMsgInfo prep_offline_info = {
|
||
+ sizeof (struct _prep_offline_msg),
|
||
+ (MailMsgDescFunc) NULL, /* DO NOT CHANGE THIS, IT MUST BE NULL FOR CANCELLATION TO WORK */
|
||
+ (MailMsgExecFunc) prep_offline_exec,
|
||
+ (MailMsgDoneFunc) prep_offline_done,
|
||
+ (MailMsgFreeFunc) prep_offline_free
|
||
};
|
||
|
||
void
|
||
@@ -2232,7 +2171,7 @@ mail_prep_offline(const char *uri,
|
||
{
|
||
struct _prep_offline_msg *m;
|
||
|
||
- m = mail_msg_new(&prep_offline_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&prep_offline_info);
|
||
m->cancel = cancel;
|
||
if (cancel)
|
||
camel_operation_ref(cancel);
|
||
@@ -2240,13 +2179,13 @@ mail_prep_offline(const char *uri,
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
/* ** GO OFFLINE ***************************************************** */
|
||
|
||
struct _set_offline_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelStore *store;
|
||
gboolean offline;
|
||
@@ -2254,9 +2193,9 @@ struct _set_offline_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *set_offline_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+set_offline_desc (struct _set_offline_msg *m)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
char *service_name = camel_service_get_name (CAMEL_SERVICE (m->store), TRUE);
|
||
char *msg;
|
||
|
||
@@ -2266,61 +2205,59 @@ static char *set_offline_desc(struct _ma
|
||
return msg;
|
||
}
|
||
|
||
-static void set_offline_do(struct _mail_msg *mm)
|
||
+static void
|
||
+set_offline_exec (struct _set_offline_msg *m)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
-
|
||
if (CAMEL_IS_DISCO_STORE (m->store)) {
|
||
if (!m->offline) {
|
||
camel_disco_store_set_status (CAMEL_DISCO_STORE (m->store),
|
||
CAMEL_DISCO_STORE_ONLINE,
|
||
- &mm->ex);
|
||
+ &m->base.ex);
|
||
return;
|
||
} else if (camel_disco_store_can_work_offline (CAMEL_DISCO_STORE (m->store))) {
|
||
camel_disco_store_set_status (CAMEL_DISCO_STORE (m->store),
|
||
CAMEL_DISCO_STORE_OFFLINE,
|
||
- &mm->ex);
|
||
+ &m->base.ex);
|
||
return;
|
||
}
|
||
} else if (CAMEL_IS_OFFLINE_STORE (m->store)) {
|
||
if (!m->offline) {
|
||
camel_offline_store_set_network_state (CAMEL_OFFLINE_STORE (m->store),
|
||
CAMEL_OFFLINE_STORE_NETWORK_AVAIL,
|
||
- &mm->ex);
|
||
+ &m->base.ex);
|
||
return;
|
||
} else {
|
||
camel_offline_store_set_network_state (CAMEL_OFFLINE_STORE (m->store),
|
||
CAMEL_OFFLINE_STORE_NETWORK_UNAVAIL,
|
||
- &mm->ex);
|
||
+ &m->base.ex);
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (m->offline)
|
||
camel_service_disconnect (CAMEL_SERVICE (m->store),
|
||
- TRUE, &mm->ex);
|
||
+ TRUE, &m->base.ex);
|
||
}
|
||
|
||
-static void set_offline_done(struct _mail_msg *mm)
|
||
+static void
|
||
+set_offline_done (struct _set_offline_msg *m)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->store, m->data);
|
||
}
|
||
|
||
-static void set_offline_free(struct _mail_msg *mm)
|
||
+static void
|
||
+set_offline_free (struct _set_offline_msg *m)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
-
|
||
camel_object_unref(m->store);
|
||
}
|
||
|
||
-static struct _mail_msg_op set_offline_op = {
|
||
- set_offline_desc,
|
||
- set_offline_do,
|
||
- set_offline_done,
|
||
- set_offline_free,
|
||
+static MailMsgInfo set_offline_info = {
|
||
+ sizeof (struct _set_offline_msg),
|
||
+ (MailMsgDescFunc) set_offline_desc,
|
||
+ (MailMsgExecFunc) set_offline_exec,
|
||
+ (MailMsgDoneFunc) set_offline_done,
|
||
+ (MailMsgFreeFunc) set_offline_free
|
||
};
|
||
|
||
int
|
||
@@ -2337,61 +2274,59 @@ mail_store_set_offline (CamelStore *stor
|
||
if (offline)
|
||
camel_service_cancel_connect (CAMEL_SERVICE (store));
|
||
|
||
- m = mail_msg_new(&set_offline_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&set_offline_info);
|
||
m->store = store;
|
||
camel_object_ref(store);
|
||
m->offline = offline;
|
||
m->data = data;
|
||
m->done = done;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
|
||
/* ** Prepare OFFLINE ***************************************************** */
|
||
|
||
-static char *prepare_offline_desc(struct _mail_msg *mm, int done)
|
||
+static char *
|
||
+prepare_offline_desc (struct _set_offline_msg *m, int done)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
char *service_name = camel_service_get_name (CAMEL_SERVICE (m->store), TRUE);
|
||
char *msg;
|
||
|
||
- msg = g_strdup_printf(_("Preparing account '%s' for offline"), service_name);
|
||
+ msg = g_strdup_printf (_("Preparing account '%s' for offline"), service_name);
|
||
g_free(service_name);
|
||
|
||
return msg;
|
||
}
|
||
|
||
-static void prepare_offline_do(struct _mail_msg *mm)
|
||
+static void
|
||
+prepare_offline_exec (struct _set_offline_msg *m)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
-
|
||
camel_disco_store_prepare_for_offline (CAMEL_DISCO_STORE (m->store),
|
||
- &mm->ex);
|
||
+ &m->base.ex);
|
||
}
|
||
|
||
-static void prepare_offline_done(struct _mail_msg *mm)
|
||
+static void
|
||
+prepare_offline_done (struct _set_offline_msg *m)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
- m->done(m->store, m->data);
|
||
+ m->done (m->store, m->data);
|
||
}
|
||
|
||
-static void prepare_offline_free(struct _mail_msg *mm)
|
||
+static void
|
||
+prepare_offline_free (struct _set_offline_msg *m)
|
||
{
|
||
- struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
|
||
-
|
||
- camel_object_unref(m->store);
|
||
+ camel_object_unref (m->store);
|
||
}
|
||
|
||
-static struct _mail_msg_op prepare_offline_op = {
|
||
- prepare_offline_desc,
|
||
- prepare_offline_do,
|
||
- prepare_offline_done,
|
||
- prepare_offline_free,
|
||
+static MailMsgInfo prepare_offline_info = {
|
||
+ sizeof (struct _set_offline_msg),
|
||
+ (MailMsgDescFunc) prepare_offline_desc,
|
||
+ (MailMsgExecFunc) prepare_offline_exec,
|
||
+ (MailMsgDoneFunc) prepare_offline_done,
|
||
+ (MailMsgFreeFunc) prepare_offline_free
|
||
};
|
||
|
||
int
|
||
@@ -2404,14 +2339,14 @@ mail_store_prepare_offline (CamelStore *
|
||
* thread won't get queued behind a hung connect op.
|
||
*/
|
||
|
||
- m = mail_msg_new(&prepare_offline_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&prepare_offline_info);
|
||
m->store = store;
|
||
camel_object_ref(store);
|
||
m->data = NULL;
|
||
m->done = NULL;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -2428,7 +2363,7 @@ mail_execute_shell_command (CamelFilterD
|
||
|
||
/* Async service-checking/authtype-lookup code. */
|
||
struct _check_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
char *url;
|
||
CamelProviderType type;
|
||
@@ -2438,51 +2373,47 @@ struct _check_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static char *
|
||
-check_service_describe(struct _mail_msg *mm, int complete)
|
||
+static gchar *
|
||
+check_service_desc (struct _check_msg *m)
|
||
{
|
||
return g_strdup(_("Checking Service"));
|
||
}
|
||
|
||
static void
|
||
-check_service_check(struct _mail_msg *mm)
|
||
+check_service_exec (struct _check_msg *m)
|
||
{
|
||
- struct _check_msg *m = (struct _check_msg *)mm;
|
||
CamelService *service;
|
||
|
||
- service = camel_session_get_service(session, m->url, m->type, &mm->ex);
|
||
+ service = camel_session_get_service(session, m->url, m->type, &m->base.ex);
|
||
if (!service) {
|
||
- camel_operation_unregister(mm->cancel);
|
||
+ camel_operation_unregister(m->base.cancel);
|
||
return;
|
||
}
|
||
|
||
- m->authtypes = camel_service_query_auth_types(service, &mm->ex);
|
||
+ m->authtypes = camel_service_query_auth_types(service, &m->base.ex);
|
||
camel_object_unref(service);
|
||
}
|
||
|
||
static void
|
||
-check_service_done(struct _mail_msg *mm)
|
||
+check_service_done (struct _check_msg *m)
|
||
{
|
||
- struct _check_msg *m = (struct _check_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
m->done(m->url, m->type, m->authtypes, m->data);
|
||
}
|
||
|
||
static void
|
||
-check_service_free(struct _mail_msg *mm)
|
||
+check_service_free (struct _check_msg *m)
|
||
{
|
||
- struct _check_msg *m = (struct _check_msg *)mm;
|
||
-
|
||
g_free(m->url);
|
||
g_list_free(m->authtypes);
|
||
}
|
||
|
||
-static struct _mail_msg_op check_service_op = {
|
||
- check_service_describe,
|
||
- check_service_check,
|
||
- check_service_done,
|
||
- check_service_free,
|
||
+static MailMsgInfo check_service_info = {
|
||
+ sizeof (struct _check_msg),
|
||
+ (MailMsgDescFunc) check_service_desc,
|
||
+ (MailMsgExecFunc) check_service_exec,
|
||
+ (MailMsgDoneFunc) check_service_done,
|
||
+ (MailMsgFreeFunc) check_service_free
|
||
};
|
||
|
||
int
|
||
@@ -2491,14 +2422,14 @@ mail_check_service(const char *url, Came
|
||
struct _check_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new (&check_service_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new (&check_service_info);
|
||
m->url = g_strdup(url);
|
||
m->type = type;
|
||
m->done = done;
|
||
m->data = data;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
--- evolution-2.11.3/mail/em-folder-utils.c.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-folder-utils.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -84,7 +84,7 @@ emfu_is_special_local_folder (const char
|
||
}
|
||
|
||
struct _EMCopyFolders {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
/* input data */
|
||
CamelStore *fromstore;
|
||
@@ -96,18 +96,15 @@ struct _EMCopyFolders {
|
||
int delete;
|
||
};
|
||
|
||
-static char *
|
||
-emft_copy_folders__desc (struct _mail_msg *mm, int complete)
|
||
+static gchar *
|
||
+emft_copy_folders__desc (struct _EMCopyFolders *m, gint complete)
|
||
{
|
||
- struct _EMCopyFolders *m = (struct _EMCopyFolders *) mm;
|
||
-
|
||
return g_strdup_printf (_("Copying `%s' to `%s'"), m->frombase, m->tobase);
|
||
}
|
||
|
||
static void
|
||
-emft_copy_folders__copy (struct _mail_msg *mm)
|
||
+emft_copy_folders__exec (struct _EMCopyFolders *m)
|
||
{
|
||
- struct _EMCopyFolders *m = (struct _EMCopyFolders *) mm;
|
||
guint32 flags = CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_RECURSIVE | CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;
|
||
GList *pending = NULL, *deleting = NULL, *l;
|
||
GString *fromname, *toname;
|
||
@@ -115,7 +112,7 @@ emft_copy_folders__copy (struct _mail_ms
|
||
const char *tmp;
|
||
int fromlen;
|
||
|
||
- if (!(fi = camel_store_get_folder_info (m->fromstore, m->frombase, flags, &mm->ex)))
|
||
+ if (!(fi = camel_store_get_folder_info (m->fromstore, m->frombase, flags, &m->base.ex)))
|
||
return;
|
||
|
||
pending = g_list_append (pending, fi);
|
||
@@ -155,8 +152,8 @@ emft_copy_folders__copy (struct _mail_ms
|
||
if ((info->flags & CAMEL_FOLDER_NOSELECT) == 0) {
|
||
d(printf ("this folder is selectable\n"));
|
||
if (m->tostore == m->fromstore && m->delete) {
|
||
- camel_store_rename_folder (m->fromstore, info->full_name, toname->str, &mm->ex);
|
||
- if (camel_exception_is_set (&mm->ex))
|
||
+ camel_store_rename_folder (m->fromstore, info->full_name, toname->str, &m->base.ex);
|
||
+ if (camel_exception_is_set (&m->base.ex))
|
||
goto exception;
|
||
|
||
/* this folder no longer exists, unsubscribe it */
|
||
@@ -165,16 +162,16 @@ emft_copy_folders__copy (struct _mail_ms
|
||
|
||
deleted = 1;
|
||
} else {
|
||
- if (!(fromfolder = camel_store_get_folder (m->fromstore, info->full_name, 0, &mm->ex)))
|
||
+ if (!(fromfolder = camel_store_get_folder (m->fromstore, info->full_name, 0, &m->base.ex)))
|
||
goto exception;
|
||
|
||
- if (!(tofolder = camel_store_get_folder (m->tostore, toname->str, CAMEL_STORE_FOLDER_CREATE, &mm->ex))) {
|
||
+ if (!(tofolder = camel_store_get_folder (m->tostore, toname->str, CAMEL_STORE_FOLDER_CREATE, &m->base.ex))) {
|
||
camel_object_unref (fromfolder);
|
||
goto exception;
|
||
}
|
||
|
||
uids = camel_folder_get_uids (fromfolder);
|
||
- camel_folder_transfer_messages_to (fromfolder, uids, tofolder, NULL, m->delete, &mm->ex);
|
||
+ camel_folder_transfer_messages_to (fromfolder, uids, tofolder, NULL, m->delete, &m->base.ex);
|
||
camel_folder_free_uids (fromfolder, uids);
|
||
|
||
if (m->delete)
|
||
@@ -185,7 +182,7 @@ emft_copy_folders__copy (struct _mail_ms
|
||
}
|
||
}
|
||
|
||
- if (camel_exception_is_set (&mm->ex))
|
||
+ if (camel_exception_is_set (&m->base.ex))
|
||
goto exception;
|
||
else if (m->delete && !deleted)
|
||
deleting = g_list_prepend (deleting, info);
|
||
@@ -226,10 +223,8 @@ emft_copy_folders__copy (struct _mail_ms
|
||
}
|
||
|
||
static void
|
||
-emft_copy_folders__free (struct _mail_msg *mm)
|
||
+emft_copy_folders__free (struct _EMCopyFolders *m)
|
||
{
|
||
- struct _EMCopyFolders *m = (struct _EMCopyFolders *) mm;
|
||
-
|
||
camel_object_unref (m->fromstore);
|
||
camel_object_unref (m->tostore);
|
||
|
||
@@ -237,11 +232,12 @@ emft_copy_folders__free (struct _mail_ms
|
||
g_free (m->tobase);
|
||
}
|
||
|
||
-static struct _mail_msg_op copy_folders_op = {
|
||
- emft_copy_folders__desc,
|
||
- emft_copy_folders__copy,
|
||
- NULL,
|
||
- emft_copy_folders__free,
|
||
+static MailMsgInfo copy_folders_info = {
|
||
+ sizeof (struct _EMCopyFolders),
|
||
+ (MailMsgDescFunc) emft_copy_folders__desc,
|
||
+ (MailMsgExecFunc) emft_copy_folders__exec,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) emft_copy_folders__free
|
||
};
|
||
|
||
int
|
||
@@ -250,7 +246,7 @@ em_folder_utils_copy_folders(CamelStore
|
||
struct _EMCopyFolders *m;
|
||
int seq;
|
||
|
||
- m = mail_msg_new (©_folders_op, NULL, sizeof (struct _EMCopyFolders));
|
||
+ m = mail_msg_new (©_folders_info);
|
||
camel_object_ref (fromstore);
|
||
m->fromstore = fromstore;
|
||
camel_object_ref (tostore);
|
||
@@ -258,9 +254,9 @@ em_folder_utils_copy_folders(CamelStore
|
||
m->frombase = g_strdup (frombase);
|
||
m->tobase = g_strdup (tobase);
|
||
m->delete = delete;
|
||
- seq = m->msg.seq;
|
||
+ seq = m->base.seq;
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *) m);
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return seq;
|
||
}
|
||
@@ -557,7 +553,7 @@ em_folder_utils_rename_folder (CamelFold
|
||
}
|
||
|
||
struct _EMCreateFolder {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
/* input data */
|
||
CamelStore *store;
|
||
@@ -573,41 +569,33 @@ struct _EMCreateFolder {
|
||
void *user_data;
|
||
};
|
||
|
||
-static char *
|
||
-emfu_create_folder__desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+emfu_create_folder__desc (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
-
|
||
return g_strdup_printf (_("Creating folder `%s'"), m->full_name);
|
||
}
|
||
|
||
static void
|
||
-emfu_create_folder__create (struct _mail_msg *mm)
|
||
+emfu_create_folder__exec (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
-
|
||
d(printf ("creating folder parent='%s' name='%s' full_name='%s'\n", m->parent, m->name, m->full_name));
|
||
|
||
- if ((m->fi = camel_store_create_folder (m->store, m->parent, m->name, &mm->ex))) {
|
||
+ if ((m->fi = camel_store_create_folder (m->store, m->parent, m->name, &m->base.ex))) {
|
||
if (camel_store_supports_subscriptions (m->store))
|
||
- camel_store_subscribe_folder (m->store, m->full_name, &mm->ex);
|
||
+ camel_store_subscribe_folder (m->store, m->full_name, &m->base.ex);
|
||
}
|
||
}
|
||
|
||
static void
|
||
-emfu_create_folder__created (struct _mail_msg *mm)
|
||
+emfu_create_folder__done (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
-
|
||
if (m->done)
|
||
m->done (m->fi, m->user_data);
|
||
}
|
||
|
||
static void
|
||
-emfu_create_folder__free (struct _mail_msg *mm)
|
||
+emfu_create_folder__free (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
-
|
||
camel_store_free_folder_info (m->store, m->fi);
|
||
camel_object_unref (m->store);
|
||
g_free (m->full_name);
|
||
@@ -615,11 +603,12 @@ emfu_create_folder__free (struct _mail_m
|
||
g_free (m->name);
|
||
}
|
||
|
||
-static struct _mail_msg_op create_folder_op = {
|
||
- emfu_create_folder__desc,
|
||
- emfu_create_folder__create,
|
||
- emfu_create_folder__created,
|
||
- emfu_create_folder__free,
|
||
+static MailMsgInfo create_folder_info = {
|
||
+ sizeof (struct _EMCreateFolder),
|
||
+ (MailMsgDescFunc) emfu_create_folder__desc,
|
||
+ (MailMsgExecFunc) emfu_create_folder__exec,
|
||
+ (MailMsgDoneFunc) emfu_create_folder__done,
|
||
+ (MailMsgFreeFunc) emfu_create_folder__free
|
||
};
|
||
|
||
|
||
@@ -640,7 +629,7 @@ emfu_create_folder_real (CamelStore *sto
|
||
parent = namebuf;
|
||
}
|
||
|
||
- m = mail_msg_new (&create_folder_op, NULL, sizeof (struct _EMCreateFolder));
|
||
+ m = mail_msg_new (&create_folder_info);
|
||
camel_object_ref (store);
|
||
m->store = store;
|
||
m->full_name = g_strdup (full_name);
|
||
@@ -651,8 +640,8 @@ emfu_create_folder_real (CamelStore *sto
|
||
|
||
g_free (namebuf);
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put (mail_thread_new, (EMsg *) m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
--- evolution-2.11.3/mail/importers/elm-importer.c.kill-ethread 2007-04-18 06:17:29.000000000 -0400
|
||
+++ evolution-2.11.3/mail/importers/elm-importer.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -51,7 +51,7 @@
|
||
#define d(x) x
|
||
|
||
struct _elm_import_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
EImport *import;
|
||
EImportTargetHome *target;
|
||
@@ -186,8 +186,8 @@ elm_supported(EImport *ei, EImportTarget
|
||
return mailexists;
|
||
}
|
||
|
||
-static char *
|
||
-elm_import_describe (struct _mail_msg *mm, int complete)
|
||
+static gchar *
|
||
+elm_import_desc (struct _elm_import_msg *m)
|
||
{
|
||
return g_strdup (_("Importing Elm data"));
|
||
}
|
||
@@ -198,9 +198,8 @@ static MailImporterSpecial elm_special_f
|
||
};
|
||
|
||
static void
|
||
-elm_import_import(struct _mail_msg *mm)
|
||
+elm_import_exec (struct _elm_import_msg *m)
|
||
{
|
||
- struct _elm_import_msg *m = (struct _elm_import_msg *) mm;
|
||
const char *maildir;
|
||
char *elmdir;
|
||
|
||
@@ -218,13 +217,11 @@ elm_import_import(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-elm_import_imported(struct _mail_msg *mm)
|
||
+elm_import_done(struct _elm_import_msg *m)
|
||
{
|
||
- struct _elm_import_msg *m = (struct _elm_import_msg *)mm;
|
||
-
|
||
printf("importing complete\n");
|
||
|
||
- if (!camel_exception_is_set(&mm->ex)) {
|
||
+ if (!camel_exception_is_set(&m->base.ex)) {
|
||
GConfClient *gconf;
|
||
|
||
gconf = gconf_client_get_default();
|
||
@@ -236,10 +233,8 @@ elm_import_imported(struct _mail_msg *mm
|
||
}
|
||
|
||
static void
|
||
-elm_import_free(struct _mail_msg *mm)
|
||
+elm_import_free(struct _elm_import_msg *m)
|
||
{
|
||
- struct _elm_import_msg *m = (struct _elm_import_msg *)mm;
|
||
-
|
||
camel_operation_unref(m->status);
|
||
|
||
g_free(m->status_what);
|
||
@@ -288,11 +283,12 @@ elm_status_timeout(void *data)
|
||
return TRUE;
|
||
}
|
||
|
||
-static struct _mail_msg_op elm_import_op = {
|
||
- elm_import_describe,
|
||
- elm_import_import,
|
||
- elm_import_imported,
|
||
- elm_import_free,
|
||
+static MailMsgInfo elm_import_info = {
|
||
+ sizeof (struct _elm_import_msg),
|
||
+ (MailMsgDescFunc) elm_import_desc,
|
||
+ (MailMsgExecFunc) elm_import_exec,
|
||
+ (MailMsgDoneFunc) elm_import_done,
|
||
+ (MailMsgFreeFunc) elm_import_free
|
||
};
|
||
|
||
static int
|
||
@@ -301,7 +297,7 @@ mail_importer_elm_import(EImport *ei, EI
|
||
struct _elm_import_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&elm_import_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new(&elm_import_info);
|
||
g_datalist_set_data(&target->data, "elm-msg", m);
|
||
m->import = ei;
|
||
g_object_ref(m->import);
|
||
@@ -310,9 +306,9 @@ mail_importer_elm_import(EImport *ei, EI
|
||
m->status_lock = g_mutex_new();
|
||
m->status = camel_operation_new(elm_status, m);
|
||
|
||
- id = m->msg.seq;
|
||
+ id = m->base.seq;
|
||
|
||
- e_thread_put(mail_thread_queued, (EMsg *)m);
|
||
+ mail_msg_fast_ordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
--- evolution-2.11.3/mail/importers/mail-importer.c.kill-ethread 2007-06-03 11:08:07.000000000 -0400
|
||
+++ evolution-2.11.3/mail/importers/mail-importer.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -132,7 +132,7 @@ struct _BonoboObject *mail_importer_fact
|
||
}
|
||
|
||
struct _import_mbox_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
char *path;
|
||
char *uri;
|
||
@@ -142,8 +142,8 @@ struct _import_mbox_msg {
|
||
void *done_data;
|
||
};
|
||
|
||
-static char *
|
||
-import_mbox_describe(struct _mail_msg *mm, int complete)
|
||
+static gchar *
|
||
+import_mbox_desc (struct _import_mbox_msg *m)
|
||
{
|
||
return g_strdup (_("Importing mailbox"));
|
||
}
|
||
@@ -190,9 +190,8 @@ decode_mozilla_status(const char *tmp)
|
||
}
|
||
|
||
static void
|
||
-import_mbox_import(struct _mail_msg *mm)
|
||
+import_mbox_exec (struct _import_mbox_msg *m)
|
||
{
|
||
- struct _import_mbox_msg *m = (struct _import_mbox_msg *) mm;
|
||
CamelFolder *folder;
|
||
CamelMimeParser *mp = NULL;
|
||
struct stat st;
|
||
@@ -207,7 +206,7 @@ import_mbox_import(struct _mail_msg *mm)
|
||
if (m->uri == NULL || m->uri[0] == 0)
|
||
folder = mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_INBOX);
|
||
else
|
||
- folder = mail_tool_uri_to_folder(m->uri, CAMEL_STORE_FOLDER_CREATE, &mm->ex);
|
||
+ folder = mail_tool_uri_to_folder(m->uri, CAMEL_STORE_FOLDER_CREATE, &m->base.ex);
|
||
|
||
if (folder == NULL)
|
||
return;
|
||
@@ -262,11 +261,11 @@ import_mbox_import(struct _mail_msg *mm)
|
||
flags |= decode_status(tmp);
|
||
|
||
camel_message_info_set_flags(info, flags, ~0);
|
||
- camel_folder_append_message(folder, msg, info, NULL, &mm->ex);
|
||
+ camel_folder_append_message(folder, msg, info, NULL, &m->base.ex);
|
||
camel_message_info_free(info);
|
||
camel_object_unref(msg);
|
||
|
||
- if (camel_exception_is_set(&mm->ex))
|
||
+ if (camel_exception_is_set(&m->base.ex))
|
||
break;
|
||
|
||
camel_mime_parser_step(mp, 0, 0);
|
||
@@ -286,30 +285,27 @@ fail1:
|
||
}
|
||
|
||
static void
|
||
-import_mbox_done(struct _mail_msg *mm)
|
||
+import_mbox_done (struct _import_mbox_msg *m)
|
||
{
|
||
- struct _import_mbox_msg *m = (struct _import_mbox_msg *)mm;
|
||
-
|
||
if (m->done)
|
||
- m->done(m->done_data, &mm->ex);
|
||
+ m->done(m->done_data, &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-import_mbox_free (struct _mail_msg *mm)
|
||
+import_mbox_free (struct _import_mbox_msg *m)
|
||
{
|
||
- struct _import_mbox_msg *m = (struct _import_mbox_msg *)mm;
|
||
-
|
||
if (m->cancel)
|
||
camel_operation_unref(m->cancel);
|
||
g_free(m->uri);
|
||
g_free(m->path);
|
||
}
|
||
|
||
-static struct _mail_msg_op import_mbox_op = {
|
||
- import_mbox_describe,
|
||
- import_mbox_import,
|
||
- import_mbox_done,
|
||
- import_mbox_free,
|
||
+static MailMsgInfo import_mbox_info = {
|
||
+ sizeof (struct _import_mbox_msg),
|
||
+ (MailMsgDescFunc) import_mbox_desc,
|
||
+ (MailMsgExecFunc) import_mbox_exec,
|
||
+ (MailMsgDoneFunc) import_mbox_done,
|
||
+ (MailMsgFreeFunc) import_mbox_free
|
||
};
|
||
|
||
int
|
||
@@ -318,7 +314,7 @@ mail_importer_import_mbox(const char *pa
|
||
struct _import_mbox_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&import_mbox_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new(&import_mbox_info);
|
||
m->path = g_strdup(path);
|
||
m->uri = g_strdup(folderuri);
|
||
m->done = done;
|
||
@@ -328,8 +324,8 @@ mail_importer_import_mbox(const char *pa
|
||
camel_operation_ref(cancel);
|
||
}
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_queued, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_fast_ordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -339,7 +335,7 @@ mail_importer_import_mbox_sync(const cha
|
||
{
|
||
struct _import_mbox_msg *m;
|
||
|
||
- m = mail_msg_new(&import_mbox_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new(&import_mbox_info);
|
||
m->path = g_strdup(path);
|
||
m->uri = g_strdup(folderuri);
|
||
if (cancel) {
|
||
@@ -347,9 +343,9 @@ mail_importer_import_mbox_sync(const cha
|
||
camel_operation_ref(cancel);
|
||
}
|
||
|
||
- import_mbox_import(&m->msg);
|
||
- import_mbox_done(&m->msg);
|
||
- mail_msg_free(&m->msg);
|
||
+ import_mbox_exec(&m->base);
|
||
+ import_mbox_done(&m->base);
|
||
+ mail_msg_unref(m);
|
||
}
|
||
|
||
struct _import_folders_data {
|
||
--- evolution-2.11.3/mail/importers/pine-importer.c.kill-ethread 2007-04-18 06:17:29.000000000 -0400
|
||
+++ evolution-2.11.3/mail/importers/pine-importer.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -56,7 +56,7 @@
|
||
#define d(x) x
|
||
|
||
struct _pine_import_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
EImport *import;
|
||
EImportTarget *target;
|
||
@@ -223,8 +223,8 @@ import_contacts(void)
|
||
g_object_unref(book);
|
||
}
|
||
|
||
-static char *
|
||
-pine_import_describe (struct _mail_msg *mm, int complete)
|
||
+static gchar *
|
||
+pine_import_desc (struct _pine_import_msg *m)
|
||
{
|
||
return g_strdup (_("Importing Pine data"));
|
||
}
|
||
@@ -236,10 +236,8 @@ static MailImporterSpecial pine_special_
|
||
};
|
||
|
||
static void
|
||
-pine_import_import(struct _mail_msg *mm)
|
||
+pine_import_exec(struct _pine_import_msg *m)
|
||
{
|
||
- struct _pine_import_msg *m = (struct _pine_import_msg *) mm;
|
||
-
|
||
if (GPOINTER_TO_INT(g_datalist_get_data(&m->target->data, "pine-do-addr")))
|
||
import_contacts();
|
||
|
||
@@ -253,13 +251,11 @@ pine_import_import(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-pine_import_imported(struct _mail_msg *mm)
|
||
+pine_import_done(struct _pine_import_msg *m)
|
||
{
|
||
- struct _pine_import_msg *m = (struct _pine_import_msg *)mm;
|
||
-
|
||
printf("importing complete\n");
|
||
|
||
- if (!camel_exception_is_set(&mm->ex)) {
|
||
+ if (!camel_exception_is_set(&m->base.ex)) {
|
||
GConfClient *gconf;
|
||
|
||
gconf = gconf_client_get_default();
|
||
@@ -274,10 +270,8 @@ pine_import_imported(struct _mail_msg *m
|
||
}
|
||
|
||
static void
|
||
-pine_import_free(struct _mail_msg *mm)
|
||
+pine_import_free(struct _pine_import_msg *m)
|
||
{
|
||
- struct _pine_import_msg *m = (struct _pine_import_msg *)mm;
|
||
-
|
||
camel_operation_unref(m->status);
|
||
|
||
g_free(m->status_what);
|
||
@@ -326,11 +320,12 @@ pine_status_timeout(void *data)
|
||
return TRUE;
|
||
}
|
||
|
||
-static struct _mail_msg_op pine_import_op = {
|
||
- pine_import_describe,
|
||
- pine_import_import,
|
||
- pine_import_imported,
|
||
- pine_import_free,
|
||
+static MailMsgInfo pine_import_info = {
|
||
+ sizeof (struct _pine_import_msg),
|
||
+ (MailMsgDescFunc) pine_import_desc,
|
||
+ (MailMsgExecFunc) pine_import_exec,
|
||
+ (MailMsgDoneFunc) pine_import_done,
|
||
+ (MailMsgFreeFunc) pine_import_free
|
||
};
|
||
|
||
static int
|
||
@@ -339,7 +334,7 @@ mail_importer_pine_import(EImport *ei, E
|
||
struct _pine_import_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&pine_import_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new(&pine_import_info);
|
||
g_datalist_set_data(&target->data, "pine-msg", m);
|
||
m->import = ei;
|
||
g_object_ref(m->import);
|
||
@@ -348,9 +343,9 @@ mail_importer_pine_import(EImport *ei, E
|
||
m->status_lock = g_mutex_new();
|
||
m->status = camel_operation_new(pine_status, m);
|
||
|
||
- id = m->msg.seq;
|
||
+ id = m->base.seq;
|
||
|
||
- e_thread_put(mail_thread_queued, (EMsg *)m);
|
||
+ mail_msg_fast_ordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
--- evolution-2.11.3/mail/em-utils.c.kill-ethread 2007-06-04 14:25:09.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-utils.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -1906,7 +1906,7 @@ em_utils_in_addressbook(CamelInternetAdd
|
||
ESource *source = s->data;
|
||
GList *contacts;
|
||
EBook *book;
|
||
- void *hook;
|
||
+ GHook *hook;
|
||
|
||
d(printf(" checking '%s'\n", e_source_get_uri(source)));
|
||
|
||
--- evolution-2.11.3/mail/mail-vfolder.c.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-vfolder.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -21,7 +21,7 @@
|
||
*/
|
||
|
||
#include <config.h>
|
||
-
|
||
+#include <pthread.h>
|
||
#include <string.h>
|
||
|
||
#include <glib.h>
|
||
@@ -75,7 +75,7 @@ static void rule_changed(FilterRule *rul
|
||
/* ********************************************************************** */
|
||
|
||
struct _setup_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *folder;
|
||
char *query;
|
||
@@ -83,18 +83,15 @@ struct _setup_msg {
|
||
GList *sources_folder;
|
||
};
|
||
|
||
-static char *
|
||
-vfolder_setup_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+vfolder_setup_desc (struct _setup_msg *m)
|
||
{
|
||
- struct _setup_msg *m = (struct _setup_msg *)mm;
|
||
-
|
||
return g_strdup_printf(_("Setting up Search Folder: %s"), m->folder->full_name);
|
||
}
|
||
|
||
static void
|
||
-vfolder_setup_do(struct _mail_msg *mm)
|
||
+vfolder_setup_exec (struct _setup_msg *m)
|
||
{
|
||
- struct _setup_msg *m = (struct _setup_msg *)mm;
|
||
GList *l, *list = NULL;
|
||
CamelFolder *folder;
|
||
|
||
@@ -105,12 +102,12 @@ vfolder_setup_do(struct _mail_msg *mm)
|
||
l = m->sources_uri;
|
||
while (l && !shutdown) {
|
||
d(printf(" Adding uri: %s\n", (char *)l->data));
|
||
- folder = mail_tool_uri_to_folder (l->data, 0, &mm->ex);
|
||
+ folder = mail_tool_uri_to_folder (l->data, 0, &m->base.ex);
|
||
if (folder) {
|
||
list = g_list_append(list, folder);
|
||
} else {
|
||
g_warning("Could not open vfolder source: %s", (char *)l->data);
|
||
- camel_exception_clear(&mm->ex);
|
||
+ camel_exception_clear(&m->base.ex);
|
||
}
|
||
l = l->next;
|
||
}
|
||
@@ -135,17 +132,13 @@ vfolder_setup_do(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-vfolder_setup_done(struct _mail_msg *mm)
|
||
+vfolder_setup_done (struct _setup_msg *m)
|
||
{
|
||
- struct _setup_msg *m = (struct _setup_msg *)mm;
|
||
-
|
||
- m = m;
|
||
}
|
||
|
||
static void
|
||
-vfolder_setup_free (struct _mail_msg *mm)
|
||
+vfolder_setup_free (struct _setup_msg *m)
|
||
{
|
||
- struct _setup_msg *m = (struct _setup_msg *)mm;
|
||
GList *l;
|
||
|
||
camel_object_unref(m->folder);
|
||
@@ -166,11 +159,12 @@ vfolder_setup_free (struct _mail_msg *mm
|
||
g_list_free(m->sources_folder);
|
||
}
|
||
|
||
-static struct _mail_msg_op vfolder_setup_op = {
|
||
- vfolder_setup_desc,
|
||
- vfolder_setup_do,
|
||
- vfolder_setup_done,
|
||
- vfolder_setup_free,
|
||
+static MailMsgInfo vfolder_setup_info = {
|
||
+ sizeof (struct _setup_msg),
|
||
+ (MailMsgDescFunc) vfolder_setup_desc,
|
||
+ (MailMsgExecFunc) vfolder_setup_exec,
|
||
+ (MailMsgDoneFunc) vfolder_setup_done,
|
||
+ (MailMsgFreeFunc) vfolder_setup_free
|
||
};
|
||
|
||
/* sources_uri should be camel uri's */
|
||
@@ -180,15 +174,15 @@ vfolder_setup(CamelFolder *folder, const
|
||
struct _setup_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&vfolder_setup_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new(&vfolder_setup_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->query = g_strdup(query);
|
||
m->sources_uri = sources_uri;
|
||
m->sources_folder = sources_folder;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_slow_ordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -196,17 +190,16 @@ vfolder_setup(CamelFolder *folder, const
|
||
/* ********************************************************************** */
|
||
|
||
struct _adduri_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
char *uri;
|
||
GList *folders;
|
||
int remove;
|
||
};
|
||
|
||
-static char *
|
||
-vfolder_adduri_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+vfolder_adduri_desc (struct _adduri_msg *m)
|
||
{
|
||
- struct _adduri_msg *m = (struct _adduri_msg *)mm;
|
||
char *euri, *desc = NULL;
|
||
|
||
/* Yuck yuck. Lookup the account name and use that to describe the path */
|
||
@@ -250,9 +243,8 @@ vfolder_adduri_desc(struct _mail_msg *mm
|
||
}
|
||
|
||
static void
|
||
-vfolder_adduri_do(struct _mail_msg *mm)
|
||
+vfolder_adduri_exec (struct _adduri_msg *m)
|
||
{
|
||
- struct _adduri_msg *m = (struct _adduri_msg *)mm;
|
||
GList *l;
|
||
CamelFolder *folder = NULL;
|
||
|
||
@@ -269,7 +261,7 @@ vfolder_adduri_do(struct _mail_msg *mm)
|
||
}
|
||
|
||
if (folder == NULL)
|
||
- folder = mail_tool_uri_to_folder (m->uri, 0, &mm->ex);
|
||
+ folder = mail_tool_uri_to_folder (m->uri, 0, &m->base.ex);
|
||
|
||
if (folder != NULL) {
|
||
l = m->folders;
|
||
@@ -285,28 +277,24 @@ vfolder_adduri_do(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-vfolder_adduri_done(struct _mail_msg *mm)
|
||
+vfolder_adduri_done(struct _adduri_msg *m)
|
||
{
|
||
- struct _adduri_msg *m = (struct _adduri_msg *)mm;
|
||
-
|
||
- m = m;
|
||
}
|
||
|
||
static void
|
||
-vfolder_adduri_free (struct _mail_msg *mm)
|
||
+vfolder_adduri_free (struct _adduri_msg *m)
|
||
{
|
||
- struct _adduri_msg *m = (struct _adduri_msg *)mm;
|
||
-
|
||
g_list_foreach(m->folders, (GFunc)camel_object_unref, NULL);
|
||
g_list_free(m->folders);
|
||
g_free(m->uri);
|
||
}
|
||
|
||
-static struct _mail_msg_op vfolder_adduri_op = {
|
||
- vfolder_adduri_desc,
|
||
- vfolder_adduri_do,
|
||
- vfolder_adduri_done,
|
||
- vfolder_adduri_free,
|
||
+static MailMsgInfo vfolder_adduri_info = {
|
||
+ sizeof (struct _adduri_msg),
|
||
+ (MailMsgDescFunc) vfolder_adduri_desc,
|
||
+ (MailMsgExecFunc) vfolder_adduri_exec,
|
||
+ (MailMsgDoneFunc) vfolder_adduri_done,
|
||
+ (MailMsgFreeFunc) vfolder_adduri_free
|
||
};
|
||
|
||
|
||
@@ -317,13 +305,13 @@ vfolder_adduri(const char *uri, GList *f
|
||
struct _adduri_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&vfolder_adduri_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new(&vfolder_adduri_info);
|
||
m->folders = folders;
|
||
m->uri = g_strdup(uri);
|
||
m->remove = remove;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_slow_ordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -447,7 +435,7 @@ mail_vfolder_add_uri(CamelStore *store,
|
||
return;
|
||
}
|
||
|
||
- g_assert(pthread_equal(pthread_self(), mail_gui_thread));
|
||
+ g_assert(mail_in_main_thread());
|
||
|
||
is_ignore = uri_is_ignore(store, curi);
|
||
|
||
@@ -540,7 +528,7 @@ mail_vfolder_delete_uri(CamelStore *stor
|
||
|
||
d(printf ("Deleting uri to check: %s\n", uri));
|
||
|
||
- g_assert (pthread_equal(pthread_self(), mail_gui_thread));
|
||
+ g_assert (mail_in_main_thread());
|
||
|
||
changed = g_string_new ("");
|
||
|
||
@@ -615,7 +603,7 @@ mail_vfolder_rename_uri(CamelStore *stor
|
||
if (context == NULL || uri_is_spethal(store, cfrom) || uri_is_spethal(store, cto))
|
||
return;
|
||
|
||
- g_assert(pthread_equal(pthread_self(), mail_gui_thread));
|
||
+ g_assert(mail_in_main_thread());
|
||
|
||
from = em_uri_from_camel(cfrom);
|
||
to = em_uri_from_camel(cto);
|
||
--- evolution-2.11.3/mail/em-format-html.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-format-html.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -165,7 +165,7 @@ efh_gtkhtml_destroy(GtkHTML *html, EMFor
|
||
if (efh->priv->format_timeout_id != 0) {
|
||
g_source_remove(efh->priv->format_timeout_id);
|
||
efh->priv->format_timeout_id = 0;
|
||
- mail_msg_free(efh->priv->format_timeout_msg);
|
||
+ mail_msg_unref(efh->priv->format_timeout_msg);
|
||
efh->priv->format_timeout_msg = NULL;
|
||
}
|
||
|
||
@@ -1179,7 +1179,7 @@ efh_builtin_init(EMFormatHTMLClass *efhc
|
||
|
||
/* Sigh, this is so we have a cancellable, async rendering thread */
|
||
struct _format_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
EMFormatHTML *format;
|
||
EMFormat *format_source;
|
||
@@ -1189,14 +1189,15 @@ struct _format_msg {
|
||
CamelMimeMessage *message;
|
||
};
|
||
|
||
-static char *efh_format_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+efh_format_desc (struct _format_msg *m)
|
||
{
|
||
return g_strdup(_("Formatting message"));
|
||
}
|
||
|
||
-static void efh_format_do(struct _mail_msg *mm)
|
||
+static void
|
||
+efh_format_exec (struct _format_msg *m)
|
||
{
|
||
- struct _format_msg *m = (struct _format_msg *)mm;
|
||
struct _EMFormatHTMLJob *job;
|
||
struct _EMFormatPURITree *puri_level;
|
||
int cancelled = FALSE;
|
||
@@ -1281,10 +1282,9 @@ static void efh_format_do(struct _mail_m
|
||
((EMFormat *)m->format)->pending_uri_level = puri_level;
|
||
}
|
||
|
||
-static void efh_format_done(struct _mail_msg *mm)
|
||
+static void
|
||
+efh_format_done (struct _format_msg *m)
|
||
{
|
||
- struct _format_msg *m = (struct _format_msg *)mm;
|
||
-
|
||
d(printf("formatting finished\n"));
|
||
|
||
m->format->load_http_now = FALSE;
|
||
@@ -1292,10 +1292,9 @@ static void efh_format_done(struct _mail
|
||
g_signal_emit_by_name(m->format, "complete");
|
||
}
|
||
|
||
-static void efh_format_free(struct _mail_msg *mm)
|
||
+static void
|
||
+efh_format_free (struct _format_msg *m)
|
||
{
|
||
- struct _format_msg *m = (struct _format_msg *)mm;
|
||
-
|
||
d(printf("formatter freed\n"));
|
||
g_object_unref(m->format);
|
||
if (m->estream) {
|
||
@@ -1311,11 +1310,12 @@ static void efh_format_free(struct _mail
|
||
g_object_unref(m->format_source);
|
||
}
|
||
|
||
-static struct _mail_msg_op efh_format_op = {
|
||
- efh_format_desc,
|
||
- efh_format_do,
|
||
- efh_format_done,
|
||
- efh_format_free,
|
||
+static MailMsgInfo efh_format_info = {
|
||
+ sizeof (struct _format_msg),
|
||
+ (MailMsgDescFunc) efh_format_desc,
|
||
+ (MailMsgExecFunc) efh_format_exec,
|
||
+ (MailMsgDoneFunc) efh_format_done,
|
||
+ (MailMsgFreeFunc) efh_format_free
|
||
};
|
||
|
||
static gboolean
|
||
@@ -1326,7 +1326,7 @@ efh_format_timeout(struct _format_msg *m
|
||
struct _EMFormatHTMLPrivate *p = efh->priv;
|
||
|
||
if (m->format->html == NULL) {
|
||
- mail_msg_free(m);
|
||
+ mail_msg_unref(m);
|
||
return FALSE;
|
||
}
|
||
|
||
@@ -1354,7 +1354,7 @@ efh_format_timeout(struct _format_msg *m
|
||
if (m->message == NULL) {
|
||
hstream = gtk_html_begin(efh->html);
|
||
gtk_html_stream_close(hstream, GTK_HTML_STREAM_OK);
|
||
- mail_msg_free(m);
|
||
+ mail_msg_unref(m);
|
||
p->last_part = NULL;
|
||
} else {
|
||
hstream = NULL;
|
||
@@ -1373,8 +1373,8 @@ efh_format_timeout(struct _format_msg *m
|
||
p->last_part = m->message;
|
||
}
|
||
|
||
- efh->priv->format_id = m->msg.seq;
|
||
- e_thread_put(mail_thread_new, (EMsg *)m);
|
||
+ efh->priv->format_id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
efh->priv->format_timeout_id = 0;
|
||
@@ -1398,11 +1398,11 @@ static void efh_format_clone(EMFormat *e
|
||
d(printf(" timeout for last still active, removing ...\n"));
|
||
g_source_remove(efh->priv->format_timeout_id);
|
||
efh->priv->format_timeout_id = 0;
|
||
- mail_msg_free(efh->priv->format_timeout_msg);
|
||
+ mail_msg_unref(efh->priv->format_timeout_msg);
|
||
efh->priv->format_timeout_msg = NULL;
|
||
}
|
||
|
||
- m = mail_msg_new(&efh_format_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&efh_format_info);
|
||
m->format = (EMFormatHTML *)emf;
|
||
g_object_ref(emf);
|
||
m->format_source = emfsource;
|
||
--- evolution-2.11.3/mail/em-folder-properties.c.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-folder-properties.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -386,7 +386,7 @@ em_folder_properties_show(GtkWindow *par
|
||
}
|
||
|
||
if (folder == NULL)
|
||
- mail_get_folder(uri, 0, emfp_dialog_got_folder, NULL, mail_thread_new);
|
||
+ mail_get_folder(uri, 0, emfp_dialog_got_folder, NULL, mail_msg_unordered_push);
|
||
else
|
||
emfp_dialog_got_folder((char *)uri, folder, NULL);
|
||
}
|
||
--- evolution-2.11.3/mail/em-folder-tree.c.kill-ethread 2007-06-04 01:52:58.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-folder-tree.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -834,7 +834,7 @@ fail:
|
||
/* TODO: Merge the drop handling code/menu's into one spot using a popup target for details */
|
||
/* Drop handling */
|
||
struct _DragDataReceivedAsync {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
/* input data */
|
||
GdkDragContext *context;
|
||
@@ -859,17 +859,16 @@ emft_drop_folder(struct _DragDataReceive
|
||
|
||
d(printf(" * Drop folder '%s' onto '%s'\n", m->selection->data, m->full_name));
|
||
|
||
- if (!(src = mail_tool_uri_to_folder((char *)m->selection->data, 0, &m->msg.ex)))
|
||
+ if (!(src = mail_tool_uri_to_folder((char *)m->selection->data, 0, &m->base.ex)))
|
||
return;
|
||
|
||
em_folder_utils_copy_folders(src->parent_store, src->full_name, m->store, m->full_name?m->full_name:"", m->move);
|
||
camel_object_unref(src);
|
||
}
|
||
|
||
-static char *
|
||
-emft_drop_async_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+emft_drop_async__desc (struct _DragDataReceivedAsync *m)
|
||
{
|
||
- struct _DragDataReceivedAsync *m = (struct _DragDataReceivedAsync *) mm;
|
||
CamelURL *url;
|
||
char *buf;
|
||
|
||
@@ -893,9 +892,8 @@ emft_drop_async_desc (struct _mail_msg *
|
||
}
|
||
|
||
static void
|
||
-emft_drop_async_drop (struct _mail_msg *mm)
|
||
+emft_drop_async__exec (struct _DragDataReceivedAsync *m)
|
||
{
|
||
- struct _DragDataReceivedAsync *m = (struct _DragDataReceivedAsync *) mm;
|
||
CamelFolder *folder;
|
||
|
||
/* for types other than folder, we can't drop to the root path */
|
||
@@ -903,14 +901,14 @@ emft_drop_async_drop (struct _mail_msg *
|
||
/* copy or move (aka rename) a folder */
|
||
emft_drop_folder(m);
|
||
} else if (m->full_name == NULL) {
|
||
- camel_exception_set (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
|
||
+ camel_exception_set (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
|
||
_("Cannot drop message(s) into toplevel store"));
|
||
- } else if ((folder = camel_store_get_folder (m->store, m->full_name, 0, &mm->ex))) {
|
||
+ } else if ((folder = camel_store_get_folder (m->store, m->full_name, 0, &m->base.ex))) {
|
||
switch (m->info) {
|
||
case DND_DROP_TYPE_UID_LIST:
|
||
/* import a list of uids from another evo folder */
|
||
- em_utils_selection_get_uidlist(m->selection, folder, m->move, &mm->ex);
|
||
- m->moved = m->move && !camel_exception_is_set(&mm->ex);
|
||
+ em_utils_selection_get_uidlist(m->selection, folder, m->move, &m->base.ex);
|
||
+ m->moved = m->move && !camel_exception_is_set(&m->base.ex);
|
||
break;
|
||
case DND_DROP_TYPE_MESSAGE_RFC822:
|
||
/* import a message/rfc822 stream */
|
||
@@ -928,9 +926,8 @@ emft_drop_async_drop (struct _mail_msg *
|
||
}
|
||
|
||
static void
|
||
-emft_drop_async_done (struct _mail_msg *mm)
|
||
+emft_drop_async__done (struct _DragDataReceivedAsync *m)
|
||
{
|
||
- struct _DragDataReceivedAsync *m = (struct _DragDataReceivedAsync *) mm;
|
||
gboolean success, delete;
|
||
|
||
/* ?? */
|
||
@@ -938,7 +935,7 @@ emft_drop_async_done (struct _mail_msg *
|
||
success = FALSE;
|
||
delete = FALSE;
|
||
} else {
|
||
- success = !camel_exception_is_set (&mm->ex);
|
||
+ success = !camel_exception_is_set (&m->base.ex);
|
||
delete = success && m->move && !m->moved;
|
||
}
|
||
|
||
@@ -946,10 +943,8 @@ emft_drop_async_done (struct _mail_msg *
|
||
}
|
||
|
||
static void
|
||
-emft_drop_async_free (struct _mail_msg *mm)
|
||
+emft_drop_async__free (struct _DragDataReceivedAsync *m)
|
||
{
|
||
- struct _DragDataReceivedAsync *m = (struct _DragDataReceivedAsync *) mm;
|
||
-
|
||
g_object_unref(m->context);
|
||
camel_object_unref(m->store);
|
||
g_free(m->full_name);
|
||
@@ -958,18 +953,19 @@ emft_drop_async_free (struct _mail_msg *
|
||
g_free(m->selection);
|
||
}
|
||
|
||
-static struct _mail_msg_op emft_drop_async_op = {
|
||
- emft_drop_async_desc,
|
||
- emft_drop_async_drop,
|
||
- emft_drop_async_done,
|
||
- emft_drop_async_free,
|
||
+static MailMsgInfo emft_drop_async_info = {
|
||
+ sizeof (struct _DragDataReceivedAsync),
|
||
+ (MailMsgDescFunc) emft_drop_async__desc,
|
||
+ (MailMsgExecFunc) emft_drop_async__exec,
|
||
+ (MailMsgDoneFunc) emft_drop_async__done,
|
||
+ (MailMsgFreeFunc) emft_drop_async__free
|
||
};
|
||
|
||
static void
|
||
tree_drag_data_action(struct _DragDataReceivedAsync *m)
|
||
{
|
||
m->move = m->action == GDK_ACTION_MOVE;
|
||
- e_thread_put (mail_thread_new, (EMsg *) m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
static void
|
||
@@ -996,7 +992,7 @@ emft_drop_popup_cancel(EPopup *ep, EPopu
|
||
struct _DragDataReceivedAsync *m = data;
|
||
|
||
m->aborted = TRUE;
|
||
- mail_msg_free(&m->msg);
|
||
+ mail_msg_unref(m);
|
||
}
|
||
|
||
static EPopupItem emft_drop_popup_menu[] = {
|
||
@@ -1052,7 +1048,7 @@ tree_drag_data_received(GtkWidget *widge
|
||
return;
|
||
}
|
||
|
||
- m = mail_msg_new (&emft_drop_async_op, NULL, sizeof (struct _DragDataReceivedAsync));
|
||
+ m = mail_msg_new (&emft_drop_async_info);
|
||
m->context = context;
|
||
g_object_ref(context);
|
||
m->store = store;
|
||
@@ -1686,7 +1682,7 @@ dump_fi (CamelFolderInfo *fi, int depth)
|
||
#endif
|
||
|
||
struct _EMFolderTreeGetFolderInfo {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
/* input data */
|
||
GtkTreeRowReference *root;
|
||
@@ -1699,10 +1695,9 @@ struct _EMFolderTreeGetFolderInfo {
|
||
CamelFolderInfo *fi;
|
||
};
|
||
|
||
-static char *
|
||
-emft_get_folder_info__desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+emft_get_folder_info__desc (struct _EMFolderTreeGetFolderInfo *m)
|
||
{
|
||
- struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *)mm;
|
||
char *ret, *name;
|
||
|
||
name = camel_service_get_name((CamelService *)m->store, TRUE);
|
||
@@ -1712,18 +1707,16 @@ emft_get_folder_info__desc(struct _mail_
|
||
}
|
||
|
||
static void
|
||
-emft_get_folder_info__get (struct _mail_msg *mm)
|
||
+emft_get_folder_info__exec (struct _EMFolderTreeGetFolderInfo *m)
|
||
{
|
||
- struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *) mm;
|
||
guint32 flags = m->flags | CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;
|
||
|
||
- m->fi = camel_store_get_folder_info (m->store, m->top, flags, &mm->ex);
|
||
+ m->fi = camel_store_get_folder_info (m->store, m->top, flags, &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-emft_get_folder_info__got (struct _mail_msg *mm)
|
||
+emft_get_folder_info__done (struct _EMFolderTreeGetFolderInfo *m)
|
||
{
|
||
- struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *) mm;
|
||
struct _EMFolderTreePrivate *priv = m->emft->priv;
|
||
struct _EMFolderTreeModelStoreInfo *si;
|
||
GtkTreeIter root, iter;
|
||
@@ -1751,7 +1744,7 @@ emft_get_folder_info__got (struct _mail_
|
||
gtk_tree_model_get_iter ((GtkTreeModel *) model, &root, path);
|
||
|
||
/* if we had an error, then we need to re-set the load subdirs state and collapse the node */
|
||
- if (!m->fi && camel_exception_is_set(&mm->ex)) {
|
||
+ if (!m->fi && camel_exception_is_set(&m->base.ex)) {
|
||
gtk_tree_store_set(model, &root, COL_BOOL_LOAD_SUBDIRS, TRUE, -1);
|
||
gtk_tree_view_collapse_row (priv->treeview, path);
|
||
gtk_tree_path_free (path);
|
||
@@ -1806,10 +1799,8 @@ emft_get_folder_info__got (struct _mail_
|
||
}
|
||
|
||
static void
|
||
-emft_get_folder_info__free (struct _mail_msg *mm)
|
||
+emft_get_folder_info__free (struct _EMFolderTreeGetFolderInfo *m)
|
||
{
|
||
- struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *) mm;
|
||
-
|
||
camel_store_free_folder_info (m->store, m->fi);
|
||
|
||
gtk_tree_row_reference_free (m->root);
|
||
@@ -1818,11 +1809,12 @@ emft_get_folder_info__free (struct _mail
|
||
g_free (m->top);
|
||
}
|
||
|
||
-static struct _mail_msg_op get_folder_info_op = {
|
||
- emft_get_folder_info__desc,
|
||
- emft_get_folder_info__get,
|
||
- emft_get_folder_info__got,
|
||
- emft_get_folder_info__free,
|
||
+static MailMsgInfo get_folder_info_info = {
|
||
+ sizeof (struct _EMFolderTreeGetFolderInfo),
|
||
+ (MailMsgDescFunc) emft_get_folder_info__desc,
|
||
+ (MailMsgExecFunc) emft_get_folder_info__exec,
|
||
+ (MailMsgDoneFunc) emft_get_folder_info__done,
|
||
+ (MailMsgFreeFunc) emft_get_folder_info__free
|
||
};
|
||
|
||
static void
|
||
@@ -1909,7 +1901,7 @@ emft_tree_row_expanded (GtkTreeView *tre
|
||
|
||
gtk_tree_store_set((GtkTreeStore *)model, root, COL_BOOL_LOAD_SUBDIRS, FALSE, -1);
|
||
|
||
- m = mail_msg_new (&get_folder_info_op, NULL, sizeof (struct _EMFolderTreeGetFolderInfo));
|
||
+ m = mail_msg_new (&get_folder_info_info);
|
||
m->root = gtk_tree_row_reference_new (model, tree_path);
|
||
camel_object_ref (store);
|
||
m->store = store;
|
||
@@ -1918,7 +1910,7 @@ emft_tree_row_expanded (GtkTreeView *tre
|
||
m->top = full_name;
|
||
m->flags = CAMEL_STORE_FOLDER_INFO_RECURSIVE|CAMEL_STORE_FOLDER_INFO_FAST;
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *) m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
static gboolean
|
||
--- evolution-2.11.3/mail/em-folder-browser.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-folder-browser.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -839,7 +839,7 @@ get_view_query (ESearchBar *esb)
|
||
|
||
|
||
struct _setup_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelFolder *folder;
|
||
char *query;
|
||
@@ -847,16 +847,15 @@ struct _setup_msg {
|
||
GList *sources_folder;
|
||
};
|
||
|
||
-static char *
|
||
-vfolder_setup_desc(struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+vfolder_setup_desc(struct _setup_msg *m)
|
||
{
|
||
return g_strdup(_("Searching"));
|
||
}
|
||
|
||
static void
|
||
-vfolder_setup_do(struct _mail_msg *mm)
|
||
+vfolder_setup_exec(struct _setup_msg *m)
|
||
{
|
||
- struct _setup_msg *m = (struct _setup_msg *)mm;
|
||
GList *l, *list = NULL;
|
||
CamelFolder *folder;
|
||
|
||
@@ -867,12 +866,12 @@ vfolder_setup_do(struct _mail_msg *mm)
|
||
l = m->sources_uri;
|
||
while (l) {
|
||
d(printf(" Adding uri: %s\n", (char *)l->data));
|
||
- folder = mail_tool_uri_to_folder (l->data, 0, &mm->ex);
|
||
+ folder = mail_tool_uri_to_folder (l->data, 0, &m->base.ex);
|
||
if (folder) {
|
||
list = g_list_append(list, folder);
|
||
} else {
|
||
g_warning("Could not open vfolder source: %s", (char *)l->data);
|
||
- camel_exception_clear(&mm->ex);
|
||
+ camel_exception_clear(&m->base.ex);
|
||
}
|
||
l = l->next;
|
||
}
|
||
@@ -896,17 +895,13 @@ vfolder_setup_do(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-vfolder_setup_done(struct _mail_msg *mm)
|
||
+vfolder_setup_done(struct _setup_msg *m)
|
||
{
|
||
- struct _setup_msg *m = (struct _setup_msg *)mm;
|
||
-
|
||
- m = m;
|
||
}
|
||
|
||
static void
|
||
-vfolder_setup_free (struct _mail_msg *mm)
|
||
+vfolder_setup_free (struct _setup_msg *m)
|
||
{
|
||
- struct _setup_msg *m = (struct _setup_msg *)mm;
|
||
GList *l;
|
||
|
||
camel_object_unref(m->folder);
|
||
@@ -927,11 +922,12 @@ vfolder_setup_free (struct _mail_msg *mm
|
||
g_list_free(m->sources_folder);
|
||
}
|
||
|
||
-static struct _mail_msg_op vfolder_setup_op = {
|
||
- vfolder_setup_desc,
|
||
- vfolder_setup_do,
|
||
- vfolder_setup_done,
|
||
- vfolder_setup_free,
|
||
+static MailMsgInfo vfolder_setup_info = {
|
||
+ sizeof (struct _setup_msg),
|
||
+ (MailMsgDescFunc) vfolder_setup_desc,
|
||
+ (MailMsgExecFunc) vfolder_setup_exec,
|
||
+ (MailMsgDoneFunc) vfolder_setup_done,
|
||
+ (MailMsgFreeFunc) vfolder_setup_free
|
||
};
|
||
|
||
/* sources_uri should be camel uri's */
|
||
@@ -941,15 +937,15 @@ vfolder_setup(CamelFolder *folder, const
|
||
struct _setup_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new(&vfolder_setup_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new(&vfolder_setup_info);
|
||
m->folder = folder;
|
||
camel_object_ref(folder);
|
||
m->query = g_strdup(query);
|
||
m->sources_uri = sources_uri;
|
||
m->sources_folder = sources_folder;
|
||
|
||
- id = m->msg.seq;
|
||
- e_thread_put(mail_thread_queued_slow, (EMsg *)m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_slow_ordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
--- evolution-2.11.3/mail/message-list.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/message-list.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -1841,7 +1841,7 @@ ml_tree_drag_data_get (ETree *tree, int
|
||
/* TODO: merge this with the folder tree stuff via empopup targets */
|
||
/* Drop handling */
|
||
struct _drop_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
GdkDragContext *context;
|
||
|
||
@@ -1858,11 +1858,9 @@ struct _drop_msg {
|
||
unsigned int aborted:1;
|
||
};
|
||
|
||
-static char *
|
||
-ml_drop_async_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+ml_drop_async_desc (struct _drop_msg *m)
|
||
{
|
||
- struct _drop_msg *m = (struct _drop_msg *) mm;
|
||
-
|
||
if (m->move)
|
||
return g_strdup_printf(_("Moving messages into folder %s"), m->folder->full_name);
|
||
else
|
||
@@ -1870,13 +1868,11 @@ ml_drop_async_desc (struct _mail_msg *mm
|
||
}
|
||
|
||
static void
|
||
-ml_drop_async_drop(struct _mail_msg *mm)
|
||
+ml_drop_async_exec (struct _drop_msg *m)
|
||
{
|
||
- struct _drop_msg *m = (struct _drop_msg *)mm;
|
||
-
|
||
switch (m->info) {
|
||
case DND_X_UID_LIST:
|
||
- em_utils_selection_get_uidlist(m->selection, m->folder, m->action == GDK_ACTION_MOVE, &mm->ex);
|
||
+ em_utils_selection_get_uidlist(m->selection, m->folder, m->action == GDK_ACTION_MOVE, &m->base.ex);
|
||
break;
|
||
case DND_MESSAGE_RFC822:
|
||
em_utils_selection_get_message(m->selection, m->folder);
|
||
@@ -1888,9 +1884,8 @@ ml_drop_async_drop(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-ml_drop_async_done(struct _mail_msg *mm)
|
||
+ml_drop_async_done (struct _drop_msg *m)
|
||
{
|
||
- struct _drop_msg *m = (struct _drop_msg *)mm;
|
||
gboolean success, delete;
|
||
|
||
/* ?? */
|
||
@@ -1898,7 +1893,7 @@ ml_drop_async_done(struct _mail_msg *mm)
|
||
success = FALSE;
|
||
delete = FALSE;
|
||
} else {
|
||
- success = !camel_exception_is_set (&mm->ex);
|
||
+ success = !camel_exception_is_set (&m->base.ex);
|
||
delete = success && m->move && !m->moved;
|
||
}
|
||
|
||
@@ -1906,10 +1901,8 @@ ml_drop_async_done(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-ml_drop_async_free(struct _mail_msg *mm)
|
||
+ml_drop_async_free (struct _drop_msg *m)
|
||
{
|
||
- struct _drop_msg *m = (struct _drop_msg *)mm;
|
||
-
|
||
g_object_unref(m->context);
|
||
camel_object_unref(m->folder);
|
||
|
||
@@ -1917,18 +1910,19 @@ ml_drop_async_free(struct _mail_msg *mm)
|
||
g_free(m->selection);
|
||
}
|
||
|
||
-static struct _mail_msg_op ml_drop_async_op = {
|
||
- ml_drop_async_desc,
|
||
- ml_drop_async_drop,
|
||
- ml_drop_async_done,
|
||
- ml_drop_async_free,
|
||
+static MailMsgInfo ml_drop_async_info = {
|
||
+ sizeof (struct _drop_msg),
|
||
+ (MailMsgDescFunc) ml_drop_async_desc,
|
||
+ (MailMsgExecFunc) ml_drop_async_exec,
|
||
+ (MailMsgDoneFunc) ml_drop_async_done,
|
||
+ (MailMsgFreeFunc) ml_drop_async_free
|
||
};
|
||
|
||
static void
|
||
ml_drop_action(struct _drop_msg *m)
|
||
{
|
||
m->move = m->action == GDK_ACTION_MOVE;
|
||
- e_thread_put (mail_thread_new, (EMsg *) m);
|
||
+ mail_msg_unordered_push (m);
|
||
}
|
||
|
||
static void
|
||
@@ -1955,7 +1949,7 @@ ml_drop_popup_cancel(EPopup *ep, EPopupI
|
||
struct _drop_msg *m = data;
|
||
|
||
m->aborted = TRUE;
|
||
- mail_msg_free(&m->msg);
|
||
+ mail_msg_unref(m);
|
||
}
|
||
|
||
static EPopupItem ml_drop_popup_menu[] = {
|
||
@@ -1985,7 +1979,7 @@ ml_tree_drag_data_received (ETree *tree,
|
||
if (data->data == NULL || data->length == -1)
|
||
return;
|
||
|
||
- m = mail_msg_new(&ml_drop_async_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&ml_drop_async_info);
|
||
m->context = context;
|
||
g_object_ref(context);
|
||
m->folder = ml->folder;
|
||
@@ -3718,7 +3712,7 @@ save_hide_state (MessageList *ml)
|
||
|
||
/* ** REGENERATE MESSAGELIST ********************************************** */
|
||
struct _regen_list_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
int complete;
|
||
|
||
@@ -3746,16 +3740,15 @@ struct _regen_list_msg {
|
||
|
||
*/
|
||
|
||
-static char *
|
||
-regen_list_describe (struct _mail_msg *mm, gint complete)
|
||
+static gchar *
|
||
+regen_list_desc (struct _regen_list_msg *m)
|
||
{
|
||
return g_strdup (_("Generating message list"));
|
||
}
|
||
|
||
static void
|
||
-regen_list_regen (struct _mail_msg *mm)
|
||
+regen_list_exec (struct _regen_list_msg *m)
|
||
{
|
||
- struct _regen_list_msg *m = (struct _regen_list_msg *)mm;
|
||
GPtrArray *uids, *uidnew, *showuids, *searchuids = NULL;
|
||
CamelMessageInfo *info;
|
||
int i;
|
||
@@ -3785,7 +3778,7 @@ regen_list_regen (struct _mail_msg *mm)
|
||
} else
|
||
expr = "(match-all (not (system-flag \"deleted\")))";
|
||
}
|
||
- searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &mm->ex);
|
||
+ searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &m->base.ex);
|
||
} else {
|
||
char *expr;
|
||
|
||
@@ -3795,23 +3788,23 @@ regen_list_regen (struct _mail_msg *mm)
|
||
sprintf(expr, "(and (match-all (not (system-flag \"junk\")))\n %s)", m->search);
|
||
} else
|
||
expr = "(match-all (not (system-flag \"junk\")))";
|
||
- searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &mm->ex);
|
||
+ searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &m->base.ex);
|
||
} else {
|
||
if (m->search)
|
||
- searchuids = uids = camel_folder_search_by_expression (m->folder, m->search, &mm->ex);
|
||
+ searchuids = uids = camel_folder_search_by_expression (m->folder, m->search, &m->base.ex);
|
||
else
|
||
uids = camel_folder_get_uids (m->folder);
|
||
}
|
||
}
|
||
|
||
- if (camel_exception_is_set (&mm->ex))
|
||
+ if (camel_exception_is_set (&m->base.ex))
|
||
return;
|
||
|
||
/* perform hiding */
|
||
if (m->hideexpr && camel_folder_has_search_capability(m->folder)) {
|
||
- uidnew = camel_folder_search_by_expression (m->ml->folder, m->hideexpr, &mm->ex);
|
||
+ uidnew = camel_folder_search_by_expression (m->ml->folder, m->hideexpr, &m->base.ex);
|
||
/* well, lets not abort just because this faileld ... */
|
||
- camel_exception_clear (&mm->ex);
|
||
+ camel_exception_clear (&m->base.ex);
|
||
|
||
if (uidnew) {
|
||
MESSAGE_LIST_LOCK(m->ml, hide_lock);
|
||
@@ -3886,7 +3879,7 @@ regen_list_regen (struct _mail_msg *mm)
|
||
|
||
e_profile_event_emit("list.threaduids", m->folder->full_name, 0);
|
||
|
||
- if (!camel_operation_cancel_check(mm->cancel)) {
|
||
+ if (!camel_operation_cancel_check(m->base.cancel)) {
|
||
/* update/build a new tree */
|
||
if (m->dotree) {
|
||
if (m->tree)
|
||
@@ -3915,17 +3908,15 @@ regen_list_regen (struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-regen_list_regened (struct _mail_msg *mm)
|
||
+regen_list_done (struct _regen_list_msg *m)
|
||
{
|
||
- struct _regen_list_msg *m = (struct _regen_list_msg *)mm;
|
||
-
|
||
if (m->ml->priv->destroyed)
|
||
return;
|
||
|
||
if (!m->complete)
|
||
return;
|
||
|
||
- if (camel_operation_cancel_check(mm->cancel))
|
||
+ if (camel_operation_cancel_check(m->base.cancel))
|
||
return;
|
||
|
||
if (m->ml->folder != m->folder)
|
||
@@ -3976,9 +3967,8 @@ regen_list_regened (struct _mail_msg *mm
|
||
}
|
||
|
||
static void
|
||
-regen_list_free (struct _mail_msg *mm)
|
||
+regen_list_free (struct _regen_list_msg *m)
|
||
{
|
||
- struct _regen_list_msg *m = (struct _regen_list_msg *)mm;
|
||
int i;
|
||
|
||
e_profile_event_emit("list.regenerated", m->folder->full_name, 0);
|
||
@@ -4006,11 +3996,12 @@ regen_list_free (struct _mail_msg *mm)
|
||
g_object_unref(m->ml);
|
||
}
|
||
|
||
-static struct _mail_msg_op regen_list_op = {
|
||
- regen_list_describe,
|
||
- regen_list_regen,
|
||
- regen_list_regened,
|
||
- regen_list_free,
|
||
+static MailMsgInfo regen_list_info = {
|
||
+ sizeof (struct _regen_list_msg),
|
||
+ (MailMsgDescFunc) regen_list_desc,
|
||
+ (MailMsgExecFunc) regen_list_exec,
|
||
+ (MailMsgDoneFunc) regen_list_done,
|
||
+ (MailMsgFreeFunc) regen_list_free
|
||
};
|
||
|
||
static gboolean
|
||
@@ -4020,7 +4011,7 @@ ml_regen_timeout(struct _regen_list_msg
|
||
|
||
m->ml->regen = g_list_prepend(m->ml->regen, m);
|
||
/* TODO: we should manage our own thread stuff, would make cancelling outstanding stuff easier */
|
||
- e_thread_put (mail_thread_queued, (EMsg *)m);
|
||
+ mail_msg_fast_ordered_push (m);
|
||
|
||
m->ml->regen_timeout_msg = NULL;
|
||
m->ml->regen_timeout_id = 0;
|
||
@@ -4036,7 +4027,7 @@ mail_regen_cancel(MessageList *ml)
|
||
GList *l = ml->regen;
|
||
|
||
while (l) {
|
||
- struct _mail_msg *mm = l->data;
|
||
+ MailMsg *mm = l->data;
|
||
|
||
if (mm->cancel)
|
||
camel_operation_cancel(mm->cancel);
|
||
@@ -4048,7 +4039,7 @@ mail_regen_cancel(MessageList *ml)
|
||
if (ml->regen_timeout_id) {
|
||
g_source_remove(ml->regen_timeout_id);
|
||
ml->regen_timeout_id = 0;
|
||
- mail_msg_free((struct _mail_msg *)ml->regen_timeout_msg);
|
||
+ mail_msg_unref(ml->regen_timeout_msg);
|
||
ml->regen_timeout_msg = NULL;
|
||
}
|
||
}
|
||
@@ -4083,7 +4074,7 @@ mail_regen_list (MessageList *ml, const
|
||
}
|
||
#endif
|
||
|
||
- m = mail_msg_new (®en_list_op, NULL, sizeof (*m));
|
||
+ m = mail_msg_new (®en_list_info);
|
||
m->ml = ml;
|
||
m->search = g_strdup (search);
|
||
m->hideexpr = g_strdup (hideexpr);
|
||
--- evolution-2.11.3/mail/em-sync-stream.h.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-sync-stream.h 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -29,41 +29,45 @@ requests are always handled in the main
|
||
#ifndef EM_SYNC_STREAM_H
|
||
#define EM_SYNC_STREAM_H
|
||
|
||
-#ifdef __cplusplus
|
||
-extern "C" {
|
||
-#pragma }
|
||
-#endif /* __cplusplus */
|
||
-
|
||
-#define EM_SYNC_STREAM_TYPE (em_sync_stream_get_type ())
|
||
-#define EM_SYNC_STREAM(obj) (CAMEL_CHECK_CAST((obj), EM_SYNC_STREAM_TYPE, EMSyncStream))
|
||
-#define EM_SYNC_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), EM_SYNC_STREAM_TYPE, EMSyncStreamClass))
|
||
-#define EM_IS_SYNC_STREAM(o) (CAMEL_CHECK_TYPE((o), EM_SYNC_STREAM_TYPE))
|
||
-
|
||
#include <glib.h>
|
||
#include <camel/camel-stream.h>
|
||
|
||
-typedef struct _EMSyncStream {
|
||
- CamelStream parent_stream;
|
||
-
|
||
- struct _EMSyncStreamPrivate *priv;
|
||
+#define EM_SYNC_STREAM_TYPE \
|
||
+ (em_sync_stream_get_type ())
|
||
+#define EM_SYNC_STREAM(obj) \
|
||
+ (CAMEL_CHECK_CAST \
|
||
+ ((obj), EM_SYNC_STREAM_TYPE, EMSyncStream))
|
||
+#define EM_SYNC_STREAM_CLASS(cls) \
|
||
+ (CAMEL_CHECK_CLASS_CAST \
|
||
+ ((cls), EM_SYNC_STREAM_TYPE, EMSyncStreamClass))
|
||
+#define EM_IS_SYNC_STREAM(obj) \
|
||
+ (CAMEL_CHECK_TYPE ((obj), EM_SYNC_STREAM_TYPE))
|
||
+
|
||
+G_BEGIN_DECLS
|
||
+
|
||
+typedef struct _EMSyncStream EMSyncStream;
|
||
+typedef struct _EMSyncStreamClass EMSyncStreamClass;
|
||
+
|
||
+struct _EMSyncStream {
|
||
+ CamelStream parent;
|
||
+ GString *buffer;
|
||
+ gboolean cancel;
|
||
+};
|
||
|
||
- int cancel;
|
||
-} EMSyncStream;
|
||
-
|
||
-typedef struct {
|
||
+struct _EMSyncStreamClass {
|
||
CamelStreamClass parent_class;
|
||
|
||
- ssize_t (*sync_write) (CamelStream *stream, const char *buffer, size_t n);
|
||
- int (*sync_close) (CamelStream *stream);
|
||
- int (*sync_flush) (CamelStream *stream);
|
||
-
|
||
-} EMSyncStreamClass;
|
||
-
|
||
-CamelType em_sync_stream_get_type (void);
|
||
-void em_sync_stream_set_buffer_size(EMSyncStream *, size_t size);
|
||
-
|
||
-#ifdef __cplusplus
|
||
-}
|
||
-#endif /* __cplusplus */
|
||
+ gssize (*sync_write) (CamelStream *stream,
|
||
+ const gchar *string,
|
||
+ gsize len);
|
||
+ int (*sync_close) (CamelStream *stream);
|
||
+ int (*sync_flush) (CamelStream *stream);
|
||
+};
|
||
+
|
||
+CamelType em_sync_stream_get_type (void);
|
||
+void em_sync_stream_set_buffer_size (EMSyncStream *stream,
|
||
+ gsize size);
|
||
+
|
||
+G_END_DECLS
|
||
|
||
#endif /* EM_SYNC_STREAM_H */
|
||
--- evolution-2.11.3/mail/em-format-html-print.c.kill-ethread 2007-04-22 13:20:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-format-html-print.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -224,7 +224,7 @@ em_format_html_print_message (EMFormatHT
|
||
g_object_ref (efhp);
|
||
|
||
mail_get_message (
|
||
- folder, uid, emfhp_got_message, efhp, mail_thread_new);
|
||
+ folder, uid, emfhp_got_message, efhp, mail_msg_unordered_push);
|
||
}
|
||
|
||
void
|
||
--- evolution-2.11.3/mail/em-sync-stream.c.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-sync-stream.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -25,42 +25,17 @@
|
||
#include <config.h>
|
||
#endif
|
||
|
||
-#include <string.h>
|
||
+#include "em-sync-stream.h"
|
||
+
|
||
#include <stdio.h>
|
||
-#include <camel/camel-stream.h>
|
||
+#include <string.h>
|
||
#include <camel/camel-object.h>
|
||
-#include <gtk/gtkmain.h>
|
||
-#include "em-sync-stream.h"
|
||
+#include <libedataserver/e-flag.h>
|
||
|
||
#include "mail-mt.h"
|
||
|
||
-#define LOG_STREAM
|
||
-
|
||
-#define d(x)
|
||
-
|
||
#define EMSS_CLASS(x) ((EMSyncStreamClass *)(((CamelObject *)(x))->klass))
|
||
|
||
-struct _EMSyncStreamPrivate {
|
||
- /* FIXME: use a single data port/gui channel for all instances */
|
||
- /* TODO: possibly just use one of the mail-mt ports ... */
|
||
- struct _EMsgPort *data_port, *reply_port;
|
||
- struct _GIOChannel *gui_channel;
|
||
- guint gui_watch;
|
||
-
|
||
- char *buf_data;
|
||
- int buf_used;
|
||
- int buf_size;
|
||
-
|
||
-#ifdef LOG_STREAM
|
||
- FILE *logfd;
|
||
-#endif
|
||
-};
|
||
-
|
||
-#ifdef LOG_STREAM
|
||
-int dolog;
|
||
-#endif
|
||
-
|
||
-/* Should probably expose messages to outside world ... so subclasses can extend */
|
||
enum _write_msg_t {
|
||
EMSS_WRITE,
|
||
EMSS_FLUSH,
|
||
@@ -68,275 +43,168 @@ enum _write_msg_t {
|
||
};
|
||
|
||
struct _write_msg {
|
||
- EMsg msg;
|
||
+ EMSyncStream *emss;
|
||
+ EFlag *done;
|
||
|
||
enum _write_msg_t op;
|
||
|
||
- const char *data;
|
||
- size_t n;
|
||
+ const gchar *string;
|
||
+ gsize len;
|
||
};
|
||
|
||
-static void em_sync_stream_class_init (EMSyncStreamClass *klass);
|
||
-static void em_sync_stream_init (CamelObject *object);
|
||
-static void em_sync_stream_finalize (CamelObject *object);
|
||
-
|
||
-static ssize_t stream_write(CamelStream *stream, const char *buffer, size_t n);
|
||
-static int stream_close(CamelStream *stream);
|
||
-static int stream_flush(CamelStream *stream);
|
||
-
|
||
static CamelStreamClass *parent_class = NULL;
|
||
|
||
-CamelType
|
||
-em_sync_stream_get_type (void)
|
||
-{
|
||
- static CamelType type = CAMEL_INVALID_TYPE;
|
||
-
|
||
- if (type == CAMEL_INVALID_TYPE) {
|
||
-#ifdef LOG_STREAM
|
||
- dolog = getenv("EVOLUTION_MAIL_LOG_HTML") != NULL;
|
||
-#endif
|
||
- type = camel_type_register (CAMEL_STREAM_TYPE,
|
||
- "EMSyncStream",
|
||
- sizeof (EMSyncStream),
|
||
- sizeof (EMSyncStreamClass),
|
||
- (CamelObjectClassInitFunc) em_sync_stream_class_init,
|
||
- NULL,
|
||
- (CamelObjectInitFunc) em_sync_stream_init,
|
||
- (CamelObjectFinalizeFunc) em_sync_stream_finalize);
|
||
- }
|
||
-
|
||
- return type;
|
||
-}
|
||
-
|
||
-static void
|
||
-em_sync_stream_class_init (EMSyncStreamClass *klass)
|
||
-{
|
||
- CamelStreamClass *stream_class = CAMEL_STREAM_CLASS (klass);
|
||
-
|
||
- parent_class = (CamelStreamClass *) CAMEL_STREAM_TYPE;
|
||
-
|
||
- /* virtual method overload */
|
||
- stream_class->write = stream_write;
|
||
- stream_class->flush = stream_flush;
|
||
- stream_class->close = stream_close;
|
||
-}
|
||
-
|
||
static gboolean
|
||
-emcs_gui_received(GIOChannel *source, GIOCondition cond, void *data)
|
||
+emss_process_message (struct _write_msg *msg)
|
||
{
|
||
- EMSyncStream *emss = data;
|
||
- struct _EMSyncStreamPrivate *p = emss->priv;
|
||
- struct _write_msg *msg;
|
||
-
|
||
- d(printf("%p: gui sync op job waiting\n", emss));
|
||
-
|
||
- msg = (struct _write_msg *)e_msgport_get(p->data_port);
|
||
- /* Should never happen ... */
|
||
- if (msg == NULL)
|
||
- return TRUE;
|
||
-
|
||
- d(printf("%p: running sync op %d\n", emss, msg->op));
|
||
-
|
||
- /* force out any pending data before doing anything else */
|
||
- if (p->buf_used > 0) {
|
||
- EMSS_CLASS(emss)->sync_write((CamelStream *)emss, p->buf_data, p->buf_used);
|
||
-#ifdef LOG_STREAM
|
||
- if (p->logfd)
|
||
- fwrite(p->buf_data, 1, p->buf_used, p->logfd);
|
||
-#endif
|
||
- p->buf_used = 0;
|
||
- }
|
||
+ struct _EMSyncStream *emss = msg->emss;
|
||
|
||
- /* FIXME: need to handle return values */
|
||
+ /* Force out any pending data before doing anything else. */
|
||
+ if (emss->buffer != NULL && emss->buffer->len > 0) {
|
||
+ EMSS_CLASS (emss)->sync_write (
|
||
+ CAMEL_STREAM (emss), emss->buffer->str,
|
||
+ emss->buffer->len);
|
||
+ g_string_set_size (emss->buffer, 0);
|
||
+ }
|
||
|
||
switch (msg->op) {
|
||
- case EMSS_WRITE:
|
||
- EMSS_CLASS(emss)->sync_write((CamelStream *)emss, msg->data, msg->n);
|
||
-#ifdef LOG_STREAM
|
||
- if (p->logfd)
|
||
- fwrite(msg->data, 1, msg->n, p->logfd);
|
||
-#endif
|
||
- break;
|
||
- case EMSS_FLUSH:
|
||
- EMSS_CLASS(emss)->sync_flush((CamelStream *)emss);
|
||
- break;
|
||
- case EMSS_CLOSE:
|
||
- EMSS_CLASS(emss)->sync_close((CamelStream *)emss);
|
||
-#ifdef LOG_STREAM
|
||
- if (p->logfd) {
|
||
- fclose(p->logfd);
|
||
- p->logfd = NULL;
|
||
- }
|
||
-#endif
|
||
- break;
|
||
+ case EMSS_WRITE:
|
||
+ EMSS_CLASS (emss)->sync_write (
|
||
+ CAMEL_STREAM (emss), msg->string, msg->len);
|
||
+ break;
|
||
+ case EMSS_FLUSH:
|
||
+ EMSS_CLASS (emss)->sync_flush (
|
||
+ CAMEL_STREAM (emss));
|
||
+ break;
|
||
+ case EMSS_CLOSE:
|
||
+ EMSS_CLASS (emss)->sync_close (
|
||
+ CAMEL_STREAM (emss));
|
||
+ break;
|
||
}
|
||
-
|
||
- e_msgport_reply((EMsg *)msg);
|
||
- d(printf("%p: gui sync op jobs done\n", emss));
|
||
-
|
||
- return TRUE;
|
||
-}
|
||
-
|
||
-static void
|
||
-em_sync_stream_init (CamelObject *object)
|
||
-{
|
||
- EMSyncStream *emss = (EMSyncStream *)object;
|
||
- struct _EMSyncStreamPrivate *p;
|
||
-
|
||
- p = emss->priv = g_malloc0(sizeof(*p));
|
||
|
||
- p->data_port = e_msgport_new();
|
||
- p->reply_port = e_msgport_new();
|
||
+ e_flag_set (msg->done);
|
||
|
||
-#ifndef G_OS_WIN32
|
||
- p->gui_channel = g_io_channel_unix_new(e_msgport_fd(p->data_port));
|
||
-#else
|
||
- p->gui_channel = g_io_channel_win32_new_socket(e_msgport_fd(p->data_port));
|
||
-#endif
|
||
- p->gui_watch = g_io_add_watch(p->gui_channel, G_IO_IN, emcs_gui_received, emss);
|
||
-
|
||
-#ifdef LOG_STREAM
|
||
- if (dolog) {
|
||
- char name[32];
|
||
- static int count;
|
||
-
|
||
- sprintf(name, "sync-stream.%d.html", count++);
|
||
- printf("Saving raw data stream to '%s'\n", name);
|
||
- p->logfd = fopen(name, "w");
|
||
- }
|
||
-#endif
|
||
-
|
||
- d(printf("%p: new emss\n", emss));
|
||
+ return FALSE;
|
||
}
|
||
|
||
static void
|
||
-sync_op(EMSyncStream *emss, enum _write_msg_t op, const char *data, size_t n)
|
||
+emss_sync_op (EMSyncStream *emss, enum _write_msg_t op,
|
||
+ const gchar *string, gsize len)
|
||
{
|
||
- struct _EMSyncStreamPrivate *p = emss->priv;
|
||
struct _write_msg msg;
|
||
- EMsg *reply_msg;
|
||
-
|
||
- d(printf("%p: launching sync op %d\n", emss, op));
|
||
|
||
- /* we do everything synchronous, we should never have any locks, and
|
||
- this prevents overflow from banked up data */
|
||
-
|
||
- msg.msg.reply_port = p->reply_port;
|
||
+ msg.done = e_flag_new ();
|
||
+ msg.emss = emss;
|
||
msg.op = op;
|
||
- msg.data = data;
|
||
- msg.n = n;
|
||
-
|
||
- e_msgport_put(p->data_port, &msg.msg);
|
||
- reply_msg = e_msgport_wait(p->reply_port);
|
||
- g_assert(reply_msg == &msg.msg);
|
||
-
|
||
- d(printf("%p: returned sync op %d\n", emss, op));
|
||
-}
|
||
-
|
||
-static void
|
||
-em_sync_stream_finalize (CamelObject *object)
|
||
-{
|
||
- EMSyncStream *emss = (EMSyncStream *)object;
|
||
- struct _EMSyncStreamPrivate *p = emss->priv;
|
||
-
|
||
- /* TODO: is this stuff safe to do in another thread? */
|
||
- g_source_remove(p->gui_watch);
|
||
- g_io_channel_unref(p->gui_channel);
|
||
+ msg.string = string;
|
||
+ msg.len = len;
|
||
|
||
- e_msgport_destroy(p->data_port);
|
||
- e_msgport_destroy(p->reply_port);
|
||
+ camel_object_ref (emss);
|
||
|
||
- p->data_port = NULL;
|
||
- p->reply_port = NULL;
|
||
+ g_idle_add ((GSourceFunc) emss_process_message, &msg);
|
||
|
||
- g_free(p->buf_data);
|
||
+ e_flag_wait (msg.done);
|
||
+ e_flag_free (msg.done);
|
||
|
||
-#ifdef LOG_STREAM
|
||
- if (p->logfd)
|
||
- fclose(p->logfd);
|
||
-#endif
|
||
-
|
||
- g_free(p);
|
||
+ camel_object_unref (emss);
|
||
}
|
||
|
||
-static ssize_t
|
||
-stream_write (CamelStream *stream, const char *buffer, size_t n)
|
||
+static gssize
|
||
+emss_stream_write (CamelStream *stream, const gchar *string, gsize len)
|
||
{
|
||
EMSyncStream *emss = EM_SYNC_STREAM (stream);
|
||
- struct _EMSyncStreamPrivate *p = emss->priv;
|
||
|
||
if (emss->cancel)
|
||
return -1;
|
||
|
||
- if (pthread_equal(pthread_self(), mail_gui_thread)) {
|
||
- EMSS_CLASS(emss)->sync_write(stream, buffer, n);
|
||
-#ifdef LOG_STREAM
|
||
- if (p->logfd)
|
||
- fwrite(buffer, 1, n, p->logfd);
|
||
-#endif
|
||
- } else if (p->buf_size > 0) {
|
||
- size_t left = p->buf_size-p->buf_used;
|
||
-
|
||
- if (n >= left) {
|
||
- sync_op(emss, EMSS_WRITE, buffer, n);
|
||
- } else {
|
||
- memcpy(p->buf_data + p->buf_used, buffer, n);
|
||
- p->buf_used += n;
|
||
- }
|
||
+ if (mail_in_main_thread ()) {
|
||
+ EMSS_CLASS (emss)->sync_write (stream, string, len);
|
||
+ } else if (emss->buffer != NULL) {
|
||
+ if (len < (emss->buffer->allocated_len - emss->buffer->len))
|
||
+ g_string_append_len (emss->buffer, string, len);
|
||
+ else
|
||
+ emss_sync_op (emss, EMSS_WRITE, string, len);
|
||
} else {
|
||
- sync_op(emss, EMSS_WRITE, buffer, n);
|
||
+ emss_sync_op(emss, EMSS_WRITE, string, len);
|
||
}
|
||
|
||
- return (ssize_t) n;
|
||
+ return (gssize) len;
|
||
}
|
||
|
||
static int
|
||
-stream_flush(CamelStream *stream)
|
||
+emss_stream_flush (CamelStream *stream)
|
||
{
|
||
- EMSyncStream *emss = (EMSyncStream *)stream;
|
||
+ EMSyncStream *emss = EM_SYNC_STREAM (stream);
|
||
|
||
if (emss->cancel)
|
||
return -1;
|
||
|
||
- if (pthread_equal(pthread_self(), mail_gui_thread))
|
||
- return ((EMSyncStreamClass *)(((CamelObject *)emss)->klass))->sync_flush(stream);
|
||
+ if (mail_in_main_thread ())
|
||
+ return EMSS_CLASS (emss)->sync_flush (stream);
|
||
else
|
||
- sync_op(emss, EMSS_FLUSH, NULL, 0);
|
||
+ emss_sync_op (emss, EMSS_FLUSH, NULL, 0);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int
|
||
-stream_close(CamelStream *stream)
|
||
+emss_stream_close (CamelStream *stream)
|
||
{
|
||
- EMSyncStream *emss = (EMSyncStream *)stream;
|
||
+ EMSyncStream *emss = EM_SYNC_STREAM (stream);
|
||
|
||
if (emss->cancel)
|
||
return -1;
|
||
|
||
- d(printf("%p: closing stream\n", stream));
|
||
-
|
||
- if (pthread_equal(pthread_self(), mail_gui_thread)) {
|
||
-#ifdef LOG_STREAM
|
||
- if (emss->priv->logfd) {
|
||
- fclose(emss->priv->logfd);
|
||
- emss->priv->logfd = NULL;
|
||
- }
|
||
-#endif
|
||
- return ((EMSyncStreamClass *)(((CamelObject *)emss)->klass))->sync_close(stream);
|
||
- } else
|
||
- sync_op(emss, EMSS_CLOSE, NULL, 0);
|
||
+ if (mail_in_main_thread ())
|
||
+ return EMSS_CLASS (emss)->sync_close (stream);
|
||
+ else
|
||
+ emss_sync_op (emss, EMSS_CLOSE, NULL, 0);
|
||
|
||
return 0;
|
||
}
|
||
|
||
-void
|
||
-em_sync_stream_set_buffer_size(EMSyncStream *emss, size_t size)
|
||
+static void
|
||
+em_sync_stream_class_init (EMSyncStreamClass *class)
|
||
+{
|
||
+ CamelStreamClass *stream_class = CAMEL_STREAM_CLASS (class);
|
||
+
|
||
+ parent_class = (CamelStreamClass *) CAMEL_STREAM_TYPE;
|
||
+
|
||
+ stream_class->write = emss_stream_write;
|
||
+ stream_class->flush = emss_stream_flush;
|
||
+ stream_class->close = emss_stream_close;
|
||
+}
|
||
+
|
||
+static void
|
||
+em_sync_stream_finalize (EMSyncStream *emss)
|
||
+{
|
||
+ if (emss->buffer != NULL)
|
||
+ g_string_free (emss->buffer, TRUE);
|
||
+}
|
||
+
|
||
+CamelType
|
||
+em_sync_stream_get_type (void)
|
||
{
|
||
- struct _EMSyncStreamPrivate *p = emss->priv;
|
||
+ static CamelType type = CAMEL_INVALID_TYPE;
|
||
+
|
||
+ if (G_UNLIKELY (type == CAMEL_INVALID_TYPE))
|
||
+ type = camel_type_register (
|
||
+ CAMEL_STREAM_TYPE,
|
||
+ "EMSyncStream",
|
||
+ sizeof (EMSyncStream),
|
||
+ sizeof (EMSyncStreamClass),
|
||
+ (CamelObjectClassInitFunc) em_sync_stream_class_init,
|
||
+ NULL,
|
||
+ (CamelObjectInitFunc) NULL,
|
||
+ (CamelObjectFinalizeFunc) em_sync_stream_finalize);
|
||
|
||
- g_free(p->buf_data);
|
||
- p->buf_data = g_malloc(size);
|
||
- p->buf_size = size;
|
||
- p->buf_used = 0;
|
||
+ return type;
|
||
+}
|
||
+
|
||
+void
|
||
+em_sync_stream_set_buffer_size (EMSyncStream *emss, gsize size)
|
||
+{
|
||
+ if (emss->buffer != NULL)
|
||
+ g_string_free (emss->buffer, TRUE);
|
||
+ emss->buffer = g_string_sized_new (size);
|
||
}
|
||
--- evolution-2.11.3/mail/em-subscribe-editor.c.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-subscribe-editor.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -175,7 +175,7 @@ sub_unref(EMSubscribe *sub)
|
||
/* ** Subscribe folder operation **************************************** */
|
||
|
||
struct _zsubscribe_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
EMSubscribe *sub;
|
||
EMSubscribeNode *node;
|
||
@@ -184,20 +184,18 @@ struct _zsubscribe_msg {
|
||
};
|
||
|
||
static void
|
||
-sub_folder_subscribe (struct _mail_msg *mm)
|
||
+sub_folder_exec (struct _zsubscribe_msg *m)
|
||
{
|
||
- struct _zsubscribe_msg *m = (struct _zsubscribe_msg *) mm;
|
||
-
|
||
if (m->subscribe)
|
||
- camel_store_subscribe_folder (m->sub->store, m->node->info->full_name, &mm->ex);
|
||
+ camel_store_subscribe_folder (m->sub->store, m->node->info->full_name, &m->base.ex);
|
||
else
|
||
- camel_store_unsubscribe_folder (m->sub->store, m->node->info->full_name, &mm->ex);
|
||
+ camel_store_unsubscribe_folder (m->sub->store, m->node->info->full_name, &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-sub_folder_subscribed (struct _mail_msg *mm)
|
||
+sub_folder_done (struct _zsubscribe_msg *m)
|
||
{
|
||
- struct _zsubscribe_msg *m = (struct _zsubscribe_msg *)mm, *next;
|
||
+ struct _zsubscribe_msg *next;
|
||
GtkTreeIter iter;
|
||
GtkTreeModel *model;
|
||
EMSubscribeNode *node;
|
||
@@ -207,7 +205,7 @@ sub_folder_subscribed (struct _mail_msg
|
||
if (m->sub->cancel)
|
||
return;
|
||
|
||
- if (!camel_exception_is_set(&mm->ex)) {
|
||
+ if (!camel_exception_is_set(&m->base.ex)) {
|
||
if (m->subscribe)
|
||
m->node->info->flags |= CAMEL_FOLDER_SUBSCRIBED;
|
||
else
|
||
@@ -228,8 +226,8 @@ sub_folder_subscribed (struct _mail_msg
|
||
/* queue any further ones, or if out, update the ui */
|
||
next = (struct _zsubscribe_msg *)e_dlist_remhead(&m->sub->subscribe);
|
||
if (next) {
|
||
- next->sub->subscribe_id = next->msg.seq;
|
||
- e_thread_put(mail_thread_new, (EMsg *)next);
|
||
+ next->sub->subscribe_id = next->base.seq;
|
||
+ mail_msg_unordered_push (next);
|
||
} else {
|
||
/* should it go off the model instead? */
|
||
sub_selection_changed(gtk_tree_view_get_selection(m->sub->tree), m->sub);
|
||
@@ -237,19 +235,18 @@ sub_folder_subscribed (struct _mail_msg
|
||
}
|
||
|
||
static void
|
||
-sub_folder_free (struct _mail_msg *mm)
|
||
+sub_folder_free (struct _zsubscribe_msg *m)
|
||
{
|
||
- struct _zsubscribe_msg *m = (struct _zsubscribe_msg *) mm;
|
||
-
|
||
g_free(m->path);
|
||
sub_unref(m->sub);
|
||
}
|
||
|
||
-static struct _mail_msg_op sub_subscribe_folder_op = {
|
||
- NULL, /*subscribe_folder_desc,*/
|
||
- sub_folder_subscribe,
|
||
- sub_folder_subscribed,
|
||
- sub_folder_free,
|
||
+static MailMsgInfo sub_subscribe_folder_info = {
|
||
+ sizeof (struct _zsubscribe_msg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) sub_folder_exec,
|
||
+ (MailMsgDoneFunc) sub_folder_done,
|
||
+ (MailMsgFreeFunc) sub_folder_free
|
||
};
|
||
|
||
/* spath is tree path in string form */
|
||
@@ -259,18 +256,18 @@ sub_subscribe_folder (EMSubscribe *sub,
|
||
struct _zsubscribe_msg *m;
|
||
int id;
|
||
|
||
- m = mail_msg_new (&sub_subscribe_folder_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new (&sub_subscribe_folder_info);
|
||
m->sub = sub;
|
||
sub_ref(sub);
|
||
m->node = node;
|
||
m->subscribe = state;
|
||
m->path = g_strdup(spath);
|
||
|
||
- id = m->msg.seq;
|
||
+ id = m->base.seq;
|
||
if (sub->subscribe_id == -1) {
|
||
sub->subscribe_id = id;
|
||
d(printf("running subscribe folder '%s'\n", spath));
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
} else {
|
||
d(printf("queueing subscribe folder '%s'\n", spath));
|
||
e_dlist_addtail(&sub->subscribe, (EDListNode *)m);
|
||
@@ -341,7 +338,7 @@ sub_fill_level(EMSubscribe *sub, CamelFo
|
||
/* async query of folderinfo */
|
||
|
||
struct _emse_folderinfo_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
int seq;
|
||
|
||
@@ -351,31 +348,29 @@ struct _emse_folderinfo_msg {
|
||
};
|
||
|
||
static void
|
||
-sub_folderinfo_get (struct _mail_msg *mm)
|
||
+sub_folderinfo_exec (struct _emse_folderinfo_msg *m)
|
||
{
|
||
- struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
|
||
char *pub_full_name=NULL;
|
||
|
||
if (m->seq == m->sub->seq) {
|
||
- camel_operation_register(mm->cancel);
|
||
- m->info = camel_store_get_folder_info(m->sub->store, m->node?m->node->info->full_name:pub_full_name, CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, &mm->ex);
|
||
- camel_operation_unregister(mm->cancel);
|
||
+ camel_operation_register(m->base.cancel);
|
||
+ m->info = camel_store_get_folder_info(m->sub->store, m->node?m->node->info->full_name:pub_full_name, CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, &m->base.ex);
|
||
+ camel_operation_unregister(m->base.cancel);
|
||
}
|
||
}
|
||
|
||
static void
|
||
-sub_folderinfo_got(struct _mail_msg *mm)
|
||
+sub_folderinfo_done (struct _emse_folderinfo_msg *m)
|
||
{
|
||
- struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
|
||
EMSubscribeNode *node;
|
||
|
||
m->sub->pending_id = -1;
|
||
if (m->sub->cancel || m->seq != m->sub->seq)
|
||
return;
|
||
|
||
- if (camel_exception_is_set (&mm->ex)) {
|
||
+ if (camel_exception_is_set (&m->base.ex)) {
|
||
g_warning ("Error getting folder info from store: %s",
|
||
- camel_exception_get_description (&mm->ex));
|
||
+ camel_exception_get_description (&m->base.ex));
|
||
}
|
||
|
||
if (m->info) {
|
||
@@ -396,10 +391,8 @@ sub_folderinfo_got(struct _mail_msg *mm)
|
||
}
|
||
|
||
static void
|
||
-sub_folderinfo_free(struct _mail_msg *mm)
|
||
+sub_folderinfo_free (struct _emse_folderinfo_msg *m)
|
||
{
|
||
- struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
|
||
-
|
||
if (m->info)
|
||
m->sub->info_list = g_slist_prepend(m->sub->info_list, m->info);
|
||
|
||
@@ -415,11 +408,12 @@ sub_folderinfo_free(struct _mail_msg *mm
|
||
sub_unref(m->sub);
|
||
}
|
||
|
||
-static struct _mail_msg_op sub_folderinfo_op = {
|
||
- NULL, /*sub_folderinfo_desc, we do our own progress reporting/cancellation */
|
||
- sub_folderinfo_get,
|
||
- sub_folderinfo_got,
|
||
- sub_folderinfo_free,
|
||
+static MailMsgInfo sub_folderinfo_info = {
|
||
+ sizeof (struct _emse_folderinfo_msg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) sub_folderinfo_exec,
|
||
+ (MailMsgDoneFunc) sub_folderinfo_done,
|
||
+ (MailMsgFreeFunc) sub_folderinfo_free
|
||
};
|
||
|
||
static int
|
||
@@ -431,19 +425,19 @@ sub_queue_fill_level(EMSubscribe *sub, E
|
||
d(printf("%s:%d:%s: Starting get folderinfo of '%s'\n", __FILE__, __LINE__, __GNUC_PRETTY_FUNCTION__,
|
||
node?node->info->full_name:"<root>"));
|
||
|
||
- m = mail_msg_new (&sub_folderinfo_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new (&sub_folderinfo_info);
|
||
sub_ref(sub);
|
||
m->sub = sub;
|
||
m->node = node;
|
||
m->seq = sub->seq;
|
||
|
||
- sub->pending_id = m->msg.seq;
|
||
+ sub->pending_id = m->base.seq;
|
||
|
||
sub_editor_busy(sub->editor, 1);
|
||
|
||
- id = m->msg.seq;
|
||
+ id = m->base.seq;
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *)m);
|
||
+ mail_msg_unordered_push (m);
|
||
return id;
|
||
}
|
||
|
||
@@ -573,7 +567,7 @@ sub_destroy(GtkWidget *w, EMSubscribe *s
|
||
mail_msg_cancel(sub->subscribe_id);
|
||
|
||
while ( (m = (struct _zsubscribe_msg *)e_dlist_remhead(&sub->subscribe)) )
|
||
- mail_msg_free(m);
|
||
+ mail_msg_unref(m);
|
||
|
||
sub_unref(sub);
|
||
}
|
||
--- evolution-2.11.3/mail/mail-mt.h.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-mt.h 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -23,47 +23,64 @@
|
||
#ifndef _MAIL_MT
|
||
#define _MAIL_MT
|
||
|
||
-#include <pthread.h>
|
||
#include "camel/camel-exception.h"
|
||
-#include "libedataserver/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 */
|
||
+typedef struct _MailMsg MailMsg;
|
||
+typedef struct _MailMsgInfo MailMsgInfo;
|
||
+typedef struct _MailMsgPrivate MailMsgPrivate;
|
||
+
|
||
+typedef gchar * (*MailMsgDescFunc) (MailMsg *msg);
|
||
+typedef void (*MailMsgExecFunc) (MailMsg *msg);
|
||
+typedef void (*MailMsgDoneFunc) (MailMsg *msg);
|
||
+typedef void (*MailMsgFreeFunc) (MailMsg *msg);
|
||
+typedef void (*MailMsgDispatchFunc) (gpointer msg);
|
||
+
|
||
+struct _MailMsg {
|
||
+ MailMsgInfo *info;
|
||
+ volatile gint ref_count;
|
||
unsigned int seq; /* seq number for synchronisation */
|
||
+ gint priority; /* priority (default = 0) */
|
||
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;
|
||
+ MailMsgPrivate *priv;
|
||
+};
|
||
|
||
-/* 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;
|
||
+struct _MailMsgInfo {
|
||
+ gsize size;
|
||
+ MailMsgDescFunc desc;
|
||
+ MailMsgExecFunc exec;
|
||
+ MailMsgDoneFunc done;
|
||
+ MailMsgFreeFunc free;
|
||
+};
|
||
|
||
/* setup ports */
|
||
void mail_msg_init(void);
|
||
void mail_msg_cleanup (void);
|
||
|
||
+gboolean mail_in_main_thread (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);
|
||
+gpointer mail_msg_new (MailMsgInfo *info);
|
||
+gpointer mail_msg_ref (gpointer msg);
|
||
+void mail_msg_unref (gpointer msg);
|
||
+void mail_msg_check_error (gpointer 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);
|
||
|
||
+/* dispatch a message */
|
||
+void mail_msg_main_loop_push (gpointer msg);
|
||
+void mail_msg_unordered_push (gpointer msg);
|
||
+void mail_msg_fast_ordered_push (gpointer msg);
|
||
+void mail_msg_slow_ordered_push (gpointer msg);
|
||
+
|
||
/* To implement the stop button */
|
||
-void *mail_cancel_hook_add(GDestroyNotify func, void *data);
|
||
-void mail_cancel_hook_remove(void *handle);
|
||
-void mail_cancel_all(void);
|
||
+GHook * mail_cancel_hook_add (GHookFunc func, gpointer data);
|
||
+void mail_cancel_hook_remove (GHook *hook);
|
||
+void mail_cancel_all (void);
|
||
|
||
/* request a string/password */
|
||
char *mail_get_password (CamelService *service, const char *prompt,
|
||
@@ -112,24 +129,6 @@ void *mail_call_main(mail_call_t type, M
|
||
void mail_enable_stop(void);
|
||
void mail_disable_stop(void);
|
||
|
||
-/* 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 */
|
||
-#ifndef G_OS_WIN32
|
||
-extern EThread *mail_thread_queued; /* for operations that can (or should) be queued */
|
||
-#else
|
||
-EThread *mail_win32_get_mail_thread_queued (void);
|
||
-#define mail_thread_queued mail_win32_get_mail_thread_queued ()
|
||
-#endif
|
||
-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;
|
||
--- evolution-2.11.3/mail/mail-ops.h.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-ops.h 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -30,13 +30,14 @@ extern "C" {
|
||
#pragma }
|
||
#endif /* __cplusplus */
|
||
|
||
+#include "mail-mt.h"
|
||
+
|
||
#include "camel/camel-store.h"
|
||
#include "camel/camel-folder.h"
|
||
#include "camel/camel-filter-driver.h"
|
||
#include "camel/camel-mime-message.h"
|
||
#include "camel/camel-operation.h"
|
||
|
||
-#include "libedataserver/e-msgport.h"
|
||
#include "libedataserver/e-account.h"
|
||
|
||
void mail_append_mail (CamelFolder *folder, CamelMimeMessage *message, CamelMessageInfo *info,
|
||
@@ -55,12 +56,12 @@ void mail_transfer_messages (CamelFolder
|
||
void mail_get_message (CamelFolder *folder, const char *uid,
|
||
void (*done) (CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data),
|
||
void *data,
|
||
- EThread *thread);
|
||
+ MailMsgDispatchFunc dispatch);
|
||
|
||
void
|
||
mail_get_messagex(CamelFolder *folder, const char *uid,
|
||
void (*done) (CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data, CamelException *),
|
||
- void *data, EThread *thread);
|
||
+ void *data, MailMsgDispatchFunc dispatch);
|
||
|
||
/* get several messages */
|
||
void mail_get_messages (CamelFolder *folder, GPtrArray *uids,
|
||
@@ -70,7 +71,7 @@ void mail_get_messages (CamelFolder *fol
|
||
/* same for a folder */
|
||
int mail_get_folder (const char *uri, guint32 flags,
|
||
void (*done) (char *uri, CamelFolder *folder, void *data), void *data,
|
||
- EThread *thread);
|
||
+ MailMsgDispatchFunc dispatch);
|
||
|
||
/* and for a store */
|
||
int mail_get_store (const char *uri, CamelOperation *op,
|
||
--- evolution-2.11.3/mail/em-composer-utils.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-composer-utils.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -534,7 +534,7 @@ em_utils_composer_save_draft_cb (EMsgCom
|
||
strcmp (account->drafts_folder_uri, default_drafts_folder_uri) != 0) {
|
||
int id;
|
||
|
||
- id = mail_get_folder (account->drafts_folder_uri, 0, save_draft_folder, &folder, mail_thread_new);
|
||
+ id = mail_get_folder (account->drafts_folder_uri, 0, save_draft_folder, &folder, mail_msg_unordered_push);
|
||
mail_msg_wait (id);
|
||
|
||
if (!folder || !account->enabled) {
|
||
@@ -1085,7 +1085,7 @@ em_utils_redirect_message_by_uid (CamelF
|
||
g_return_if_fail (CAMEL_IS_FOLDER (folder));
|
||
g_return_if_fail (uid != NULL);
|
||
|
||
- mail_get_message (folder, uid, redirect_msg, NULL, mail_thread_new);
|
||
+ mail_get_message (folder, uid, redirect_msg, NULL, mail_msg_unordered_push);
|
||
}
|
||
|
||
static void
|
||
@@ -1116,7 +1116,7 @@ em_utils_handle_receipt (CamelFolder *fo
|
||
}
|
||
|
||
if (msg == NULL) {
|
||
- mail_get_messagex(folder, uid, emu_handle_receipt_message, NULL, mail_thread_new);
|
||
+ mail_get_messagex(folder, uid, emu_handle_receipt_message, NULL, mail_msg_unordered_push);
|
||
camel_message_info_free(info);
|
||
return;
|
||
}
|
||
@@ -1922,7 +1922,7 @@ em_utils_reply_to_message(CamelFolder *f
|
||
rd->source = source;
|
||
if (rd->source)
|
||
g_object_ref(rd->source);
|
||
- mail_get_message(folder, uid, reply_to_message, rd, mail_thread_new);
|
||
+ mail_get_message(folder, uid, reply_to_message, rd, mail_msg_unordered_push);
|
||
|
||
return;
|
||
}
|
||
@@ -2094,5 +2094,5 @@ em_utils_post_reply_to_message_by_uid (C
|
||
g_return_if_fail (CAMEL_IS_FOLDER (folder));
|
||
g_return_if_fail (uid != NULL);
|
||
|
||
- mail_get_message (folder, uid, post_reply_to_message, NULL, mail_thread_new);
|
||
+ mail_get_message (folder, uid, post_reply_to_message, NULL, mail_msg_unordered_push);
|
||
}
|
||
--- evolution-2.11.3/mail/mail-folder-cache.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-folder-cache.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -860,15 +860,14 @@ update_folders(CamelStore *store, CamelF
|
||
|
||
|
||
struct _ping_store_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelStore *store;
|
||
};
|
||
|
||
-static char *
|
||
-ping_store_desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+ping_store_desc (struct _ping_store_msg *m)
|
||
{
|
||
- struct _ping_store_msg *m = (struct _ping_store_msg *) mm;
|
||
char *service_name = camel_service_get_name (CAMEL_SERVICE (m->store), TRUE);
|
||
char *msg;
|
||
|
||
@@ -879,10 +878,9 @@ ping_store_desc (struct _mail_msg *mm, i
|
||
}
|
||
|
||
static void
|
||
-ping_store_ping (struct _mail_msg *mm)
|
||
+ping_store_exec (struct _ping_store_msg *m)
|
||
{
|
||
gboolean online = FALSE;
|
||
- struct _ping_store_msg *m = (struct _ping_store_msg *) mm;
|
||
|
||
if (CAMEL_SERVICE (m->store)->status == CAMEL_SERVICE_CONNECTED) {
|
||
if (CAMEL_IS_DISCO_STORE (m->store) &&
|
||
@@ -893,22 +891,21 @@ ping_store_ping (struct _mail_msg *mm)
|
||
online = TRUE;
|
||
}
|
||
if (online)
|
||
- camel_store_noop (m->store, &mm->ex);
|
||
+ camel_store_noop (m->store, &m->base.ex);
|
||
}
|
||
|
||
static void
|
||
-ping_store_free (struct _mail_msg *mm)
|
||
+ping_store_free (struct _ping_store_msg *m)
|
||
{
|
||
- struct _ping_store_msg *m = (struct _ping_store_msg *) mm;
|
||
-
|
||
camel_object_unref (m->store);
|
||
}
|
||
|
||
-static struct _mail_msg_op ping_store_op = {
|
||
- ping_store_desc,
|
||
- ping_store_ping,
|
||
- NULL,
|
||
- ping_store_free
|
||
+static MailMsgInfo ping_store_info = {
|
||
+ sizeof (struct _ping_store_msg),
|
||
+ (MailMsgDescFunc) ping_store_desc,
|
||
+ (MailMsgExecFunc) ping_store_exec,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) ping_store_free
|
||
};
|
||
|
||
static void
|
||
@@ -920,11 +917,11 @@ ping_store (gpointer key, gpointer val,
|
||
if (CAMEL_SERVICE (store)->status != CAMEL_SERVICE_CONNECTED)
|
||
return;
|
||
|
||
- m = mail_msg_new (&ping_store_op, NULL, sizeof (struct _ping_store_msg));
|
||
+ m = mail_msg_new (&ping_store_info);
|
||
m->store = store;
|
||
camel_object_ref (store);
|
||
|
||
- e_thread_put (mail_thread_queued_slow, (EMsg *) m);
|
||
+ mail_msg_slow_ordered_push (m);
|
||
}
|
||
|
||
static gboolean
|
||
@@ -969,7 +966,7 @@ mail_note_store(CamelStore *store, Camel
|
||
int hook = 0;
|
||
|
||
g_assert(CAMEL_IS_STORE(store));
|
||
- g_assert(pthread_equal(pthread_self(), mail_gui_thread));
|
||
+ g_assert(mail_in_main_thread());
|
||
|
||
LOCK(info_lock);
|
||
|
||
--- evolution-2.11.3/mail/em-folder-view.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/em-folder-view.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -71,6 +71,7 @@
|
||
#include <gtkhtml/gtkhtml-stream.h>
|
||
|
||
#include <libedataserver/e-data-server-util.h>
|
||
+#include <libedataserver/e-msgport.h>
|
||
|
||
#include "menus/gal-view-etable.h"
|
||
#include "menus/gal-view-factory-etable.h"
|
||
@@ -695,7 +696,7 @@ emfv_got_folder(char *uri, CamelFolder *
|
||
static void
|
||
emfv_set_folder_uri(EMFolderView *emfv, const char *uri)
|
||
{
|
||
- mail_get_folder(uri, 0, emfv_got_folder, emfv, mail_thread_queued);
|
||
+ mail_get_folder(uri, 0, emfv_got_folder, emfv, mail_msg_fast_ordered_push);
|
||
}
|
||
|
||
static void
|
||
@@ -1632,7 +1633,7 @@ filter_type_uid (CamelFolder *folder, co
|
||
data->type = type;
|
||
data->source = source;
|
||
|
||
- mail_get_message (folder, uid, filter_type_got_message, data, mail_thread_new);
|
||
+ mail_get_message (folder, uid, filter_type_got_message, data, mail_msg_unordered_push);
|
||
}
|
||
|
||
static void
|
||
@@ -1730,7 +1731,7 @@ vfolder_type_uid (CamelFolder *folder, c
|
||
data->type = type;
|
||
data->uri = g_strdup (uri);
|
||
|
||
- mail_get_message (folder, uid, vfolder_type_got_message, data, mail_thread_new);
|
||
+ mail_get_message (folder, uid, vfolder_type_got_message, data, mail_msg_unordered_push);
|
||
}
|
||
|
||
static void
|
||
@@ -2373,7 +2374,7 @@ emfv_message_selected_timeout(void *data
|
||
emfv->displayed_uid);
|
||
gtk_html_stream_close(hstream, GTK_HTML_STREAM_OK);
|
||
*/
|
||
- mail_get_messagex(emfv->folder, emfv->displayed_uid, emfv_list_done_message_selected, emfv, mail_thread_queued);
|
||
+ mail_get_messagex(emfv->folder, emfv->displayed_uid, emfv_list_done_message_selected, emfv, mail_msg_fast_ordered_push);
|
||
} else {
|
||
e_profile_event_emit("goto.empty", "", 0);
|
||
g_free(emfv->priv->selected_uid);
|
||
--- evolution-2.11.3/mail/mail-session.c.kill-ethread 2007-06-03 11:08:08.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-session.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -35,7 +35,7 @@
|
||
#include <libgnome/gnome-sound.h>
|
||
|
||
#include <libedataserverui/e-passwords.h>
|
||
-#include <libedataserver/e-msgport.h>
|
||
+#include <libedataserver/e-flag.h>
|
||
|
||
#include <camel/camel.h> /* FIXME: this is where camel_init is defined, it shouldn't include everything else */
|
||
#include <camel/camel-filter-driver.h>
|
||
@@ -258,21 +258,22 @@ forget_password (CamelSession *session,
|
||
|
||
/* ********************************************************************** */
|
||
|
||
-static GtkDialog *message_dialog;
|
||
-static EDList message_list = E_DLIST_INITIALISER(message_list);
|
||
+static gpointer user_message_dialog;
|
||
+static GQueue user_message_queue = { NULL, NULL, 0 };
|
||
|
||
struct _user_message_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
CamelSessionAlertType type;
|
||
char *prompt;
|
||
+ EFlag *done;
|
||
|
||
unsigned int allow_cancel:1;
|
||
unsigned int result:1;
|
||
unsigned int ismain:1;
|
||
};
|
||
|
||
-static void do_user_message (struct _mail_msg *mm);
|
||
+static void user_message_exec (struct _user_message_msg *m);
|
||
|
||
/* clicked, send back the reply */
|
||
static void
|
||
@@ -280,122 +281,116 @@ user_message_response (GtkDialog *dialog
|
||
{
|
||
gtk_widget_destroy ((GtkWidget *) dialog);
|
||
|
||
- message_dialog = NULL;
|
||
+ user_message_dialog = NULL;
|
||
|
||
/* if !allow_cancel, then we've already replied */
|
||
if (m->allow_cancel) {
|
||
m->result = button == GTK_RESPONSE_OK;
|
||
- e_msgport_reply((EMsg *)m);
|
||
+ e_flag_set (m->done);
|
||
}
|
||
|
||
/* check for pendings */
|
||
- if ((m = (struct _user_message_msg *)e_dlist_remhead(&message_list)))
|
||
- do_user_message((struct _mail_msg *)m);
|
||
-}
|
||
-
|
||
-static void
|
||
-user_message_destroy_notify (struct _user_message_msg *m, GObject *deadbeef)
|
||
-{
|
||
- message_dialog = NULL;
|
||
+ if (!g_queue_is_empty (&user_message_queue)) {
|
||
+ m = g_queue_pop_head (&user_message_queue);
|
||
+ user_message_exec (m);
|
||
+ mail_msg_unref (m);
|
||
+ }
|
||
}
|
||
|
||
-/* This is kinda ugly/inefficient, but oh well, it works */
|
||
-static const char *error_type[] = {
|
||
- "mail:session-message-info", "mail:session-message-warning", "mail:session-message-error",
|
||
- "mail:session-message-info-cancel", "mail:session-message-warning-cancel", "mail:session-message-error-cancel"
|
||
-};
|
||
-
|
||
static void
|
||
-do_user_message (struct _mail_msg *mm)
|
||
+user_message_exec (struct _user_message_msg *m)
|
||
{
|
||
- struct _user_message_msg *m = (struct _user_message_msg *)mm;
|
||
- int type;
|
||
+ const gchar *error_type;
|
||
|
||
- if (!m->ismain && message_dialog != NULL) {
|
||
- e_dlist_addtail (&message_list, (EDListNode *)m);
|
||
+ if (!m->ismain && user_message_dialog != NULL) {
|
||
+ g_queue_push_tail (&user_message_queue, mail_msg_ref (m));
|
||
return;
|
||
}
|
||
|
||
switch (m->type) {
|
||
- case CAMEL_SESSION_ALERT_INFO:
|
||
- type = 0;
|
||
- break;
|
||
- case CAMEL_SESSION_ALERT_WARNING:
|
||
- type = 1;
|
||
- break;
|
||
- case CAMEL_SESSION_ALERT_ERROR:
|
||
- type = 2;
|
||
- break;
|
||
- default:
|
||
- type = 0;
|
||
+ case CAMEL_SESSION_ALERT_INFO:
|
||
+ error_type = m->allow_cancel ?
|
||
+ "mail:session-message-info-cancel" :
|
||
+ "mail:session-message-info";
|
||
+ break;
|
||
+ case CAMEL_SESSION_ALERT_WARNING:
|
||
+ error_type = m->allow_cancel ?
|
||
+ "mail:session-message-warning-cancel" :
|
||
+ "mail:session-message-warning";
|
||
+ break;
|
||
+ case CAMEL_SESSION_ALERT_ERROR:
|
||
+ error_type = m->allow_cancel ?
|
||
+ "mail:session-message-error-cancel" :
|
||
+ "mail:session-message-error";
|
||
+ break;
|
||
+ default:
|
||
+ g_assert_not_reached ();
|
||
}
|
||
|
||
- if (m->allow_cancel)
|
||
- type += 3;
|
||
-
|
||
- message_dialog = (GtkDialog *)e_error_new(NULL, error_type[type], m->prompt, NULL);
|
||
- g_object_set ((GObject *) message_dialog, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
|
||
+ user_message_dialog = e_error_new(NULL, error_type, m->prompt, NULL);
|
||
+ g_object_set (user_message_dialog, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
|
||
|
||
/* We only need to wait for the result if we allow cancel otherwise show but send result back instantly */
|
||
if (m->allow_cancel) {
|
||
if (m->ismain) {
|
||
- user_message_response(message_dialog, gtk_dialog_run (message_dialog), m);
|
||
+ user_message_response(user_message_dialog, gtk_dialog_run (user_message_dialog), m);
|
||
} else {
|
||
- g_signal_connect (message_dialog, "response", G_CALLBACK (user_message_response), m);
|
||
- gtk_widget_show ((GtkWidget *) message_dialog);
|
||
+ g_signal_connect (user_message_dialog, "response", G_CALLBACK (user_message_response), m);
|
||
+ gtk_widget_show (user_message_dialog);
|
||
}
|
||
} else {
|
||
- g_signal_connect (message_dialog, "response", G_CALLBACK (gtk_widget_destroy), message_dialog);
|
||
- g_object_weak_ref ((GObject *) message_dialog, (GWeakNotify) user_message_destroy_notify, m);
|
||
- gtk_widget_show ((GtkWidget *) message_dialog);
|
||
- mail_msg_free(m);
|
||
+ g_signal_connect (user_message_dialog, "response", G_CALLBACK (gtk_widget_destroy), user_message_dialog);
|
||
+ g_object_add_weak_pointer (user_message_dialog, &user_message_dialog);
|
||
+ gtk_widget_show (user_message_dialog);
|
||
+ mail_msg_unref(m);
|
||
}
|
||
}
|
||
|
||
static void
|
||
-free_user_message(struct _mail_msg *mm)
|
||
+user_message_free (struct _user_message_msg *m)
|
||
{
|
||
- struct _user_message_msg *m = (struct _user_message_msg *)mm;
|
||
-
|
||
g_free(m->prompt);
|
||
+ e_flag_free(m->done);
|
||
}
|
||
|
||
-static struct _mail_msg_op user_message_op = { NULL, do_user_message, NULL, free_user_message };
|
||
+static MailMsgInfo user_message_info = {
|
||
+ sizeof (struct _user_message_msg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) user_message_exec,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) user_message_free
|
||
+};
|
||
|
||
static gboolean
|
||
alert_user(CamelSession *session, CamelSessionAlertType type, const char *prompt, gboolean cancel)
|
||
{
|
||
MailSession *mail_session = MAIL_SESSION (session);
|
||
- struct _user_message_msg *m, *r;
|
||
- EMsgPort *user_message_reply = NULL;
|
||
+ struct _user_message_msg *m;
|
||
gboolean ret;
|
||
|
||
if (!mail_session->interactive)
|
||
return FALSE;
|
||
|
||
- if (cancel)
|
||
- user_message_reply = e_msgport_new ();
|
||
- m = mail_msg_new (&user_message_op, user_message_reply, sizeof (*m));
|
||
- m->ismain = pthread_equal(pthread_self(), mail_gui_thread);
|
||
+ m = mail_msg_new (&user_message_info);
|
||
+ m->ismain = mail_in_main_thread();
|
||
m->type = type;
|
||
m->prompt = g_strdup(prompt);
|
||
+ m->done = e_flag_new ();
|
||
m->allow_cancel = cancel;
|
||
|
||
+ if (cancel)
|
||
+ mail_msg_ref (m);
|
||
+
|
||
if (m->ismain)
|
||
- do_user_message((struct _mail_msg *)m);
|
||
+ user_message_exec(m);
|
||
else {
|
||
- extern EMsgPort *mail_gui_port2;
|
||
-
|
||
- e_msgport_put(mail_gui_port2, (EMsg *)m);
|
||
+ mail_msg_main_loop_push(m);
|
||
}
|
||
|
||
if (cancel) {
|
||
- r = (struct _user_message_msg *)e_msgport_wait(user_message_reply);
|
||
- g_assert(m == r);
|
||
-
|
||
+ e_flag_wait (m->done);
|
||
ret = m->result;
|
||
- mail_msg_free(m);
|
||
- e_msgport_destroy(user_message_reply);
|
||
+ mail_msg_unref(m);
|
||
} else
|
||
ret = TRUE;
|
||
|
||
@@ -535,7 +530,7 @@ get_filter_driver (CamelSession *session
|
||
/* TODO: This is very temporary, until we have a better way to do the progress reporting,
|
||
we just borrow a dummy mail-mt thread message and hook it onto out camel thread message */
|
||
|
||
-static mail_msg_op_t ms_thread_ops_dummy = { NULL };
|
||
+static MailMsgInfo ms_thread_info_dummy = { sizeof (MailMsg) };
|
||
|
||
static void *ms_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size)
|
||
{
|
||
@@ -544,7 +539,7 @@ static void *ms_thread_msg_new(CamelSess
|
||
/* We create a dummy mail_msg, and then copy its cancellation port over to ours, so
|
||
we get cancellation and progress in common with hte existing mail code, for free */
|
||
if (msg) {
|
||
- struct _mail_msg *m = mail_msg_new(&ms_thread_ops_dummy, NULL, sizeof(struct _mail_msg));
|
||
+ MailMsg *m = mail_msg_new(&ms_thread_info_dummy);
|
||
|
||
msg->data = m;
|
||
camel_operation_unref(msg->op);
|
||
@@ -557,7 +552,7 @@ static void *ms_thread_msg_new(CamelSess
|
||
|
||
static void ms_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *m)
|
||
{
|
||
- mail_msg_free(m->data);
|
||
+ mail_msg_unref(m->data);
|
||
ms_parent_class->thread_msg_free(session, m);
|
||
}
|
||
|
||
@@ -680,22 +675,23 @@ mail_session_set_interactive (gboolean i
|
||
MAIL_SESSION (session)->interactive = interactive;
|
||
|
||
if (!interactive) {
|
||
- struct _user_message_msg *um;
|
||
+ struct _user_message_msg *msg;
|
||
|
||
d(printf ("Gone non-interactive, checking for outstanding interactive tasks\n"));
|
||
|
||
e_passwords_cancel();
|
||
|
||
/* flush/cancel pending user messages */
|
||
- while ((um = (struct _user_message_msg *) e_dlist_remhead (&message_list))) {
|
||
- d(printf ("Flusing message request: %s\n", um->prompt));
|
||
- e_msgport_reply((EMsg *) um);
|
||
+ while (!g_queue_is_empty (&user_message_queue)) {
|
||
+ msg = g_queue_pop_head (&user_message_queue);
|
||
+ e_flag_set (msg->done);
|
||
+ mail_msg_unref (msg);
|
||
}
|
||
|
||
/* and the current */
|
||
- if (message_dialog) {
|
||
+ if (user_message_dialog) {
|
||
d(printf("Destroying message dialogue\n"));
|
||
- gtk_widget_destroy ((GtkWidget *) message_dialog);
|
||
+ gtk_widget_destroy ((GtkWidget *) user_message_dialog);
|
||
}
|
||
}
|
||
}
|
||
--- evolution-2.11.3/mail/mail-mt.c.kill-ethread 2007-04-18 06:17:32.000000000 -0400
|
||
+++ evolution-2.11.3/mail/mail-mt.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -29,8 +29,8 @@
|
||
#include <gtk/gtk.h>
|
||
#include <glib/gi18n.h>
|
||
|
||
-#include <libedataserver/e-msgport.h>
|
||
#include <libedataserver/e-data-server-util.h>
|
||
+#include <libedataserver/e-flag.h>
|
||
|
||
#include <camel/camel-url.h>
|
||
#include <camel/camel-operation.h>
|
||
@@ -63,7 +63,7 @@ static void mail_operation_status(struct
|
||
#endif
|
||
|
||
/* background operation status stuff */
|
||
-struct _mail_msg_priv {
|
||
+struct _MailMsgPrivate {
|
||
int activity_state; /* sigh sigh sigh, we need to keep track of the state external to the
|
||
pointer itself for locking/race conditions */
|
||
int activity_id;
|
||
@@ -82,15 +82,12 @@ static GHashTable *mail_msg_active_table
|
||
static pthread_mutex_t mail_msg_lock = PTHREAD_MUTEX_INITIALIZER;
|
||
static pthread_cond_t mail_msg_cond = PTHREAD_COND_INITIALIZER;
|
||
|
||
-pthread_t mail_gui_thread;
|
||
-
|
||
MailAsyncEvent *mail_async_event;
|
||
|
||
-static void mail_msg_destroy(EThread *e, EMsg *msg, void *data);
|
||
-
|
||
-void *mail_msg_new(mail_msg_op_t *ops, EMsgPort *reply_port, size_t size)
|
||
+gpointer
|
||
+mail_msg_new (MailMsgInfo *info)
|
||
{
|
||
- struct _mail_msg *msg;
|
||
+ MailMsg *msg;
|
||
|
||
MAIL_MT_LOCK(mail_msg_lock);
|
||
|
||
@@ -112,7 +109,6 @@ void *mail_msg_new(mail_msg_op_t *ops, E
|
||
fprintf(log, "Logging async operations\n");
|
||
|
||
if (log_locks) {
|
||
- fprintf(log, "Logging lock operations, mail_gui_thread = %" G_GINT64_MODIFIER "x\n\n", e_util_pthread_id(mail_gui_thread));
|
||
fprintf(log, "%" G_GINT64_MODIFIER "x: lock mail_msg_lock\n", e_util_pthread_id(pthread_self()));
|
||
}
|
||
} else {
|
||
@@ -122,14 +118,14 @@ void *mail_msg_new(mail_msg_op_t *ops, E
|
||
}
|
||
}
|
||
#endif
|
||
- msg = g_malloc0(size);
|
||
- msg->ops = ops;
|
||
+ msg = g_slice_alloc0 (info->size);
|
||
+ msg->info = info;
|
||
+ msg->ref_count = 1;
|
||
msg->seq = mail_msg_seq++;
|
||
- msg->msg.reply_port = reply_port;
|
||
msg->cancel = camel_operation_new(mail_operation_status, GINT_TO_POINTER(msg->seq));
|
||
camel_exception_init(&msg->ex);
|
||
- msg->priv = g_malloc0(sizeof(*msg->priv));
|
||
+ msg->priv = g_slice_new (MailMsgPrivate);
|
||
|
||
g_hash_table_insert(mail_msg_active_table, GINT_TO_POINTER(msg->seq), msg);
|
||
|
||
d(printf("New message %p\n", msg));
|
||
@@ -143,12 +140,15 @@ void *mail_msg_new(mail_msg_op_t *ops, E
|
||
return msg;
|
||
}
|
||
|
||
-
|
||
-static void end_event_callback (CamelObject *o, void *event_data, void *data)
|
||
+static void
|
||
+end_event_callback (CamelObject *o, void *event_data, void *data)
|
||
{
|
||
- EActivityHandler *activity_handler = mail_component_peek_activity_handler (mail_component_peek ());
|
||
+ MailComponent *component;
|
||
+ EActivityHandler *activity_handler;
|
||
guint activity_id = GPOINTER_TO_INT (event_data);
|
||
|
||
+ component = mail_component_peek ();
|
||
+ activity_handler = mail_component_peek_activity_handler (component);
|
||
e_activity_handler_operation_finished (activity_handler, activity_id);
|
||
}
|
||
|
||
@@ -177,58 +177,84 @@ checkmem(void *p)
|
||
}
|
||
#endif
|
||
|
||
-void mail_msg_free(void *msg)
|
||
+gpointer
|
||
+mail_msg_ref (gpointer msg)
|
||
{
|
||
- struct _mail_msg *m = msg;
|
||
- int activity_id;
|
||
+ MailMsg *mail_msg = msg;
|
||
+
|
||
+ g_return_val_if_fail (mail_msg != NULL, msg);
|
||
+ g_return_val_if_fail (mail_msg->ref_count > 0, msg);
|
||
+
|
||
+ g_atomic_int_add (&mail_msg->ref_count, 1);
|
||
+ return msg;
|
||
+}
|
||
+
|
||
+void
|
||
+mail_msg_unref (gpointer msg)
|
||
+{
|
||
+ MailMsg *mail_msg = msg;
|
||
+ gint activity_id;
|
||
+
|
||
+ g_return_if_fail (mail_msg != NULL);
|
||
+ g_return_if_fail (mail_msg->ref_count > 0);
|
||
+
|
||
+ if (g_atomic_int_exchange_and_add (&mail_msg->ref_count, -1) > 1)
|
||
+ return;
|
||
|
||
#ifdef MALLOC_CHECK
|
||
- checkmem(m);
|
||
- checkmem(m->cancel);
|
||
- checkmem(m->priv);
|
||
+ checkmem(mail_msg);
|
||
+ checkmem(mail_msg->cancel);
|
||
+ checkmem(mail_msg->priv);
|
||
#endif
|
||
d(printf("Free message %p\n", msg));
|
||
|
||
- if (m->ops->destroy_msg)
|
||
- m->ops->destroy_msg(m);
|
||
+ if (mail_msg->info->free)
|
||
+ mail_msg->info->free(mail_msg);
|
||
|
||
MAIL_MT_LOCK(mail_msg_lock);
|
||
|
||
#ifdef LOG_OPS
|
||
- if (log_ops)
|
||
- fprintf(log, "%p: Free (exception `%s')\n", msg,
|
||
- camel_exception_get_description(&m->ex)?camel_exception_get_description(&m->ex):"None");
|
||
+ if (log_ops) {
|
||
+ const gchar *description;
|
||
+
|
||
+ description = camel_exception_get_description (&mail_msg->ex);
|
||
+ if (description == NULL)
|
||
+ description = "None";
|
||
+ fprintf(log, "%p: Free (exception `%s')\n", msg, description);
|
||
+ }
|
||
#endif
|
||
- g_hash_table_remove(mail_msg_active_table, GINT_TO_POINTER(m->seq));
|
||
- pthread_cond_broadcast(&mail_msg_cond);
|
||
+ g_hash_table_remove (
|
||
+ mail_msg_active_table, GINT_TO_POINTER (mail_msg->seq));
|
||
+ pthread_cond_broadcast (&mail_msg_cond);
|
||
|
||
/* We need to make sure we dont lose a reference here YUCK YUCK */
|
||
/* This is tightly integrated with the code in do_op_status,
|
||
as it closely relates to the CamelOperation setup in msg_new() above */
|
||
- if (m->priv->activity_state == 1) {
|
||
- m->priv->activity_state = 3; /* tell the other thread
|
||
- * to free it itself (yuck yuck) */
|
||
+ if (mail_msg->priv->activity_state == 1) {
|
||
+ /* tell the other to free it itself */
|
||
+ mail_msg->priv->activity_state = 3;
|
||
MAIL_MT_UNLOCK(mail_msg_lock);
|
||
return;
|
||
} else {
|
||
- activity_id = m->priv->activity_id;
|
||
+ activity_id = mail_msg->priv->activity_id;
|
||
}
|
||
|
||
MAIL_MT_UNLOCK(mail_msg_lock);
|
||
|
||
- if (m->cancel) {
|
||
- camel_operation_mute(m->cancel);
|
||
- camel_operation_unref(m->cancel);
|
||
+ if (mail_msg->cancel) {
|
||
+ camel_operation_mute (mail_msg->cancel);
|
||
+ camel_operation_unref (mail_msg->cancel);
|
||
}
|
||
|
||
- camel_exception_clear(&m->ex);
|
||
- /*g_free(m->priv->what);*/
|
||
- g_free(m->priv);
|
||
- g_free(m);
|
||
+ camel_exception_clear (&mail_msg->ex);
|
||
+ g_slice_free (MailMsgPrivate, mail_msg->priv);
|
||
+ g_slice_free1 (mail_msg->info->size, mail_msg);
|
||
|
||
if (activity_id != 0)
|
||
- mail_async_event_emit(mail_async_event, MAIL_ASYNC_GUI, (MailAsyncFunc) end_event_callback,
|
||
- NULL, GINT_TO_POINTER (activity_id), NULL);
|
||
+ mail_async_event_emit (
|
||
+ mail_async_event, MAIL_ASYNC_GUI,
|
||
+ (MailAsyncFunc) end_event_callback,
|
||
+ NULL, GINT_TO_POINTER (activity_id), NULL);
|
||
}
|
||
|
||
/* hash table of ops->dialogue of active errors */
|
||
@@ -244,9 +271,10 @@ static void error_response(GtkObject *o,
|
||
gtk_widget_destroy((GtkWidget *)o);
|
||
}
|
||
|
||
-void mail_msg_check_error(void *msg)
|
||
+void
|
||
+mail_msg_check_error (gpointer msg)
|
||
{
|
||
- struct _mail_msg *m = msg;
|
||
+ MailMsg *m = msg;
|
||
char *what;
|
||
GtkDialog *gd;
|
||
|
||
@@ -271,27 +299,27 @@ void mail_msg_check_error(void *msg)
|
||
/* check to see if we have dialogue already running for this operation */
|
||
/* we key on the operation pointer, which is at least accurate enough
|
||
for the operation type, although it could be on a different object. */
|
||
- if (g_hash_table_lookup(active_errors, m->ops)) {
|
||
+ if (g_hash_table_lookup(active_errors, m->info)) {
|
||
g_warning("Error occurred while existing dialogue active:\n%s", camel_exception_get_description(&m->ex));
|
||
return;
|
||
}
|
||
|
||
- if (m->ops->describe_msg
|
||
- && (what = m->ops->describe_msg(m, FALSE))) {
|
||
+ if (m->info->desc
|
||
+ && (what = m->info->desc (m))) {
|
||
gd = (GtkDialog *)e_error_new(NULL, "mail:async-error", what, camel_exception_get_description(&m->ex), NULL);
|
||
g_free(what);
|
||
} else
|
||
gd = (GtkDialog *)e_error_new(NULL, "mail:async-error-nodescribe", camel_exception_get_description(&m->ex), NULL);
|
||
|
||
- g_hash_table_insert(active_errors, m->ops, gd);
|
||
- g_signal_connect(gd, "response", G_CALLBACK(error_response), m->ops);
|
||
- g_signal_connect(gd, "destroy", G_CALLBACK(error_destroy), m->ops);
|
||
+ g_hash_table_insert(active_errors, m->info, gd);
|
||
+ g_signal_connect(gd, "response", G_CALLBACK(error_response), m->info);
|
||
+ g_signal_connect(gd, "destroy", G_CALLBACK(error_destroy), m->info);
|
||
gtk_widget_show((GtkWidget *)gd);
|
||
}
|
||
|
||
void mail_msg_cancel(unsigned int msgid)
|
||
{
|
||
- struct _mail_msg *m;
|
||
+ MailMsg *m;
|
||
|
||
MAIL_MT_LOCK(mail_msg_lock);
|
||
m = g_hash_table_lookup(mail_msg_active_table, GINT_TO_POINTER(msgid));
|
||
@@ -304,13 +332,12 @@ void mail_msg_cancel(unsigned int msgid)
|
||
|
||
|
||
/* waits for a message to be finished processing (freed)
|
||
- the messageid is from struct _mail_msg->seq */
|
||
+ the messageid is from MailMsg->seq */
|
||
void mail_msg_wait(unsigned int msgid)
|
||
{
|
||
- struct _mail_msg *m;
|
||
- int ismain = pthread_equal(pthread_self(), mail_gui_thread);
|
||
+ MailMsg *m;
|
||
|
||
- if (ismain) {
|
||
+ if (mail_in_main_thread ()) {
|
||
MAIL_MT_LOCK(mail_msg_lock);
|
||
m = g_hash_table_lookup(mail_msg_active_table, GINT_TO_POINTER(msgid));
|
||
while (m) {
|
||
@@ -347,9 +374,7 @@ int mail_msg_active(unsigned int msgid)
|
||
|
||
void mail_msg_wait_all(void)
|
||
{
|
||
- int ismain = pthread_equal(pthread_self(), mail_gui_thread);
|
||
-
|
||
- if (ismain) {
|
||
+ if (mail_in_main_thread ()) {
|
||
MAIL_MT_LOCK(mail_msg_lock);
|
||
while (g_hash_table_size(mail_msg_active_table) > 0) {
|
||
MAIL_MT_UNLOCK(mail_msg_lock);
|
||
@@ -367,294 +392,239 @@ void mail_msg_wait_all(void)
|
||
}
|
||
|
||
/* **************************************** */
|
||
-struct _cancel_hook_data {
|
||
- struct _cancel_hook_data *next;
|
||
- struct _cancel_hook_data *prev;
|
||
|
||
- GDestroyNotify func;
|
||
- void *data;
|
||
-};
|
||
+static GHookList cancel_hook_list;
|
||
|
||
-static EDList cancel_hook_list = E_DLIST_INITIALISER(cancel_hook_list);
|
||
-
|
||
-void *mail_cancel_hook_add(GDestroyNotify func, void *data)
|
||
+GHook *
|
||
+mail_cancel_hook_add (GHookFunc func, gpointer data)
|
||
{
|
||
- struct _cancel_hook_data *d;
|
||
+ GHook *hook;
|
||
|
||
- d = g_malloc0(sizeof(*d));
|
||
- d->func = func;
|
||
- d->data = data;
|
||
+ MAIL_MT_LOCK (mail_msg_lock);
|
||
|
||
- MAIL_MT_LOCK(mail_msg_lock);
|
||
- e_dlist_addtail(&cancel_hook_list, (EDListNode *)d);
|
||
- MAIL_MT_UNLOCK(mail_msg_lock);
|
||
+ if (!cancel_hook_list.is_setup)
|
||
+ g_hook_list_init (&cancel_hook_list, sizeof (GHook));
|
||
|
||
- return (void *)d;
|
||
-}
|
||
+ hook = g_hook_alloc (&cancel_hook_list);
|
||
+ hook->func = func;
|
||
+ hook->data = data;
|
||
|
||
-void mail_cancel_hook_remove(void *handle)
|
||
-{
|
||
- struct _cancel_hook_data *d = handle;
|
||
+ g_hook_append (&cancel_hook_list, hook);
|
||
|
||
- MAIL_MT_LOCK(mail_msg_lock);
|
||
- e_dlist_remove((EDListNode *)d);
|
||
- MAIL_MT_UNLOCK(mail_msg_lock);
|
||
- g_free(d);
|
||
+ MAIL_MT_UNLOCK (mail_msg_lock);
|
||
+
|
||
+ return hook;
|
||
}
|
||
|
||
-void mail_cancel_all(void)
|
||
+void
|
||
+mail_cancel_hook_remove (GHook *hook)
|
||
{
|
||
- struct _cancel_hook_data *d, *n;
|
||
+ MAIL_MT_LOCK (mail_msg_lock);
|
||
|
||
- camel_operation_cancel(NULL);
|
||
+ g_assert (cancel_hook_list.is_setup);
|
||
+ g_hook_destroy_link (&cancel_hook_list, hook);
|
||
|
||
- /* I can ssee a deadlock coming on ... */
|
||
- MAIL_MT_LOCK(mail_msg_lock);
|
||
- d = (struct _cancel_hook_data *)cancel_hook_list.head;
|
||
- n = d->next;
|
||
- while (n) {
|
||
- d->func(d->data);
|
||
- d = n;
|
||
- n = n->next;
|
||
- }
|
||
- MAIL_MT_UNLOCK(mail_msg_lock);
|
||
+ MAIL_MT_UNLOCK (mail_msg_lock);
|
||
}
|
||
|
||
-EMsgPort *mail_gui_port;
|
||
-static GIOChannel *mail_gui_channel;
|
||
-static guint mail_gui_watch;
|
||
-
|
||
-/* TODO: Merge these, gui_port2 doesn't do any mail_msg processing on the request (replies, forwards, frees) */
|
||
-EMsgPort *mail_gui_port2;
|
||
-static GIOChannel *mail_gui_channel2;
|
||
-static guint mail_gui_watch2;
|
||
-
|
||
-EMsgPort *mail_gui_reply_port;
|
||
-static GIOChannel *mail_gui_reply_channel;
|
||
-
|
||
-/* a couple of global threads available */
|
||
-#ifdef G_OS_WIN32
|
||
-#undef mail_thread_queued
|
||
-static
|
||
-#endif
|
||
-EThread *mail_thread_queued; /* for operations that can (or should) be queued */
|
||
-EThread *mail_thread_queued_slow; /* for operations that can (or should) be queued, but take a long time */
|
||
-EThread *mail_thread_new; /* for operations that should run in a new thread each time */
|
||
-
|
||
-#ifdef G_OS_WIN32
|
||
-EThread *
|
||
-mail_win32_get_mail_thread_queued (void)
|
||
+void
|
||
+mail_cancel_all (void)
|
||
{
|
||
- return mail_thread_queued;
|
||
+ camel_operation_cancel (NULL);
|
||
+
|
||
+ MAIL_MT_LOCK (mail_msg_lock);
|
||
+
|
||
+ if (cancel_hook_list.is_setup)
|
||
+ g_hook_list_invoke (&cancel_hook_list, FALSE);
|
||
+
|
||
+ MAIL_MT_UNLOCK (mail_msg_lock);
|
||
}
|
||
-#endif
|
||
+
|
||
+static guint idle_source_id = 0;
|
||
+G_LOCK_DEFINE_STATIC (idle_source_id);
|
||
+static GAsyncQueue *main_loop_queue = NULL;
|
||
+static GAsyncQueue *msg_reply_queue = NULL;
|
||
+static GThread *main_thread = NULL;
|
||
|
||
static gboolean
|
||
-mail_msgport_replied(GIOChannel *source, GIOCondition cond, void *d)
|
||
+mail_msg_idle_cb (void)
|
||
{
|
||
- EMsgPort *port = (EMsgPort *)d;
|
||
- mail_msg_t *m;
|
||
-
|
||
- while (( m = (mail_msg_t *)e_msgport_get(port))) {
|
||
+ MailMsg *msg;
|
||
|
||
-#ifdef MALLOC_CHECK
|
||
- checkmem(m);
|
||
- checkmem(m->cancel);
|
||
- checkmem(m->priv);
|
||
-#endif
|
||
-
|
||
-#ifdef LOG_OPS
|
||
- if (log_ops)
|
||
- fprintf(log, "%p: Replied to GUI thread (exception `%s'\n", m,
|
||
- camel_exception_get_description(&m->ex)?camel_exception_get_description(&m->ex):"None");
|
||
-#endif
|
||
+ g_assert (main_loop_queue != NULL);
|
||
+ g_assert (msg_reply_queue != NULL);
|
||
|
||
- if (m->ops->reply_msg)
|
||
- m->ops->reply_msg(m);
|
||
- mail_msg_check_error(m);
|
||
- mail_msg_free(m);
|
||
+ G_LOCK (idle_source_id);
|
||
+ idle_source_id = 0;
|
||
+ G_UNLOCK (idle_source_id);
|
||
+
|
||
+ /* check the main loop queue */
|
||
+ while ((msg = g_async_queue_try_pop (main_loop_queue)) != NULL) {
|
||
+ if (msg->info->exec != NULL)
|
||
+ msg->info->exec (msg);
|
||
+ if (msg->info->done != NULL)
|
||
+ msg->info->done (msg);
|
||
+ mail_msg_unref (msg);
|
||
+ }
|
||
+
|
||
+ /* check the reply queue */
|
||
+ while ((msg = g_async_queue_try_pop (msg_reply_queue)) != NULL) {
|
||
+ if (msg->info->done != NULL)
|
||
+ msg->info->done (msg);
|
||
+ mail_msg_check_error (msg);
|
||
+ mail_msg_unref (msg);
|
||
}
|
||
|
||
- return TRUE;
|
||
+ return FALSE;
|
||
}
|
||
|
||
-static gboolean
|
||
-mail_msgport_received(GIOChannel *source, GIOCondition cond, void *d)
|
||
+static void
|
||
+mail_msg_proxy (MailMsg *msg)
|
||
{
|
||
- EMsgPort *port = (EMsgPort *)d;
|
||
- mail_msg_t *m;
|
||
-
|
||
- while (( m = (mail_msg_t *)e_msgport_get(port))) {
|
||
-#ifdef MALLOC_CHECK
|
||
- checkmem(m);
|
||
- checkmem(m->cancel);
|
||
- checkmem(m->priv);
|
||
-#endif
|
||
-
|
||
-#ifdef LOG_OPS
|
||
- if (log_ops)
|
||
- fprintf(log, "%p: Received at GUI thread\n", m);
|
||
-#endif
|
||
-
|
||
- if (m->ops->receive_msg)
|
||
- m->ops->receive_msg(m);
|
||
- if (m->msg.reply_port)
|
||
- e_msgport_reply((EMsg *)m);
|
||
- else {
|
||
- if (m->ops->reply_msg)
|
||
- m->ops->reply_msg(m);
|
||
- mail_msg_free(m);
|
||
- }
|
||
+ if (msg->info->desc != NULL) {
|
||
+ gchar *text = msg->info->desc (msg);
|
||
+ camel_operation_register (msg->cancel);
|
||
+ camel_operation_start (msg->cancel, "%s", text);
|
||
+ g_free (text);
|
||
+ }
|
||
+
|
||
+ if (msg->info->exec != NULL) {
|
||
+ mail_enable_stop ();
|
||
+ msg->info->exec (msg);
|
||
+ mail_disable_stop ();
|
||
+ }
|
||
+
|
||
+ if (msg->info->desc != NULL) {
|
||
+ camel_operation_end (msg->cancel);
|
||
+ camel_operation_unregister (msg->cancel);
|
||
+ MAIL_MT_LOCK (mail_msg_lock);
|
||
+ camel_operation_unref (msg->cancel);
|
||
+ msg->cancel = NULL;
|
||
+ MAIL_MT_UNLOCK (mail_msg_lock);
|
||
}
|
||
|
||
- return TRUE;
|
||
+ g_async_queue_push (msg_reply_queue, msg);
|
||
+
|
||
+ G_LOCK (idle_source_id);
|
||
+ if (idle_source_id == 0)
|
||
+ idle_source_id = g_idle_add (
|
||
+ (GSourceFunc) mail_msg_idle_cb, NULL);
|
||
+ G_UNLOCK (idle_source_id);
|
||
}
|
||
|
||
-/* Test code, lighterwight, more configurable calls */
|
||
-static gboolean
|
||
-mail_msgport_received2(GIOChannel *source, GIOCondition cond, void *d)
|
||
+void
|
||
+mail_msg_cleanup (void)
|
||
{
|
||
- EMsgPort *port = (EMsgPort *)d;
|
||
- mail_msg_t *m;
|
||
+ mail_msg_wait_all();
|
||
|
||
- while (( m = (mail_msg_t *)e_msgport_get(port))) {
|
||
-#ifdef LOG_OPS
|
||
- if (log_ops)
|
||
- fprintf(log, "%p: Received at GUI2 thread\n", m);
|
||
-#endif
|
||
+ G_LOCK (idle_source_id);
|
||
+ if (idle_source_id != 0) {
|
||
+ GSource *source;
|
||
|
||
- if (m->ops->receive_msg)
|
||
- m->ops->receive_msg(m);
|
||
- else
|
||
- mail_msg_free(m);
|
||
+ /* Cancel the idle source. */
|
||
+ source = g_main_context_find_source_by_id (
|
||
+ g_main_context_default (), idle_source_id);
|
||
+ g_assert (source != NULL);
|
||
+ g_source_destroy (source);
|
||
+ idle_source_id = 0;
|
||
}
|
||
+ G_UNLOCK (idle_source_id);
|
||
|
||
- return TRUE;
|
||
-}
|
||
+ g_assert (main_loop_queue != NULL);
|
||
+ g_async_queue_unref (main_loop_queue);
|
||
+ main_loop_queue = NULL;
|
||
|
||
+ g_assert (msg_reply_queue != NULL);
|
||
+ g_async_queue_unref (msg_reply_queue);
|
||
+ msg_reply_queue = NULL;
|
||
+}
|
||
|
||
-static void
|
||
-mail_msg_destroy(EThread *e, EMsg *msg, void *data)
|
||
+void
|
||
+mail_msg_init (void)
|
||
{
|
||
- mail_msg_t *m = (mail_msg_t *)msg;
|
||
+ main_loop_queue = g_async_queue_new ();
|
||
+ msg_reply_queue = g_async_queue_new ();
|
||
|
||
-#ifdef MALLOC_CHECK
|
||
- checkmem(m);
|
||
- checkmem(m->cancel);
|
||
- checkmem(m->priv);
|
||
-#endif
|
||
+ mail_msg_active_table = g_hash_table_new (NULL, NULL);
|
||
+ main_thread = g_thread_self ();
|
||
|
||
- mail_msg_free(m);
|
||
+ mail_async_event = mail_async_event_new ();
|
||
}
|
||
|
||
-static void
|
||
-mail_msg_received(EThread *e, EMsg *msg, void *data)
|
||
+static gint
|
||
+mail_msg_compare (const MailMsg *msg1, const MailMsg *msg2)
|
||
{
|
||
- mail_msg_t *m = (mail_msg_t *)msg;
|
||
-
|
||
-#ifdef MALLOC_CHECK
|
||
- checkmem(m);
|
||
- checkmem(m->cancel);
|
||
- checkmem(m->priv);
|
||
-#endif
|
||
+ gint priority1 = msg1->priority;
|
||
+ gint priority2 = msg2->priority;
|
||
|
||
- if (m->ops->describe_msg) {
|
||
- char *text = m->ops->describe_msg(m, FALSE);
|
||
+ if (priority1 == priority2)
|
||
+ return 0;
|
||
|
||
-#ifdef LOG_OPS
|
||
- if (log_ops)
|
||
- fprintf(log, "%p: Received at thread %" G_GINT64_MODIFIER "x: '%s'\n", m, e_util_pthread_id(pthread_self()), text);
|
||
-#endif
|
||
+ return (priority1 < priority2) ? 1 : -1;
|
||
+}
|
||
|
||
- d(printf("message received at thread\n"));
|
||
- camel_operation_register(m->cancel);
|
||
- camel_operation_start(m->cancel, "%s", text);
|
||
- g_free(text);
|
||
- }
|
||
-#ifdef LOG_OPS
|
||
- else
|
||
- if (log_ops)
|
||
- fprintf(log, "%p: Received at thread %" G_GINT64_MODIFIER "x\n", m, e_util_pthread_id(pthread_self()));
|
||
-#endif
|
||
+static gpointer
|
||
+create_thread_pool (gpointer data)
|
||
+{
|
||
+ GThreadPool *thread_pool;
|
||
+ gint max_threads = GPOINTER_TO_INT (data);
|
||
|
||
- if (m->ops->receive_msg) {
|
||
- mail_enable_stop();
|
||
- m->ops->receive_msg(m);
|
||
- mail_disable_stop();
|
||
- }
|
||
+ /* once created, run forever */
|
||
+ thread_pool = g_thread_pool_new (
|
||
+ (GFunc) mail_msg_proxy, NULL, max_threads, FALSE, NULL);
|
||
+ g_thread_pool_set_sort_function (
|
||
+ thread_pool, (GCompareDataFunc) mail_msg_compare, NULL);
|
||
|
||
- if (m->ops->describe_msg) {
|
||
- camel_operation_end(m->cancel);
|
||
- camel_operation_unregister(m->cancel);
|
||
- MAIL_MT_LOCK(mail_msg_lock);
|
||
- camel_operation_unref(m->cancel);
|
||
- m->cancel = NULL;
|
||
- MAIL_MT_UNLOCK(mail_msg_lock);
|
||
- }
|
||
+ return thread_pool;
|
||
}
|
||
|
||
-void mail_msg_cleanup(void)
|
||
+void
|
||
+mail_msg_main_loop_push (gpointer msg)
|
||
{
|
||
- mail_msg_wait_all();
|
||
+ g_async_queue_push_sorted (main_loop_queue, msg,
|
||
+ (GCompareDataFunc) mail_msg_compare, NULL);
|
||
|
||
- e_thread_destroy(mail_thread_queued_slow);
|
||
- e_thread_destroy(mail_thread_queued);
|
||
- e_thread_destroy(mail_thread_new);
|
||
+ G_LOCK (idle_source_id);
|
||
+ if (idle_source_id == 0)
|
||
+ idle_source_id = g_idle_add (
|
||
+ (GSourceFunc) mail_msg_idle_cb, NULL);
|
||
+ G_UNLOCK (idle_source_id);
|
||
+}
|
||
|
||
- g_io_channel_unref(mail_gui_channel);
|
||
- g_io_channel_unref(mail_gui_reply_channel);
|
||
+void
|
||
+mail_msg_unordered_push (gpointer msg)
|
||
+{
|
||
+ static GOnce once = G_ONCE_INIT;
|
||
|
||
- e_msgport_destroy(mail_gui_port);
|
||
- e_msgport_destroy(mail_gui_reply_port);
|
||
+ g_once (&once, (GThreadFunc) create_thread_pool, GINT_TO_POINTER (10));
|
||
+
|
||
+ g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);
|
||
}
|
||
|
||
-static guint
|
||
-em_channel_setup(EMsgPort **port, GIOChannel **channel, GIOFunc func)
|
||
+void
|
||
+mail_msg_fast_ordered_push (gpointer msg)
|
||
{
|
||
- GSource *source;
|
||
- guint id;
|
||
+ static GOnce once = G_ONCE_INIT;
|
||
|
||
- *port = e_msgport_new();
|
||
-#ifndef G_OS_WIN32
|
||
- *channel = g_io_channel_unix_new(e_msgport_fd(*port));
|
||
-#else
|
||
- *channel = g_io_channel_win32_new_socket(e_msgport_fd(*port));
|
||
-#endif
|
||
- source = g_io_create_watch(*channel, G_IO_IN);
|
||
- g_source_set_callback(source, (GSourceFunc)func, *port, NULL);
|
||
- g_source_set_can_recurse(source, FALSE);
|
||
- id = g_source_attach(source, NULL);
|
||
- g_source_unref(source);
|
||
+ g_once (&once, (GThreadFunc) create_thread_pool, GINT_TO_POINTER (1));
|
||
|
||
- return id;
|
||
+ g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);
|
||
}
|
||
|
||
-void mail_msg_init(void)
|
||
+void
|
||
+mail_msg_slow_ordered_push (gpointer msg)
|
||
{
|
||
- em_channel_setup(&mail_gui_reply_port, &mail_gui_reply_channel, mail_msgport_replied);
|
||
- mail_gui_watch = em_channel_setup(&mail_gui_port, &mail_gui_channel, mail_msgport_received);
|
||
- mail_gui_watch2 = em_channel_setup(&mail_gui_port2, &mail_gui_channel2, mail_msgport_received2);
|
||
-
|
||
- mail_thread_queued = e_thread_new(E_THREAD_QUEUE);
|
||
- e_thread_set_msg_destroy(mail_thread_queued, mail_msg_destroy, 0);
|
||
- e_thread_set_msg_received(mail_thread_queued, mail_msg_received, 0);
|
||
- e_thread_set_reply_port(mail_thread_queued, mail_gui_reply_port);
|
||
-
|
||
- mail_thread_queued_slow = e_thread_new(E_THREAD_QUEUE);
|
||
- e_thread_set_msg_destroy(mail_thread_queued_slow, mail_msg_destroy, 0);
|
||
- e_thread_set_msg_received(mail_thread_queued_slow, mail_msg_received, 0);
|
||
- e_thread_set_reply_port(mail_thread_queued_slow, mail_gui_reply_port);
|
||
-
|
||
- mail_thread_new = e_thread_new(E_THREAD_NEW);
|
||
- e_thread_set_msg_destroy(mail_thread_new, mail_msg_destroy, 0);
|
||
- e_thread_set_msg_received(mail_thread_new, mail_msg_received, 0);
|
||
- e_thread_set_reply_port(mail_thread_new, mail_gui_reply_port);
|
||
- e_thread_set_queue_limit(mail_thread_new, 10);
|
||
+ static GOnce once = G_ONCE_INIT;
|
||
+
|
||
+ g_once (&once, (GThreadFunc) create_thread_pool, GINT_TO_POINTER (1));
|
||
|
||
- mail_msg_active_table = g_hash_table_new(NULL, NULL);
|
||
- mail_gui_thread = pthread_self();
|
||
+ g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);
|
||
+}
|
||
|
||
- mail_async_event = mail_async_event_new();
|
||
+gboolean
|
||
+mail_in_main_thread (void)
|
||
+{
|
||
+ return (g_thread_self () == main_thread);
|
||
}
|
||
|
||
/* ********************************************************************** */
|
||
@@ -665,7 +635,8 @@ static pthread_mutex_t status_lock = PTH
|
||
/* ********************************************************************** */
|
||
|
||
struct _proxy_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
+
|
||
MailAsyncEvent *ea;
|
||
mail_async_event_t type;
|
||
|
||
@@ -679,10 +650,8 @@ struct _proxy_msg {
|
||
};
|
||
|
||
static void
|
||
-do_async_event(struct _mail_msg *mm)
|
||
+do_async_event(struct _proxy_msg *m)
|
||
{
|
||
- struct _proxy_msg *m = (struct _proxy_msg *)mm;
|
||
-
|
||
m->thread = pthread_self();
|
||
m->have_thread = TRUE;
|
||
m->func(m->o, m->event_data, m->data);
|
||
@@ -697,16 +666,17 @@ static int
|
||
idle_async_event(void *mm)
|
||
{
|
||
do_async_event(mm);
|
||
- mail_msg_free(mm);
|
||
+ mail_msg_unref(mm);
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
-static struct _mail_msg_op async_event_op = {
|
||
- NULL,
|
||
- do_async_event,
|
||
- NULL,
|
||
- NULL,
|
||
+static MailMsgInfo async_event_info = {
|
||
+ sizeof (struct _proxy_msg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) do_async_event,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) NULL
|
||
};
|
||
|
||
MailAsyncEvent *mail_async_event_new(void)
|
||
@@ -723,10 +693,9 @@ int mail_async_event_emit(MailAsyncEvent
|
||
{
|
||
struct _proxy_msg *m;
|
||
int id;
|
||
- int ismain = pthread_equal(pthread_self(), mail_gui_thread);
|
||
|
||
/* we dont have a reply port for this, we dont care when/if it gets executed, just queue it */
|
||
- m = mail_msg_new(&async_event_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&async_event_info);
|
||
m->func = func;
|
||
m->o = o;
|
||
m->event_data = event_data;
|
||
@@ -735,7 +704,7 @@ int mail_async_event_emit(MailAsyncEvent
|
||
m->type = type;
|
||
m->have_thread = FALSE;
|
||
|
||
- id = m->msg.seq;
|
||
+ id = m->base.seq;
|
||
g_mutex_lock(ea->lock);
|
||
ea->tasks = g_slist_prepend(ea->tasks, m);
|
||
g_mutex_unlock(ea->lock);
|
||
@@ -743,12 +712,12 @@ int mail_async_event_emit(MailAsyncEvent
|
||
/* We use an idle function instead of our own message port only because the
|
||
gui message ports's notification buffer might overflow and deadlock us */
|
||
if (type == MAIL_ASYNC_GUI) {
|
||
- if (ismain)
|
||
+ if (mail_in_main_thread ())
|
||
g_idle_add(idle_async_event, m);
|
||
else
|
||
- e_msgport_put(mail_gui_port, (EMsg *)m);
|
||
+ mail_msg_main_loop_push(m);
|
||
} else
|
||
- e_thread_put(mail_thread_queued, (EMsg *)m);
|
||
+ mail_msg_fast_ordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
@@ -762,7 +731,7 @@ int mail_async_event_destroy(MailAsyncEv
|
||
g_mutex_lock(ea->lock);
|
||
while (ea->tasks) {
|
||
m = ea->tasks->data;
|
||
- id = m->msg.seq;
|
||
+ id = m->base.seq;
|
||
if (m->have_thread && pthread_equal(m->thread, thread)) {
|
||
g_warning("Destroying async event from inside an event, returning EDEADLK");
|
||
g_mutex_unlock(ea->lock);
|
||
@@ -784,17 +753,18 @@ int mail_async_event_destroy(MailAsyncEv
|
||
/* ********************************************************************** */
|
||
|
||
struct _call_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
+
|
||
mail_call_t type;
|
||
MailMainFunc func;
|
||
void *ret;
|
||
va_list ap;
|
||
+ EFlag *done;
|
||
};
|
||
|
||
static void
|
||
-do_call(struct _mail_msg *mm)
|
||
+do_call(struct _call_msg *m)
|
||
{
|
||
- struct _call_msg *m = (struct _call_msg *)mm;
|
||
void *p1, *p2, *p3, *p4, *p5;
|
||
int i1;
|
||
va_list ap;
|
||
@@ -842,45 +812,48 @@ do_call(struct _mail_msg *mm)
|
||
m->ret = m->func(p1, p2, i1, p3, p4, p5);
|
||
break;
|
||
}
|
||
+
|
||
+ if (m->done != NULL)
|
||
+ e_flag_set (m->done);
|
||
}
|
||
|
||
-static struct _mail_msg_op mail_call_op = {
|
||
- NULL,
|
||
- do_call,
|
||
- NULL,
|
||
- NULL,
|
||
+static MailMsgInfo mail_call_info = {
|
||
+ sizeof (struct _call_msg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) do_call,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) NULL
|
||
};
|
||
|
||
-void *mail_call_main(mail_call_t type, MailMainFunc func, ...)
|
||
+void *
|
||
+mail_call_main (mail_call_t type, MailMainFunc func, ...)
|
||
{
|
||
struct _call_msg *m;
|
||
void *ret;
|
||
va_list ap;
|
||
- EMsgPort *reply = NULL;
|
||
- int ismain = pthread_equal(pthread_self(), mail_gui_thread);
|
||
|
||
va_start(ap, func);
|
||
|
||
- if (!ismain)
|
||
- reply = e_msgport_new();
|
||
-
|
||
- m = mail_msg_new(&mail_call_op, reply, sizeof(*m));
|
||
+ m = mail_msg_new (&mail_call_info);
|
||
m->type = type;
|
||
m->func = func;
|
||
G_VA_COPY(m->ap, ap);
|
||
|
||
- if (!ismain) {
|
||
- e_msgport_put(mail_gui_port, (EMsg *)m);
|
||
- e_msgport_wait(reply);
|
||
- e_msgport_destroy(reply);
|
||
- } else {
|
||
- do_call(&m->msg);
|
||
+ mail_msg_ref (m);
|
||
+
|
||
+ if (mail_in_main_thread ())
|
||
+ do_call (m);
|
||
+ else {
|
||
+ m->done = e_flag_new ();
|
||
+ mail_msg_main_loop_push (m);
|
||
+ e_flag_wait (m->done);
|
||
+ e_flag_free (m->done);
|
||
}
|
||
|
||
va_end(ap);
|
||
|
||
ret = m->ret;
|
||
- mail_msg_free(m);
|
||
+ mail_msg_unref (m);
|
||
|
||
return ret;
|
||
}
|
||
@@ -889,40 +862,42 @@ void *mail_call_main(mail_call_t type, M
|
||
/* locked via status_lock */
|
||
static int busy_state;
|
||
|
||
-static void do_set_busy(struct _mail_msg *mm)
|
||
+static void
|
||
+do_set_busy(MailMsg *mm)
|
||
{
|
||
set_stop(busy_state > 0);
|
||
}
|
||
|
||
-static struct _mail_msg_op set_busy_op = {
|
||
- NULL,
|
||
- do_set_busy,
|
||
- NULL,
|
||
- NULL,
|
||
+static MailMsgInfo set_busy_info = {
|
||
+ sizeof (MailMsg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) do_set_busy,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) NULL
|
||
};
|
||
|
||
void mail_enable_stop(void)
|
||
{
|
||
- struct _mail_msg *m;
|
||
+ MailMsg *m;
|
||
|
||
MAIL_MT_LOCK(status_lock);
|
||
busy_state++;
|
||
if (busy_state == 1) {
|
||
- m = mail_msg_new(&set_busy_op, NULL, sizeof(*m));
|
||
- e_msgport_put(mail_gui_port, (EMsg *)m);
|
||
+ m = mail_msg_new(&set_busy_info);
|
||
+ mail_msg_main_loop_push(m);
|
||
}
|
||
MAIL_MT_UNLOCK(status_lock);
|
||
}
|
||
|
||
void mail_disable_stop(void)
|
||
{
|
||
- struct _mail_msg *m;
|
||
+ MailMsg *m;
|
||
|
||
MAIL_MT_LOCK(status_lock);
|
||
busy_state--;
|
||
if (busy_state == 0) {
|
||
- m = mail_msg_new(&set_busy_op, NULL, sizeof(*m));
|
||
- e_msgport_put(mail_gui_port, (EMsg *)m);
|
||
+ m = mail_msg_new(&set_busy_info);
|
||
+ mail_msg_main_loop_push(m);
|
||
}
|
||
MAIL_MT_UNLOCK(status_lock);
|
||
}
|
||
@@ -930,7 +905,7 @@ void mail_disable_stop(void)
|
||
/* ******************************************************************************** */
|
||
|
||
struct _op_status_msg {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
struct _CamelOperation *op;
|
||
char *what;
|
||
@@ -938,16 +913,16 @@ struct _op_status_msg {
|
||
void *data;
|
||
};
|
||
|
||
-static void do_op_status(struct _mail_msg *mm)
|
||
+static void
|
||
+op_status_exec (struct _op_status_msg *m)
|
||
{
|
||
EActivityHandler *activity_handler = mail_component_peek_activity_handler (mail_component_peek ());
|
||
- struct _op_status_msg *m = (struct _op_status_msg *)mm;
|
||
- struct _mail_msg *msg;
|
||
- struct _mail_msg_priv *data;
|
||
+ MailMsg *msg;
|
||
+ MailMsgPrivate *data;
|
||
char *out, *p, *o, c;
|
||
int pc;
|
||
|
||
- g_assert (pthread_equal(mail_gui_thread, pthread_self ()));
|
||
+ g_assert (mail_in_main_thread ());
|
||
|
||
MAIL_MT_LOCK (mail_msg_lock);
|
||
|
||
@@ -986,8 +961,8 @@ static void do_op_status(struct _mail_ms
|
||
progress_icon = e_icon_factory_get_icon ("stock_mail-unread", E_ICON_SIZE_MENU);
|
||
|
||
MAIL_MT_UNLOCK (mail_msg_lock);
|
||
- if (msg->ops->describe_msg)
|
||
- what = msg->ops->describe_msg (msg, FALSE);
|
||
+ if (msg->info->desc)
|
||
+ what = msg->info->desc (msg);
|
||
/* uncommenting because message is not very useful for a user, see bug 271734*/
|
||
else {
|
||
what = g_strdup("");
|
||
@@ -1021,18 +996,17 @@ static void do_op_status(struct _mail_ms
|
||
}
|
||
|
||
static void
|
||
-do_op_status_free (struct _mail_msg *mm)
|
||
+op_status_free (struct _op_status_msg *m)
|
||
{
|
||
- struct _op_status_msg *m = (struct _op_status_msg *)mm;
|
||
-
|
||
g_free (m->what);
|
||
}
|
||
|
||
-static struct _mail_msg_op op_status_op = {
|
||
- NULL,
|
||
- do_op_status,
|
||
- NULL,
|
||
- do_op_status_free,
|
||
+static MailMsgInfo op_status_info = {
|
||
+ sizeof (struct _op_status_msg),
|
||
+ (MailMsgDescFunc) NULL,
|
||
+ (MailMsgExecFunc) op_status_exec,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) op_status_free
|
||
};
|
||
|
||
static void
|
||
@@ -1042,7 +1016,7 @@ mail_operation_status (struct _CamelOper
|
||
|
||
d(printf("got operation statys: %s %d%%\n", what, pc));
|
||
|
||
- m = mail_msg_new(&op_status_op, NULL, sizeof(*m));
|
||
+ m = mail_msg_new(&op_status_info);
|
||
m->op = op;
|
||
m->what = g_strdup(what);
|
||
switch (pc) {
|
||
@@ -1055,7 +1029,7 @@ mail_operation_status (struct _CamelOper
|
||
}
|
||
m->pc = pc;
|
||
m->data = data;
|
||
- e_msgport_put(mail_gui_port, (EMsg *)m);
|
||
+ mail_msg_main_loop_push(m);
|
||
}
|
||
|
||
/* ******************** */
|
||
--- evolution-2.11.3/plugins/folder-unsubscribe/folder-unsubscribe.c.kill-ethread 2007-04-18 06:17:14.000000000 -0400
|
||
+++ evolution-2.11.3/plugins/folder-unsubscribe/folder-unsubscribe.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -44,32 +44,30 @@ void org_gnome_mail_folder_unsubscribe (
|
||
|
||
|
||
struct _folder_unsub_t {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
char *uri;
|
||
};
|
||
|
||
-static char *
|
||
-folder_unsubscribe__desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+folder_unsubscribe_desc (struct _folder_unsub_t *msg)
|
||
{
|
||
- struct _folder_unsub_t *unsub = (struct _folder_unsub_t *) mm;
|
||
-
|
||
- return g_strdup_printf (_("Unsubscribing from folder \"%s\""), unsub->uri);
|
||
+ return g_strdup_printf (
|
||
+ _("Unsubscribing from folder \"%s\""), msg->uri);
|
||
}
|
||
|
||
static void
|
||
-folder_unsubscribe__unsub (struct _mail_msg *mm)
|
||
+folder_unsubscribe_exec (struct _folder_unsub_t *msg)
|
||
{
|
||
- struct _folder_unsub_t *unsub = (struct _folder_unsub_t *) mm;
|
||
extern CamelSession *session;
|
||
const char *path = NULL;
|
||
CamelStore *store;
|
||
CamelURL *url;
|
||
|
||
- if (!(store = camel_session_get_store (session, unsub->uri, &mm->ex)))
|
||
+ if (!(store = camel_session_get_store (session, msg->uri, &mm->ex)))
|
||
return;
|
||
|
||
- url = camel_url_new (unsub->uri, NULL);
|
||
+ url = camel_url_new (msg->uri, NULL);
|
||
if (((CamelService *) store)->provider->url_flags & CAMEL_URL_FRAGMENT_IS_PATH)
|
||
path = url->fragment;
|
||
else if (url->path && url->path[0])
|
||
@@ -82,18 +80,17 @@ folder_unsubscribe__unsub (struct _mail_
|
||
}
|
||
|
||
static void
|
||
-folder_unsubscribe__free (struct _mail_msg *mm)
|
||
+folder_unsubscribe_free (struct _folder_unsub_t *msg)
|
||
{
|
||
- struct _folder_unsub_t *unsub = (struct _folder_unsub_t *) mm;
|
||
-
|
||
- g_free (unsub->uri);
|
||
+ g_free (msg->uri);
|
||
}
|
||
|
||
-static struct _mail_msg_op unsubscribe_op = {
|
||
- folder_unsubscribe__desc,
|
||
- folder_unsubscribe__unsub,
|
||
- NULL,
|
||
- folder_unsubscribe__free,
|
||
+static MailMsgInfo unsubscribe_info = {
|
||
+ sizeof (struct _folder_unsub_t),
|
||
+ (MailMsgDescFunc) folder_unsubscribe_desc,
|
||
+ (MailMsgExecFunc) folder_unsubscribe_exec,
|
||
+ (MailMsgDoneFunc) NULL,
|
||
+ (MailMsgFreeFunc) folder_unsubscribe_free
|
||
};
|
||
|
||
|
||
@@ -105,8 +102,8 @@ org_gnome_mail_folder_unsubscribe (EPlug
|
||
if (target->uri == NULL)
|
||
return;
|
||
|
||
- unsub = mail_msg_new (&unsubscribe_op, NULL, sizeof (struct _folder_unsub_t));
|
||
+ unsub = mail_msg_new (&unsubscribe_info);
|
||
unsub->uri = g_strdup (target->uri);
|
||
|
||
- e_thread_put (mail_thread_new, (EMsg *) unsub);
|
||
+ mail_msg_unordered_push (unsub);
|
||
}
|
||
--- evolution-2.11.3/plugins/mark-all-read/mark-all-read.c.kill-ethread 2007-05-14 00:24:02.000000000 -0400
|
||
+++ evolution-2.11.3/plugins/mark-all-read/mark-all-read.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -44,7 +44,7 @@ org_gnome_mark_all_read (EPlugin *ep, EM
|
||
return;
|
||
}
|
||
|
||
- mail_get_folder(t->uri, 0, mar_got_folder, NULL, mail_thread_new);
|
||
+ mail_get_folder(t->uri, 0, mar_got_folder, NULL, mail_msg_unordered_push);
|
||
}
|
||
|
||
static void
|
||
--- evolution-2.11.3/plugins/exchange-operations/exchange-folder.c.kill-ethread 2007-05-13 13:41:07.000000000 -0400
|
||
+++ evolution-2.11.3/plugins/exchange-operations/exchange-folder.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -140,7 +140,7 @@ org_gnome_exchange_folder_inbox_unsubscr
|
||
inbox_physical_uri = e_folder_get_physical_uri (inbox);
|
||
|
||
/* To get the CamelStore/Folder */
|
||
- mail_get_folder (inbox_physical_uri, 0, exchange_get_folder, target_uri, mail_thread_new);
|
||
+ mail_get_folder (inbox_physical_uri, 0, exchange_get_folder, target_uri, mail_msg_unordered_push);
|
||
|
||
|
||
}
|
||
--- evolution-2.11.3/plugins/save-attachments/save-attachments.c.kill-ethread 2007-04-18 06:17:20.000000000 -0400
|
||
+++ evolution-2.11.3/plugins/save-attachments/save-attachments.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -403,5 +403,5 @@ org_gnome_save_attachments_save(EPlugin
|
||
camel_object_ref(data->folder);
|
||
data->uid = g_strdup(target->uids->pdata[0]);
|
||
|
||
- mail_get_message(data->folder, data->uid, save_got_message, data, mail_thread_new);
|
||
+ mail_get_message(data->folder, data->uid, save_got_message, data, mail_msg_unordered_push);
|
||
}
|
||
--- evolution-2.11.3/plugins/mailing-list-actions/mailing-list-actions.c.kill-ethread 2007-04-18 06:17:17.000000000 -0400
|
||
+++ evolution-2.11.3/plugins/mailing-list-actions/mailing-list-actions.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -89,7 +89,7 @@ void emla_list_action (EPlugin *item, EM
|
||
data->uri = strdup (sel->uri);
|
||
|
||
mail_get_message (sel->folder, (const char*) g_ptr_array_index (sel->uids, 0),
|
||
- emla_list_action_do, data, mail_thread_new);
|
||
+ emla_list_action_do, data, mail_msg_unordered_push);
|
||
}
|
||
|
||
void emla_list_action_do (CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data)
|
||
--- evolution-2.11.3/plugins/groupwise-features/share-folder-common.c.kill-ethread 2007-04-18 06:17:15.000000000 -0400
|
||
+++ evolution-2.11.3/plugins/groupwise-features/share-folder-common.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -121,7 +121,7 @@ shared_folder_abort (EPlugin *ep, EConfi
|
||
}
|
||
|
||
struct _EMCreateFolder {
|
||
- struct _mail_msg msg;
|
||
+ MailMsg base;
|
||
|
||
/* input data */
|
||
CamelStore *store;
|
||
@@ -137,31 +137,26 @@ struct _EMCreateFolder {
|
||
void *user_data;
|
||
};
|
||
|
||
-static char *
|
||
-create_folder__desc (struct _mail_msg *mm, int done)
|
||
+static gchar *
|
||
+create_folder_desc (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
-
|
||
return g_strdup_printf (_("Creating folder `%s'"), m->full_name);
|
||
}
|
||
|
||
static void
|
||
-create_folder__create (struct _mail_msg *mm)
|
||
+create_folder_exec (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
-
|
||
d(printf ("creating folder parent='%s' name='%s' full_name='%s'\n", m->parent, m->name, m->full_name));
|
||
|
||
- if ((m->fi = camel_store_create_folder (m->store, m->parent, m->name, &mm->ex))) {
|
||
+ if ((m->fi = camel_store_create_folder (m->store, m->parent, m->name, &m->base.ex))) {
|
||
if (camel_store_supports_subscriptions (m->store))
|
||
- camel_store_subscribe_folder (m->store, m->full_name, &mm->ex);
|
||
+ camel_store_subscribe_folder (m->store, m->full_name, &m->base.ex);
|
||
}
|
||
}
|
||
|
||
static void
|
||
-create_folder__created (struct _mail_msg *mm)
|
||
+create_folder_done (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
struct ShareInfo *ssi = (struct ShareInfo *) m->user_data;
|
||
CamelStore *store = CAMEL_STORE (m->store) ;
|
||
EGwConnection *ccnc;
|
||
@@ -180,10 +175,8 @@ create_folder__created (struct _mail_msg
|
||
}
|
||
|
||
static void
|
||
-create_folder__free (struct _mail_msg *mm)
|
||
+create_folder_free (struct _EMCreateFolder *m)
|
||
{
|
||
- struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
|
||
-
|
||
camel_store_free_folder_info (m->store, m->fi);
|
||
camel_object_unref (m->store);
|
||
g_free (m->full_name);
|
||
@@ -191,11 +184,12 @@ create_folder__free (struct _mail_msg *m
|
||
g_free (m->name);
|
||
}
|
||
|
||
-static struct _mail_msg_op create_folder_op = {
|
||
- create_folder__desc,
|
||
- create_folder__create,
|
||
- create_folder__created,
|
||
- create_folder__free,
|
||
+static MailMsgInfo create_folder_info = {
|
||
+ sizeof (struct _EMCreateFolder),
|
||
+ (MailMsgDescFunc) create_folder_desc,
|
||
+ (MailMsgExecFunc) create_folder_exec,
|
||
+ (MailMsgDoneFunc) create_folder_done,
|
||
+ (MailMsgFreeFunc) create_folder_free
|
||
};
|
||
|
||
static void
|
||
@@ -229,7 +223,7 @@ create_folder (CamelStore *store, const
|
||
parent = namebuf;
|
||
}
|
||
|
||
- m = mail_msg_new (&create_folder_op, NULL, sizeof (struct _EMCreateFolder));
|
||
+ m = mail_msg_new (&create_folder_info);
|
||
camel_object_ref (store);
|
||
m->store = store;
|
||
m->full_name = g_strdup (full_name);
|
||
@@ -238,8 +232,8 @@ create_folder (CamelStore *store, const
|
||
m->user_data = (struct ShareInfo *) user_data;
|
||
m->done = done;
|
||
g_free (namebuf);
|
||
- id = m->msg.seq;
|
||
- e_thread_put (mail_thread_new, (EMsg *) m);
|
||
+ id = m->base.seq;
|
||
+ mail_msg_unordered_push (m);
|
||
|
||
return id;
|
||
}
|
||
--- evolution-2.11.3/calendar/gui/alarm-notify/alarm-notify.h.kill-ethread 2007-04-18 06:18:37.000000000 -0400
|
||
+++ evolution-2.11.3/calendar/gui/alarm-notify/alarm-notify.h 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -39,19 +39,6 @@ typedef struct _AlarmNotifyClass AlarmNo
|
||
|
||
typedef struct _AlarmNotifyPrivate AlarmNotifyPrivate;
|
||
|
||
-typedef struct _AlarmMsg AlarmMsg;
|
||
-typedef struct _AlarmMsgPrivate AlarmMsgPrivate;
|
||
-
|
||
-struct _AlarmMsg {
|
||
- EMsg msg;
|
||
-
|
||
- void (*receive_msg)(EThread *e, struct _AlarmMsg *msg, void *data); /* message received */
|
||
- void *data;
|
||
-
|
||
- /* Private Usage */
|
||
- struct _AlarmMsgPrivate *priv;
|
||
-};
|
||
-
|
||
struct _AlarmNotify {
|
||
BonoboObject object;
|
||
|
||
--- evolution-2.11.3/calendar/gui/alarm-notify/alarm-notify.c.kill-ethread 2007-04-18 06:18:37.000000000 -0400
|
||
+++ evolution-2.11.3/calendar/gui/alarm-notify/alarm-notify.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -45,10 +45,6 @@ struct _AlarmNotifyPrivate {
|
||
GMutex *mutex;
|
||
};
|
||
|
||
-EThread *alarm_operation_thread; /* for operations that can (or should) be queued */
|
||
-EMsgPort *alarm_reply_port;
|
||
-static GIOChannel *alarm_reply_channel;
|
||
-
|
||
#define d(x) x
|
||
|
||
|
||
@@ -286,72 +282,12 @@ alarm_notify_finalize (GObject *object)
|
||
g_mutex_free (priv->mutex);
|
||
g_free (priv);
|
||
|
||
- e_thread_destroy(alarm_operation_thread);
|
||
- g_io_channel_unref(alarm_reply_channel);
|
||
- e_msgport_destroy(alarm_reply_port);
|
||
if (G_OBJECT_CLASS (parent_class)->finalize)
|
||
(* G_OBJECT_CLASS (parent_class)->finalize) (object);
|
||
}
|
||
|
||
|
||
|
||
-static guint
|
||
-alarm_channel_setup(EMsgPort **port, GIOChannel **channel, GIOFunc func)
|
||
-{
|
||
- GSource *source;
|
||
- guint id;
|
||
-
|
||
- d (printf("%s:%d (alarm_channel_setup) - Channel Setup\n ", __FILE__, __LINE__));
|
||
- *port = e_msgport_new();
|
||
-#ifndef G_OS_WIN32
|
||
- *channel = g_io_channel_unix_new(e_msgport_fd(*port));
|
||
-#else
|
||
- *channel = g_io_channel_win32_new_socket(e_msgport_fd(*port));
|
||
-#endif
|
||
- source = g_io_create_watch(*channel, G_IO_IN);
|
||
- g_source_set_callback(source, (GSourceFunc)func, *port, NULL);
|
||
- g_source_set_can_recurse(source, FALSE);
|
||
- id = g_source_attach(source, NULL);
|
||
- g_source_unref(source);
|
||
-
|
||
- return id;
|
||
-}
|
||
-
|
||
-static void
|
||
-alarm_msg_destroy(EThread *e, EMsg *msg, void *data)
|
||
-{
|
||
- AlarmMsg *m = (AlarmMsg *)msg;
|
||
-
|
||
- /* Free the private */
|
||
- g_free (m->data); /* Mostly it is a structure allocated as a carrier*/
|
||
- g_free (m);
|
||
-}
|
||
-
|
||
-static gboolean
|
||
-alarm_msgport_replied(GIOChannel *source, GIOCondition cond, void *d)
|
||
-{
|
||
- EMsgPort *port = (EMsgPort *)d;
|
||
- EMsg *m;
|
||
-
|
||
- while (( m = e_msgport_get(port))) {
|
||
- d (printf("%s:%d (alarm_msgport_replied) - %p: Replied to GUI thread\n", __FILE__, __LINE__, m));
|
||
- alarm_msg_destroy(NULL, m, NULL);
|
||
- }
|
||
-
|
||
- return TRUE;
|
||
-}
|
||
-
|
||
-static void
|
||
-alarm_msg_received(EThread *e, EMsg *msg, void *data)
|
||
-{
|
||
- AlarmMsg *m = (AlarmMsg *)msg;
|
||
-
|
||
- d(printf("%s:%d (alarm_msg_received) - %p: Received at thread %" G_GINT64_MODIFIER "x\n", __FILE__, __LINE__, m, e_util_pthread_id(pthread_self())));
|
||
- if (m->receive_msg) {
|
||
- m->receive_msg (e, m, data);
|
||
- }
|
||
-}
|
||
-
|
||
/**
|
||
* alarm_notify_new:
|
||
*
|
||
@@ -363,23 +299,10 @@ alarm_msg_received(EThread *e, EMsg *msg
|
||
AlarmNotify *
|
||
alarm_notify_new (void)
|
||
{
|
||
- AlarmNotify *an;
|
||
-
|
||
- d (printf("%s:%d (alarm_notify_new) - Alarm Notify New \n ", __FILE__, __LINE__));
|
||
-
|
||
- /* Create a thread for alarm queue operation*/
|
||
- alarm_channel_setup(&alarm_reply_port, &alarm_reply_channel, alarm_msgport_replied);
|
||
-
|
||
- alarm_operation_thread = e_thread_new(E_THREAD_QUEUE);
|
||
- e_thread_set_msg_destroy(alarm_operation_thread, alarm_msg_destroy, 0);
|
||
- e_thread_set_msg_received(alarm_operation_thread, alarm_msg_received, 0);
|
||
- e_thread_set_reply_port(alarm_operation_thread, alarm_reply_port);
|
||
-
|
||
- an = g_object_new (TYPE_ALARM_NOTIFY,
|
||
- "poa", bonobo_poa_get_threaded (ORBIT_THREAD_HINT_PER_REQUEST, NULL),
|
||
- NULL);
|
||
-
|
||
- return an;
|
||
+ return g_object_new (TYPE_ALARM_NOTIFY,
|
||
+ "poa", bonobo_poa_get_threaded (
|
||
+ ORBIT_THREAD_HINT_PER_REQUEST, NULL),
|
||
+ NULL);
|
||
}
|
||
|
||
static void
|
||
--- evolution-2.11.3/calendar/gui/alarm-notify/alarm-queue.c.kill-ethread 2007-06-01 03:09:22.000000000 -0400
|
||
+++ evolution-2.11.3/calendar/gui/alarm-notify/alarm-queue.c 2007-06-04 14:25:34.000000000 -0400
|
||
@@ -97,9 +97,6 @@ static int tray_blink_id = -1;
|
||
static int tray_blink_state = FALSE;
|
||
static AlarmNotify *an;
|
||
|
||
-/* Main Tasks thread for dealing with the global structures */
|
||
-extern EThread *alarm_operation_thread;
|
||
-
|
||
/* Structure that stores a client we are monitoring */
|
||
typedef struct {
|
||
/* Monitored client */
|
||
@@ -181,6 +178,40 @@ static void on_dialog_objs_removed_cb (E
|
||
static void load_alarms_for_today (ClientAlarms *ca);
|
||
static void midnight_refresh_cb (gpointer alarm_id, time_t trigger, gpointer data);
|
||
|
||
+/* Simple asynchronous message dispatcher */
|
||
+
|
||
+typedef struct _Message Message;
|
||
+typedef void (*MessageFunc) (Message *msg);
|
||
+
|
||
+struct _Message {
|
||
+ MessageFunc func;
|
||
+};
|
||
+
|
||
+static void
|
||
+message_proxy (Message *msg)
|
||
+{
|
||
+ g_return_if_fail (msg->func != NULL);
|
||
+
|
||
+ msg->func (msg);
|
||
+}
|
||
+
|
||
+static gpointer
|
||
+create_thread_pool (void)
|
||
+{
|
||
+ /* once created, run forever */
|
||
+ return g_thread_pool_new ((GFunc) message_proxy, NULL, 1, FALSE, NULL);
|
||
+}
|
||
+
|
||
+static void
|
||
+message_push (Message *msg)
|
||
+{
|
||
+ static GOnce once = G_ONCE_INIT;
|
||
+
|
||
+ g_once (&once, (GThreadFunc) create_thread_pool, NULL);
|
||
+
|
||
+ g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);
|
||
+}
|
||
+
|
||
/* Queues an alarm trigger for midnight so that we can load the next day's worth
|
||
* of alarms.
|
||
*/
|
||
@@ -219,47 +250,41 @@ add_client_alarms_cb (gpointer key, gpoi
|
||
}
|
||
|
||
struct _midnight_refresh_msg {
|
||
+ Message header;
|
||
gboolean remove;
|
||
};
|
||
|
||
/* Loads the alarms for the new day every midnight */
|
||
static void
|
||
-midnight_refresh_async (EThread *e, AlarmMsg *msg, void *data)
|
||
+midnight_refresh_async (struct _midnight_refresh_msg *msg)
|
||
{
|
||
- struct _midnight_refresh_msg *list = msg->data;
|
||
-
|
||
d(printf("%s:%d (midnight_refresh_async) \n",__FILE__, __LINE__));
|
||
|
||
/* Re-load the alarms for all clients */
|
||
g_hash_table_foreach (client_alarms_hash, add_client_alarms_cb, NULL);
|
||
|
||
/* Re-schedule the midnight update */
|
||
- if (list->remove && midnight_refresh_id != NULL) {
|
||
+ if (msg->remove && midnight_refresh_id != NULL) {
|
||
d(printf("%s:%d (midnight_refresh_async) - Reschedule the midnight update \n",__FILE__, __LINE__));
|
||
alarm_remove (midnight_refresh_id);
|
||
midnight_refresh_id = NULL;
|
||
}
|
||
|
||
queue_midnight_refresh ();
|
||
+
|
||
+ g_slice_free (struct _midnight_refresh_msg, msg);
|
||
}
|
||
|
||
static void
|
||
midnight_refresh_cb (gpointer alarm_id, time_t trigger, gpointer data)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _midnight_refresh_msg *list;
|
||
-
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = midnight_refresh_async;
|
||
-
|
||
- list = malloc (sizeof (struct _midnight_refresh_msg));
|
||
+ struct _midnight_refresh_msg *msg;
|
||
|
||
- list->remove = TRUE;
|
||
- msg->data = list;
|
||
+ msg = g_slice_new (struct _midnight_refresh_msg);
|
||
+ msg->header.func = (MessageFunc) midnight_refresh_async;
|
||
+ msg->remove = TRUE;
|
||
|
||
- d(printf("%s:%d (midnight_refresh_cb) - Invoking task for midnight refresh\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
/* Looks up a client in the client alarms hash table */
|
||
@@ -618,6 +643,7 @@ remove_comp (ClientAlarms *ca, ECalCompo
|
||
* alarms.
|
||
*/
|
||
struct _query_msg {
|
||
+ Message header;
|
||
ECal *client;
|
||
GList *objects;
|
||
gpointer data;
|
||
@@ -651,7 +677,7 @@ duplicate_ecal (GList *in_list)
|
||
}
|
||
|
||
static void
|
||
-query_objects_changed_async (EThread *e, AlarmMsg *msg, void *data)
|
||
+query_objects_changed_async (struct _query_msg *msg)
|
||
{
|
||
ClientAlarms *ca;
|
||
time_t from, day_end;
|
||
@@ -660,13 +686,12 @@ query_objects_changed_async (EThread *e,
|
||
icaltimezone *zone;
|
||
CompQueuedAlarms *cqa;
|
||
GList *l;
|
||
- struct _query_msg *list = msg->data;
|
||
ECal *client;
|
||
GList *objects;
|
||
|
||
- client = list->client;
|
||
- ca = list->data;
|
||
- objects = list->objects;
|
||
+ client = msg->client;
|
||
+ ca = msg->data;
|
||
+ objects = msg->objects;
|
||
|
||
from = config_data_get_last_notification_time ();
|
||
if (from == -1)
|
||
@@ -755,43 +780,38 @@ query_objects_changed_async (EThread *e,
|
||
comp = NULL;
|
||
}
|
||
g_list_free (objects);
|
||
+
|
||
+ g_slice_free (struct _query_msg, msg);
|
||
}
|
||
|
||
static void
|
||
query_objects_changed_cb (ECal *client, GList *objects, gpointer data)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _query_msg *list;
|
||
+ struct _query_msg *msg;
|
||
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = query_objects_changed_async;
|
||
- list = malloc (sizeof (struct _query_msg));
|
||
- list->client = client;
|
||
- list->objects = duplicate_ical (objects);
|
||
- list->data = data;
|
||
- msg->data = list;
|
||
-
|
||
- d(printf("%s:%d (query_objects_changed_cb) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ msg = g_slice_new (struct _query_msg);
|
||
+ msg->header.func = (MessageFunc) query_objects_changed_async;
|
||
+ msg->client = client;
|
||
+ msg->objects = duplicate_ical (objects);
|
||
+ msg->data = data;
|
||
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
/* Called when a calendar component is removed; we must delete its corresponding
|
||
* alarms.
|
||
*/
|
||
static void
|
||
-query_objects_removed_async (EThread *e, AlarmMsg *msg, void *data)
|
||
+query_objects_removed_async (struct _query_msg *msg)
|
||
{
|
||
ClientAlarms *ca;
|
||
GList *l;
|
||
- struct _query_msg *list = msg->data;
|
||
ECal *client;
|
||
GList *objects;
|
||
|
||
- client = list->client;
|
||
- ca = list->data;
|
||
- objects = list->objects;
|
||
+ client = msg->client;
|
||
+ ca = msg->data;
|
||
+ objects = msg->objects;
|
||
|
||
d(printf("%s:%d (query_objects_removed_async) - Removing %d objects\n",__FILE__, __LINE__, g_list_length(objects)));
|
||
|
||
@@ -804,27 +824,22 @@ query_objects_removed_async (EThread *e,
|
||
}
|
||
|
||
g_list_free (objects);
|
||
+
|
||
+ g_slice_free (struct _query_msg, msg);
|
||
}
|
||
|
||
static void
|
||
query_objects_removed_cb (ECal *client, GList *objects, gpointer data)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _query_msg *list;
|
||
-
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = query_objects_removed_async;
|
||
-
|
||
- list = malloc (sizeof (struct _query_msg));
|
||
- list->client = client;
|
||
- list->objects = duplicate_ecal (objects);
|
||
- list->data = data;
|
||
- msg->data = list;
|
||
+ struct _query_msg *msg;
|
||
|
||
- d(printf("%s:%d (query_objects_removed_cb) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ msg = g_slice_new (struct _query_msg);
|
||
+ msg->header.func = (MessageFunc) query_objects_removed_async;
|
||
+ msg->client = client;
|
||
+ msg->objects = duplicate_ecal (objects);
|
||
+ msg->data = data;
|
||
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
|
||
@@ -966,20 +981,19 @@ free_tray_icon_data (TrayIconData *tray_
|
||
}
|
||
|
||
static void
|
||
-on_dialog_objs_removed_async (EThread *e, AlarmMsg *msg, void *data)
|
||
+on_dialog_objs_removed_async (struct _query_msg *msg)
|
||
{
|
||
const char *our_uid;
|
||
GList *l;
|
||
TrayIconData *tray_data;
|
||
- struct _query_msg *list = msg->data;
|
||
ECal *client;
|
||
GList *objects;
|
||
|
||
d(printf("%s:%d (on_dialog_objs_removed_async)\n",__FILE__, __LINE__));
|
||
|
||
- client = list->client;
|
||
- tray_data = list->data;
|
||
- objects = list->objects;
|
||
+ client = msg->client;
|
||
+ tray_data = msg->data;
|
||
+ objects = msg->objects;
|
||
|
||
e_cal_component_get_uid (tray_data->comp, &our_uid);
|
||
g_return_if_fail (our_uid && *our_uid);
|
||
@@ -997,37 +1011,33 @@ on_dialog_objs_removed_async (EThread *e
|
||
tray_data = NULL;
|
||
}
|
||
}
|
||
+
|
||
+ g_slice_free (struct _query_msg, msg);
|
||
}
|
||
|
||
static void
|
||
on_dialog_objs_removed_cb (ECal *client, GList *objects, gpointer data)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _query_msg *list;
|
||
+ struct _query_msg *msg;
|
||
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = on_dialog_objs_removed_async;
|
||
-
|
||
- list = malloc (sizeof (struct _query_msg));
|
||
- list->client = client;
|
||
- list->objects = objects;
|
||
- list->data = data;
|
||
- msg->data = list;
|
||
+ msg = g_slice_new (struct _query_msg);
|
||
+ msg->header.func = (MessageFunc) on_dialog_objs_removed_async;
|
||
+ msg->client = client;
|
||
+ msg->objects = objects;
|
||
+ msg->data = data;
|
||
|
||
- d(printf("%s:%d (on_dialog_objs_removed_cb) - Posting a task \n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
struct _tray_cqa_msg {
|
||
+ Message header;
|
||
CompQueuedAlarms *cqa;
|
||
};
|
||
|
||
static void
|
||
-tray_list_remove_cqa_async(EThread *e, AlarmMsg *msg, void *data)
|
||
+tray_list_remove_cqa_async (struct _tray_cqa_msg *msg)
|
||
{
|
||
- struct _tray_cqa_msg *tmsg = msg->data;
|
||
- CompQueuedAlarms *cqa = tmsg->cqa;
|
||
+ CompQueuedAlarms *cqa = msg->cqa;
|
||
GList *list = tray_icons_list;
|
||
|
||
d(printf("%s:%d (tray_list_remove_cqa_async) - Removing CQA %p from tray list\n",__FILE__, __LINE__, cqa));
|
||
@@ -1066,28 +1076,25 @@ tray_list_remove_cqa_async(EThread *e, A
|
||
gtk_tree_selection_select_iter (sel, &iter);
|
||
}
|
||
}
|
||
+
|
||
+ g_slice_free (struct _tray_cqa_msg, msg);
|
||
}
|
||
|
||
static void
|
||
tray_list_remove_cqa (CompQueuedAlarms *cqa)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _tray_cqa_msg *list;
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = tray_list_remove_cqa_async;
|
||
-
|
||
- list = malloc (sizeof (struct _tray_cqa_msg));
|
||
- list->cqa = cqa;
|
||
- msg->data = list;
|
||
+ struct _tray_cqa_msg *msg;
|
||
+
|
||
+ msg = g_slice_new (struct _tray_cqa_msg);
|
||
+ msg->header.func = (MessageFunc) tray_list_remove_cqa_async;
|
||
+ msg->cqa = cqa;
|
||
|
||
- d(printf("%s:%d (tray_list_remove_cqa) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
/* Callback used from the alarm notify dialog */
|
||
static void
|
||
-tray_list_remove_async(EThread *e, AlarmMsg *msg, void *data)
|
||
+tray_list_remove_async (Message *msg)
|
||
{
|
||
GList *list = tray_icons_list;
|
||
|
||
@@ -1117,55 +1124,50 @@ tray_list_remove_async(EThread *e, Alarm
|
||
} else
|
||
list = list->next;
|
||
}
|
||
+
|
||
+ g_slice_free (Message, msg);
|
||
}
|
||
|
||
static void
|
||
-tray_list_remove_icons ()
|
||
+tray_list_remove_icons (void)
|
||
{
|
||
- AlarmMsg *msg;
|
||
-
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = tray_list_remove_async;
|
||
+ Message *msg;
|
||
|
||
- msg->data = NULL;
|
||
+ msg = g_slice_new (Message);
|
||
+ msg->func = tray_list_remove_async;
|
||
|
||
- d(printf("%s:%d (tray_list_remove_icons) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push (msg);
|
||
}
|
||
|
||
struct _tray_msg {
|
||
+ Message header;
|
||
TrayIconData *data;
|
||
};
|
||
|
||
static void
|
||
-tray_list_remove_data_async(EThread *e, AlarmMsg *msg, void *data)
|
||
+tray_list_remove_data_async (struct _tray_msg *msg)
|
||
{
|
||
- struct _tray_msg *tmsg = msg->data;
|
||
- TrayIconData *tray_data = tmsg->data;
|
||
+ TrayIconData *tray_data = msg->data;
|
||
|
||
d(printf("%s:%d (tray_list_remove_data_async) - Removing %p from tray list\n",__FILE__, __LINE__, tray_data));
|
||
|
||
tray_icons_list = g_list_remove_all (tray_icons_list, tray_data);
|
||
free_tray_icon_data (tray_data);
|
||
tray_data = NULL;
|
||
+
|
||
+ g_slice_free (struct _tray_msg, msg);
|
||
}
|
||
|
||
static void
|
||
tray_list_remove_data (TrayIconData *data)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _tray_msg *list;
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = tray_list_remove_data_async;
|
||
-
|
||
- list = malloc (sizeof (struct _tray_msg));
|
||
- list->data = data;
|
||
- msg->data = list;
|
||
+ struct _tray_msg *msg;
|
||
+
|
||
+ msg = g_slice_new (struct _tray_msg);
|
||
+ msg->header.func = (MessageFunc) tray_list_remove_data_async;
|
||
+ msg->data = data;
|
||
|
||
- d(printf("%s:%d (tray_list_remove_data) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
static void
|
||
@@ -1372,29 +1374,24 @@ tray_icon_blink_cb (gpointer data)
|
||
/* Add a new data to tray list */
|
||
|
||
static void
|
||
-tray_list_add_async (EThread *e, AlarmMsg *msg, void *data)
|
||
+tray_list_add_async (struct _tray_msg *msg)
|
||
{
|
||
- struct _tray_msg *list = msg->data;
|
||
- d(printf("%s:%d (tray_list_add_async) - Add %p\n",__FILE__, __LINE__, list->data));
|
||
- tray_icons_list = g_list_prepend (tray_icons_list, list->data);
|
||
+ d(printf("%s:%d (tray_list_add_async) - Add %p\n",__FILE__, __LINE__, msg->data));
|
||
+ tray_icons_list = g_list_prepend (tray_icons_list, msg->data);
|
||
+
|
||
+ g_slice_free (struct _tray_msg, msg);
|
||
}
|
||
|
||
static void
|
||
tray_list_add_new (TrayIconData *data)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _tray_msg *list;
|
||
+ struct _tray_msg *msg;
|
||
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = tray_list_add_async;
|
||
-
|
||
- list = malloc (sizeof (struct _tray_msg));
|
||
- list->data = data;
|
||
- msg->data = list;
|
||
-
|
||
- d(printf("%s:%d (tray_list_add_new) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ msg = g_slice_new (struct _tray_msg);
|
||
+ msg->header.func = (MessageFunc) tray_list_add_async;
|
||
+ msg->data = data;
|
||
+
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
/* Performs notification of a display alarm */
|
||
@@ -1791,21 +1788,13 @@ check_midnight_refresh (gpointer user_da
|
||
new_midnight = time_day_end_with_zone (time (NULL), zone);
|
||
|
||
if (new_midnight > midnight) {
|
||
- AlarmMsg *msg;
|
||
- struct _midnight_refresh_msg *list;
|
||
-
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = midnight_refresh_async;
|
||
-
|
||
- list = malloc (sizeof (struct _midnight_refresh_msg));
|
||
+ struct _midnight_refresh_msg *msg;
|
||
|
||
- list->remove = FALSE;
|
||
- /* We dont need it. So set it to NULL */
|
||
- msg->data = list;
|
||
+ msg = g_slice_new (struct _midnight_refresh_msg);
|
||
+ msg->header.func = (MessageFunc) midnight_refresh_async;
|
||
+ msg->remove = FALSE;
|
||
|
||
- d(printf("%s:%d (check_midnight_refresh) - Posting a task to refresh\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
return TRUE;
|
||
@@ -1936,14 +1925,15 @@ hash_ids (gpointer a)
|
||
}
|
||
|
||
struct _alarm_client_msg {
|
||
+ Message header;
|
||
ECal *client;
|
||
};
|
||
|
||
-static void alarm_queue_add_async (EThread *e, AlarmMsg *msg, void *data)
|
||
+static void
|
||
+alarm_queue_add_async (struct _alarm_client_msg *msg)
|
||
{
|
||
ClientAlarms *ca;
|
||
- struct _alarm_client_msg *list = msg->data;
|
||
- ECal *client = list->client;
|
||
+ ECal *client = msg->client;
|
||
|
||
g_return_if_fail (alarm_queue_inited);
|
||
g_return_if_fail (client != NULL);
|
||
@@ -1974,6 +1964,8 @@ static void alarm_queue_add_async (EThre
|
||
G_CALLBACK (cal_opened_cb),
|
||
ca);
|
||
}
|
||
+
|
||
+ g_slice_free (struct _alarm_client_msg, msg);
|
||
}
|
||
|
||
/**
|
||
@@ -1993,20 +1985,13 @@ static void alarm_queue_add_async (EThre
|
||
void
|
||
alarm_queue_add_client (ECal *client)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _alarm_client_msg *list;
|
||
+ struct _alarm_client_msg *msg;
|
||
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = alarm_queue_add_async;
|
||
-
|
||
- list = malloc (sizeof (struct _alarm_client_msg));
|
||
- list->client = client;
|
||
- g_object_ref (client);
|
||
- msg->data = list;
|
||
+ msg = g_slice_new (struct _alarm_client_msg);
|
||
+ msg->header.func = (MessageFunc) alarm_queue_add_async;
|
||
+ msg->client = g_object_ref (client);
|
||
|
||
- d(printf("%s:%d (alarm_queue_add_client) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
/* Removes a component an its alarms */
|
||
@@ -2058,11 +2043,10 @@ remove_client_alarms (ClientAlarms *ca)
|
||
* Removes a calendar client from the alarm queueing system.
|
||
**/
|
||
static void
|
||
-alarm_queue_remove_async (EThread *e, AlarmMsg *msg, void *data)
|
||
+alarm_queue_remove_async (struct _alarm_client_msg *msg)
|
||
{
|
||
ClientAlarms *ca;
|
||
- struct _alarm_client_msg *list = msg->data;
|
||
- ECal *client = list->client;
|
||
+ ECal *client = msg->client;
|
||
|
||
g_return_if_fail (alarm_queue_inited);
|
||
g_return_if_fail (client != NULL);
|
||
@@ -2099,24 +2083,20 @@ alarm_queue_remove_async (EThread *e, Al
|
||
g_free (ca);
|
||
|
||
g_hash_table_remove (client_alarms_hash, client);
|
||
+
|
||
+ g_slice_free (struct _alarm_client_msg, msg);
|
||
}
|
||
|
||
void
|
||
alarm_queue_remove_client (ECal *client)
|
||
{
|
||
- AlarmMsg *msg;
|
||
- struct _alarm_client_msg *list;
|
||
+ struct _alarm_client_msg *msg;
|
||
|
||
- /* These two structures will be freed by the msg destroy function*/
|
||
- msg = malloc (sizeof (AlarmMsg));
|
||
- msg->receive_msg = alarm_queue_remove_async;
|
||
-
|
||
- list = malloc (sizeof (struct _alarm_client_msg));
|
||
- list->client = client;
|
||
- msg->data = list;
|
||
+ msg = g_slice_new (struct _alarm_client_msg);
|
||
+ msg->header.func = (MessageFunc) alarm_queue_remove_async;
|
||
+ msg->client = client;
|
||
|
||
- d(printf("%s:%d (alarm_queue_remove_client) - Posting a task\n",__FILE__, __LINE__));
|
||
- e_thread_put(alarm_operation_thread, (EMsg *)msg);
|
||
+ message_push ((Message *) msg);
|
||
}
|
||
|
||
/* Update non-time related variables for various structures on modification of an existing component
|