X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-mail-operation.c;h=4f0f94227e47f3c2f5e9a84626f056a3171530e5;hp=009b11eefe43ef39ac95b9ad656df97199d9adfe;hb=152ee6945dc5142b5e63f2a6ac6efc2dbb94df0c;hpb=f6c67c77ab1306d6f369ebe94b308d0286dfa451 diff --git a/src/modest-mail-operation.c b/src/modest-mail-operation.c index 009b11e..4f0f942 100644 --- a/src/modest-mail-operation.c +++ b/src/modest-mail-operation.c @@ -51,15 +51,19 @@ #include "modest-text-utils.h" #include "modest-tny-msg.h" #include "modest-tny-folder.h" +#include "modest-tny-account-store.h" #include "modest-tny-platform-factory.h" #include "modest-marshal.h" #include "modest-error.h" #include "modest-mail-operation.h" -#include "widgets/modest-header-view.h" -#include "widgets/modest-main-window.h" #define KB 1024 -#define GET_SIZE_BUFFER_SIZE 128 + +/* + * Remove all these #ifdef stuff when the tinymail's idle calls become + * locked + */ +#define TINYMAIL_IDLES_NOT_LOCKED_YET 1 /* 'private'/'protected' functions */ static void modest_mail_operation_class_init (ModestMailOperationClass *klass); @@ -69,7 +73,7 @@ static void modest_mail_operation_finalize (GObject *obj); static void get_msg_cb (TnyFolder *folder, gboolean cancelled, TnyMsg *msg, - GError **err, + GError *rr, gpointer user_data); static void get_msg_status_cb (GObject *obj, @@ -78,8 +82,6 @@ static void get_msg_status_cb (GObject *obj, static void modest_mail_operation_notify_end (ModestMailOperation *self); -static gboolean did_a_cancel = FALSE; - enum _ModestMailOperationSignals { PROGRESS_CHANGED_SIGNAL, @@ -128,6 +130,7 @@ typedef struct _XFerMsgAsyncHelper TnyList *headers; TnyFolder *dest_folder; XferMsgsAsynUserCallback user_callback; + gboolean delete; gpointer user_data; } XFerMsgAsyncHelper; @@ -397,29 +400,27 @@ gboolean modest_mail_operation_cancel (ModestMailOperation *self) { ModestMailOperationPrivate *priv; + gboolean canceled = FALSE; - if (!MODEST_IS_MAIL_OPERATION (self)) { - g_warning ("%s: invalid parametter", G_GNUC_FUNCTION); - return FALSE; - } + g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), FALSE); priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self); - if (!priv) { - g_warning ("BUG: %s: priv == NULL", __FUNCTION__); - return FALSE; - } - did_a_cancel = TRUE; + /* Note that if we call cancel with an already canceled mail + operation the progress changed signal won't be emitted */ + if (priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED) + return FALSE; /* Set new status */ priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED; - - /* This emits progress-changed on which the mail operation queue is - * listening, so the mail operation is correctly removed from the - * queue without further explicit calls. */ - modest_mail_operation_notify_end (self); - return TRUE; + /* Cancel the mail operation. We need to wrap it between this + start/stop operations to allow following calls to the + account */ + g_return_val_if_fail (priv->account, FALSE); + tny_account_cancel (priv->account); + + return canceled; } guint @@ -574,9 +575,13 @@ idle_create_msg_cb (gpointer idle_data) { CreateMsgIdleInfo *info = (CreateMsgIdleInfo *) idle_data; - gdk_threads_enter (); + /* This is a GDK lock because we are an idle callback and + * info->callback can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED */ info->callback (info->mail_op, info->msg, info->userdata); - gdk_threads_leave (); + gdk_threads_leave (); /* CHECKED */ + g_object_unref (info->mail_op); if (info->msg) g_object_unref (info->msg); @@ -605,13 +610,18 @@ create_msg_thread (gpointer thread_data) if (new_msg) { TnyHeader *header; + TnyHeaderFlags flags = 0; + /* Set priority flags in message */ header = tny_msg_get_header (new_msg); if (info->priority_flags != 0) - tny_header_set_flags (header, info->priority_flags); - if (info->attachments_list != NULL) { - tny_header_set_flags (header, TNY_HEADER_FLAG_ATTACHMENTS); - } + flags |= info->priority_flags; + + /* Set attachment flags in message */ + if (info->attachments_list != NULL) + flags |= TNY_HEADER_FLAG_ATTACHMENTS; + + tny_header_set_flags (header, flags); g_object_unref (G_OBJECT(header)); } else { priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; @@ -671,6 +681,7 @@ modest_mail_operation_create_msg (ModestMailOperation *self, info->from = g_strdup (from); info->to = g_strdup (to); info->cc = g_strdup (cc); + info->bcc = g_strdup (bcc); info->subject = g_strdup (subject); info->plain_body = g_strdup (plain_body); info->html_body = g_strdup (html_body); @@ -696,7 +707,8 @@ modest_mail_operation_send_new_mail_cb (ModestMailOperation *self, gpointer userdata) { SendNewMailInfo *info = (SendNewMailInfo *) userdata; - TnyFolder *folder; + TnyFolder *draft_folder = NULL; + TnyFolder *outbox_folder = NULL; TnyHeader *header; if (!msg) { @@ -706,22 +718,38 @@ modest_mail_operation_send_new_mail_cb (ModestMailOperation *self, /* Call mail operation */ modest_mail_operation_send_mail (self, info->transport_account, msg); - folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (info->transport_account), TNY_FOLDER_TYPE_DRAFTS); - if (folder) { - if (info->draft_msg != NULL) { - header = tny_msg_get_header (info->draft_msg); - /* Note: This can fail (with a warning) if the message is not really already in a folder, - * because this function requires it to have a UID. */ - tny_folder_remove_msg (folder, header, NULL); - tny_header_set_flags (header, TNY_HEADER_FLAG_DELETED); - tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN); - g_object_unref (header); - } + /* Remove old mail from its source folder */ + draft_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (info->transport_account), TNY_FOLDER_TYPE_DRAFTS); + outbox_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (info->transport_account), TNY_FOLDER_TYPE_OUTBOX); + if (info->draft_msg != NULL) { + TnyFolder *folder = NULL; + TnyFolder *src_folder = NULL; + TnyFolderType folder_type; + folder = tny_msg_get_folder (info->draft_msg); + if (folder == NULL) goto end; + folder_type = modest_tny_folder_guess_folder_type (folder); + if (folder_type == TNY_FOLDER_TYPE_OUTBOX) + src_folder = outbox_folder; + else + src_folder = draft_folder; + + /* Note: This can fail (with a warning) if the message is not really already in a folder, + * because this function requires it to have a UID. */ + header = tny_msg_get_header (info->draft_msg); + tny_folder_remove_msg (src_folder, header, NULL); + tny_header_set_flags (header, TNY_HEADER_FLAG_DELETED); + tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN); + g_object_unref (header); + g_object_unref (folder); } end: if (info->draft_msg) g_object_unref (info->draft_msg); + if (draft_folder) + g_object_unref (draft_folder); + if (outbox_folder) + g_object_unref (outbox_folder); if (info->transport_account) g_object_unref (info->transport_account); g_slice_free (SendNewMailInfo, info); @@ -781,6 +809,7 @@ modest_mail_operation_save_to_drafts_cb (ModestMailOperation *self, TnyMsg *msg, gpointer userdata) { + TnyFolder *src_folder = NULL; TnyFolder *folder = NULL; TnyHeader *header = NULL; ModestMailOperationPrivate *priv = NULL; @@ -804,20 +833,21 @@ modest_mail_operation_save_to_drafts_cb (ModestMailOperation *self, goto end; } - if (info->draft_msg != NULL) { + if (!priv->error) + tny_folder_add_msg (folder, msg, &(priv->error)); + + if ((!priv->error) && (info->draft_msg != NULL)) { header = tny_msg_get_header (info->draft_msg); + src_folder = tny_header_get_folder (header); /* Remove the old draft expunging it */ - tny_folder_remove_msg (folder, header, NULL); + tny_folder_remove_msg (src_folder, header, NULL); tny_header_set_flags (header, TNY_HEADER_FLAG_DELETED); tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN); - tny_folder_sync (folder, FALSE, &(priv->error)); /* FALSE --> don't expunge */ + tny_folder_sync_async (src_folder, TRUE, NULL, NULL, NULL); /* expunge */ g_object_unref (header); } if (!priv->error) - tny_folder_add_msg (folder, msg, &(priv->error)); - - if (!priv->error) priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS; else priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; @@ -829,6 +859,8 @@ modest_mail_operation_save_to_drafts_cb (ModestMailOperation *self, end: if (folder) g_object_unref (G_OBJECT(folder)); + if (src_folder) + g_object_unref (G_OBJECT(src_folder)); if (info->edit_window) g_object_unref (G_OBJECT(info->edit_window)); if (info->draft_msg) @@ -997,10 +1029,11 @@ recurse_folders (TnyFolderStore *store, TnyFolderStoreQuery *query, TnyList *all while (!tny_iterator_is_done (iter)) { TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter); - - tny_list_prepend (all_folders, G_OBJECT (folder)); - recurse_folders (folder, query, all_folders); - g_object_unref (G_OBJECT (folder)); + if (folder) { + tny_list_prepend (all_folders, G_OBJECT (folder)); + recurse_folders (folder, query, all_folders); + g_object_unref (G_OBJECT (folder)); + } tny_iterator_next (iter); } @@ -1019,7 +1052,14 @@ idle_notify_progress (gpointer data) ModestMailOperationState *state; state = modest_mail_operation_clone_state (mail_op); + + /* This is a GDK lock because we are an idle callback and + * the handlers of this signal can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED */ g_signal_emit (G_OBJECT (mail_op), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); + gdk_threads_leave (); /* CHECKED */ + g_slice_free (ModestMailOperationState, state); return TRUE; @@ -1037,7 +1077,12 @@ idle_notify_progress_once (gpointer data) pair = (ModestPair *) data; + /* This is a GDK lock because we are an idle callback and + * the handlers of this signal can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED */ g_signal_emit (G_OBJECT (pair->first), signals[PROGRESS_CHANGED_SIGNAL], 0, pair->second, NULL); + gdk_threads_leave (); /* CHECKED */ /* Free the state and the reference to the mail operation */ g_slice_free (ModestMailOperationState, (ModestMailOperationState*)pair->second); @@ -1086,18 +1131,23 @@ compare_headers_by_date (gconstpointer a, static gboolean set_last_updated_idle (gpointer data) { - gdk_threads_enter (); + + /* This is a GDK lock because we are an idle callback and + * modest_account_mgr_set_int can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED - please recheck */ /* It does not matter if the time is not exactly the same than the time when this idle was called, it's just an approximation and it won't be very different */ + modest_account_mgr_set_int (modest_runtime_get_account_mgr (), (gchar *) data, MODEST_ACCOUNT_LAST_UPDATED, time(NULL), TRUE); - gdk_threads_leave (); + gdk_threads_leave (); /* CHECKED - please recheck */ return FALSE; } @@ -1109,11 +1159,14 @@ idle_update_account_cb (gpointer data) idle_info = (UpdateAccountInfo *) data; - gdk_threads_enter (); + /* This is a GDK lock because we are an idle callback and + * idle_info->callback can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED */ idle_info->callback (idle_info->mail_op, idle_info->new_headers, idle_info->user_data); - gdk_threads_leave (); + gdk_threads_leave (); /* CHECKED */ /* Frees */ g_object_unref (idle_info->mail_op); @@ -1127,13 +1180,14 @@ static gpointer update_account_thread (gpointer thr_user_data) { static gboolean first_time = TRUE; - UpdateAccountInfo *info; + UpdateAccountInfo *info = NULL; TnyList *all_folders = NULL; GPtrArray *new_headers = NULL; TnyIterator *iter = NULL; TnyFolderStoreQuery *query = NULL; ModestMailOperationPrivate *priv = NULL; ModestTnySendQueue *send_queue = NULL; + gint num_new_headers = 0; info = (UpdateAccountInfo *) thr_user_data; priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mail_op); @@ -1142,11 +1196,17 @@ update_account_thread (gpointer thr_user_data) priv->account = g_object_ref (info->account); /* - * for POP3, we do a logout-login upon send/receive -- many POP-servers (like Gmail) do not - * show any updates unless we do that + * Previousl, we did this for POP3, to do a logout-login upon send/receive, + * because many POP-servers (like Gmail) do not + * show any updates unless we do that. + * But that didn't work with gmail anyway, + * and tinymail now takes care of this itself by disconnecting + * automatically after using the connection. */ - if (!first_time && TNY_IS_CAMEL_POP_STORE_ACCOUNT(priv->account)) + /* + if (!first_time && TNY_IS_CAMEL_POP_STORE_ACCOUNT (priv->account)) tny_camel_pop_store_account_reconnect (TNY_CAMEL_POP_STORE_ACCOUNT(priv->account)); + */ /* Get all the folders. We can do it synchronously because we're already running in a different thread than the UI */ @@ -1165,8 +1225,10 @@ update_account_thread (gpointer thr_user_data) iter = tny_list_create_iterator (all_folders); while (!tny_iterator_is_done (iter)) { TnyFolderStore *folder = TNY_FOLDER_STORE (tny_iterator_get_current (iter)); - - recurse_folders (folder, query, all_folders); + if (folder) { + recurse_folders (folder, query, all_folders); + g_object_unref (folder); + } tny_iterator_next (iter); } g_object_unref (G_OBJECT (iter)); @@ -1180,10 +1242,12 @@ update_account_thread (gpointer thr_user_data) gint timeout = g_timeout_add (100, idle_notify_progress, info->mail_op); /* Refresh folders */ + num_new_headers = 0; new_headers = g_ptr_array_new (); iter = tny_list_create_iterator (all_folders); - while (!tny_iterator_is_done (iter) && !priv->error && !did_a_cancel) { + while (!tny_iterator_is_done (iter) && !priv->error && + priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) { InternalFolderObserver *observer; TnyFolderStore *folder = TNY_FOLDER_STORE (tny_iterator_get_current (iter)); @@ -1230,22 +1294,21 @@ update_account_thread (gpointer thr_user_data) g_object_unref (observer); observer = NULL; - g_object_unref (G_OBJECT (folder)); + if (folder) + g_object_unref (G_OBJECT (folder)); + if (priv->error) - { priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; - goto out; - } - + tny_iterator_next (iter); } - did_a_cancel = FALSE; - g_object_unref (G_OBJECT (iter)); g_source_remove (timeout); - if (new_headers->len > 0) { + if (priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED && + priv->status != MODEST_MAIL_OPERATION_STATUS_FAILED && + new_headers->len > 0) { gint msg_num = 0; /* Order by date */ @@ -1293,13 +1356,17 @@ update_account_thread (gpointer thr_user_data) msg_num++; } - g_ptr_array_foreach (new_headers, (GFunc) g_object_unref, NULL); - g_ptr_array_free (new_headers, FALSE); } + + /* Get the number of new headers and free them */ + num_new_headers = new_headers->len; + g_ptr_array_foreach (new_headers, (GFunc) g_object_unref, NULL); + g_ptr_array_free (new_headers, FALSE); + if (priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED) + goto out; + /* Perform send (if operation was not cancelled) */ - if (did_a_cancel) goto out; -/* priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND; */ priv->done = 0; priv->total = 0; if (priv->account != NULL) @@ -1308,9 +1375,7 @@ update_account_thread (gpointer thr_user_data) send_queue = modest_runtime_get_send_queue (info->transport_account); if (send_queue) { -/* timeout = g_timeout_add (250, idle_notify_progress, info->mail_op); */ modest_tny_send_queue_try_to_send (send_queue); -/* g_source_remove (timeout); */ } else { g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED, @@ -1338,8 +1403,9 @@ update_account_thread (gpointer thr_user_data) /* This thread is not in the main lock */ idle_info = g_malloc0 (sizeof (UpdateAccountInfo)); idle_info->mail_op = g_object_ref (info->mail_op); - idle_info->new_headers = (new_headers) ? new_headers->len : 0; + idle_info->new_headers = num_new_headers; idle_info->callback = info->callback; + idle_info->user_data = info->user_data; g_idle_add (idle_update_account_cb, idle_info); } @@ -1367,12 +1433,12 @@ modest_mail_operation_update_account (ModestMailOperation *self, UpdateAccountCallback callback, gpointer user_data) { - GThread *thread; - UpdateAccountInfo *info; - ModestMailOperationPrivate *priv; - ModestAccountMgr *mgr; - TnyStoreAccount *modest_account; - TnyTransportAccount *transport_account; + GThread *thread = NULL; + UpdateAccountInfo *info = NULL; + ModestMailOperationPrivate *priv = NULL; + ModestAccountMgr *mgr = NULL; + TnyStoreAccount *store_account = NULL; + TnyTransportAccount *transport_account = NULL; g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), FALSE); g_return_val_if_fail (account_name, FALSE); @@ -1385,20 +1451,20 @@ modest_mail_operation_update_account (ModestMailOperation *self, priv->done = 0; priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS; + /* Get the Modest account */ + store_account = (TnyStoreAccount *) + modest_tny_account_store_get_server_account (modest_runtime_get_account_store (), + account_name, + TNY_ACCOUNT_TYPE_STORE); + /* Make sure that we have a connection, and request one * if necessary: * TODO: Is there some way to trigger this for every attempt to * use the network? */ - if (!modest_platform_connect_and_wait (NULL)) + if (!modest_platform_connect_and_wait (NULL, TNY_ACCOUNT (store_account))) goto error; - /* Get the Modest account */ - modest_account = (TnyStoreAccount *) - modest_tny_account_store_get_server_account (modest_runtime_get_account_store (), - account_name, - TNY_ACCOUNT_TYPE_STORE); - - if (!modest_account) { + if (!store_account) { g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND, "cannot get tny store account for %s\n", account_name); @@ -1421,7 +1487,7 @@ modest_mail_operation_update_account (ModestMailOperation *self, /* Create the helper object */ info = g_slice_new (UpdateAccountInfo); info->mail_op = self; - info->account = modest_account; + info->account = store_account; info->transport_account = transport_account; info->callback = callback; info->user_data = user_data; @@ -1476,11 +1542,28 @@ modest_mail_operation_create_folder (ModestMailOperation *self, ModestMailOperationPrivate *priv; TnyFolder *new_folder = NULL; + TnyList *list = tny_simple_list_new (); + TnyFolderStoreQuery *query = tny_folder_store_query_new (); + g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), NULL); g_return_val_if_fail (name, NULL); priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self); + /* Check for already existing folder */ + tny_folder_store_query_add_item (query, name, TNY_FOLDER_STORE_QUERY_OPTION_MATCH_ON_NAME); + tny_folder_store_get_folders (parent, list, query, NULL); + g_object_unref (G_OBJECT (query)); + + if (tny_list_get_length (list) > 0) { + priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; + g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, + MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS, + _CS("ckdg_ib_folder_already_exists")); + } + + g_object_unref (G_OBJECT (list)); + /* Check parent */ if (TNY_IS_FOLDER (parent)) { /* Check folder rules */ @@ -1550,9 +1633,12 @@ modest_mail_operation_remove_folder (ModestMailOperation *self, trash_folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_TRASH); /* TODO: error_handling */ - modest_mail_operation_xfer_folder (self, folder, + if (trash_folder) { + modest_mail_operation_xfer_folder (self, folder, TNY_FOLDER_STORE (trash_folder), TRUE, NULL, NULL); + g_object_unref (trash_folder); + } } else { TnyFolderStore *parent = tny_folder_get_folder_store (folder); @@ -1592,17 +1678,25 @@ transfer_folder_status_cb (GObject *obj, priv->total = status->of_total; state = modest_mail_operation_clone_state (self); - g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); + + /* This is not a GDK lock because we are a Tinymail callback + * which is already GDK locked by Tinymail */ + + /* no gdk_threads_enter (), CHECKED */ + + g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); + + /* no gdk_threads_leave (), CHECKED */ + g_slice_free (ModestMailOperationState, state); } static void -transfer_folder_cb (TnyFolder *folder, +transfer_folder_cb (TnyFolder *folder, gboolean cancelled, TnyFolderStore *into, - gboolean cancelled, TnyFolder *new_folder, - GError **err, + GError *err, gpointer user_data) { XFerMsgAsyncHelper *helper; @@ -1615,8 +1709,8 @@ transfer_folder_cb (TnyFolder *folder, self = helper->mail_op; priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self); - if (*err) { - priv->error = g_error_copy (*err); + if (err) { + priv->error = g_error_copy (err); priv->done = 0; priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; } else if (cancelled) { @@ -1635,16 +1729,84 @@ transfer_folder_cb (TnyFolder *folder, /* If user defined callback function was defined, call it */ if (helper->user_callback) { - gdk_threads_enter (); + + /* This is not a GDK lock because we are a Tinymail callback + * which is already GDK locked by Tinymail */ + + /* no gdk_threads_enter (), CHECKED */ helper->user_callback (priv->source, helper->user_data); - gdk_threads_leave (); + /* no gdk_threads_leave () , CHECKED */ } /* Free */ g_object_unref (helper->mail_op); g_slice_free (XFerMsgAsyncHelper, helper); - g_object_unref (folder); - g_object_unref (into); +} + +/** + * + * This function checks if the new name is a valid name for our local + * folders account. The new name could not be the same than then name + * of any of the mandatory local folders + * + * We can not rely on tinymail because tinymail does not check the + * name of the virtual folders that the account could have in the case + * that we're doing a rename (because it directly calls Camel which + * knows nothing about our virtual folders). + * + * In the case of an actual copy/move (i.e. move/copy a folder between + * accounts) tinymail uses the tny_folder_store_create_account which + * is reimplemented by our ModestTnyLocalFoldersAccount that indeed + * checks the new name of the folder, so this call in that case + * wouldn't be needed. *But* NOTE that if tinymail changes its + * implementation (if folder transfers within the same account is no + * longer implemented as a rename) this call will allow Modest to work + * perfectly + * + * If the new name is not valid, this function will set the status to + * failed and will set also an error in the mail operation + */ +static gboolean +new_name_valid_if_local_account (ModestMailOperationPrivate *priv, + TnyFolderStore *into, + const gchar *new_name) +{ + if (TNY_IS_ACCOUNT (into) && + modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (into)) && + modest_tny_local_folders_account_folder_name_in_use (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (into), + new_name)) { + priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; + g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, + MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES, + _("FIXME: folder name already in use")); + return FALSE; + } else + return TRUE; +} + +/** + * This function checks if @ancestor is an acestor of @folder and + * returns TRUE in that case + */ +static gboolean +folder_is_ancestor (TnyFolder *folder, + TnyFolderStore *ancestor) +{ + TnyFolder *tmp = NULL; + gboolean found = FALSE; + + tmp = folder; + while (!found && tmp && !TNY_IS_ACCOUNT (tmp)) { + TnyFolderStore *folder_store; + + folder_store = tny_folder_get_folder_store (tmp); + if (ancestor == folder_store) + found = TRUE; + else + tmp = g_object_ref (folder_store); + g_object_unref (folder_store); + } + return found; } void @@ -1658,11 +1820,14 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self, ModestMailOperationPrivate *priv = NULL; ModestTnyFolderRules parent_rules = 0, rules; XFerMsgAsyncHelper *helper = NULL; + const gchar *folder_name = NULL; g_return_if_fail (MODEST_IS_MAIL_OPERATION (self)); g_return_if_fail (TNY_IS_FOLDER (folder)); + g_return_if_fail (TNY_IS_FOLDER_STORE (parent)); priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self); + folder_name = tny_folder_get_name (folder); /* Get account and set it into mail_operation */ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder)); @@ -1674,8 +1839,10 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self, parent_rules = modest_tny_folder_get_rules (TNY_FOLDER (parent)); /* The moveable restriction is applied also to copy operation */ - if ((!TNY_IS_FOLDER_STORE (parent)) || (rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE)) { - printf("DEBUG: %s: Not allowing the move.\n", __FUNCTION__); + if ((gpointer) parent == (gpointer) folder || + (!TNY_IS_FOLDER_STORE (parent)) || + (rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE)) { + /* Set status failed and set an error */ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, @@ -1684,8 +1851,10 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self, /* Notify the queue */ modest_mail_operation_notify_end (self); + } else if (TNY_IS_FOLDER (parent) && (parent_rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE)) { + /* Set status failed and set an error */ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, @@ -1694,11 +1863,46 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self, /* Notify the queue */ modest_mail_operation_notify_end (self); - } else { - /* Pick references for async calls */ - g_object_ref (folder); - g_object_ref (parent); + } else if (TNY_IS_FOLDER (parent) && + TNY_IS_FOLDER_STORE (folder) && + folder_is_ancestor (TNY_FOLDER (parent), TNY_FOLDER_STORE (folder))) { + /* Set status failed and set an error */ + priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; + g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, + MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES, + _("mail_in_ui_folder_copy_target_error")); + + /* Notify the queue */ + modest_mail_operation_notify_end (self); + + } else if (TNY_IS_FOLDER_STORE (parent) && + modest_tny_folder_has_subfolder_with_name (parent, folder_name)) { + /* Check that the new folder name is not used by any + parent subfolder */ + + /* Set status failed and set an error */ + priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; + g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, + MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES, + _("mail_in_ui_folder_move_target_error")); + + /* Notify the queue */ + modest_mail_operation_notify_end (self); + + } else if (!(new_name_valid_if_local_account (priv, parent, folder_name))) { + /* Check that the new folder name is not used by any + special local folder */ + + /* Set status failed and set an error */ + priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; + g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR, + MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES, + _("mail_in_ui_folder_move_target_error")); + + /* Notify the queue */ + modest_mail_operation_notify_end (self); + } else { /* Create the helper */ helper = g_slice_new0 (XFerMsgAsyncHelper); helper->mail_op = g_object_ref(self); @@ -1711,12 +1915,12 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self, tny_folder_copy_async (folder, parent, tny_folder_get_name (folder), - delete_original, + delete_original, transfer_folder_cb, transfer_folder_status_cb, helper); -/* self); */ - } + } + } void @@ -1758,31 +1962,30 @@ modest_mail_operation_rename_folder (ModestMailOperation *self, } else { TnyFolderStore *into; - ModestHeaderView *v = (ModestHeaderView *) modest_main_window_get_child_widget ( - (ModestMainWindow *)modest_window_mgr_get_main_window ( - modest_runtime_get_window_mgr ()), MODEST_WIDGET_TYPE_HEADER_VIEW); - - /* Create the helper */ - helper = g_slice_new0 (XFerMsgAsyncHelper); - helper->mail_op = g_object_ref(self); - helper->dest_folder = NULL; - helper->headers = NULL; - helper->user_callback = NULL; - helper->user_data = NULL; - - modest_header_view_clear (v); - - /* Rename. Camel handles folder subscription/unsubscription */ - into = tny_folder_get_folder_store (folder); - tny_folder_copy_async (folder, into, name, TRUE, - transfer_folder_cb, - transfer_folder_status_cb, - helper); -/* self); */ - if (into) - g_object_unref (into); + into = tny_folder_get_folder_store (folder); + + /* Check that the new folder name is not used by any + special local folder */ + if (new_name_valid_if_local_account (priv, into, name)) { + /* Create the helper */ + helper = g_slice_new0 (XFerMsgAsyncHelper); + helper->mail_op = g_object_ref(self); + helper->dest_folder = NULL; + helper->headers = NULL; + helper->user_callback = NULL; + helper->user_data = NULL; + + /* Rename. Camel handles folder subscription/unsubscription */ + tny_folder_copy_async (folder, into, name, TRUE, + transfer_folder_cb, + transfer_folder_status_cb, + helper); + } else { + modest_mail_operation_notify_end (self); + } + g_object_unref (into); } - } +} /* ******************************************************************* */ /* ************************** MSG ACTIONS ************************* */ @@ -1809,6 +2012,12 @@ void modest_mail_operation_get_msg (ModestMailOperation *self, if (folder) { /* Get account and set it into mail_operation */ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder)); + + /* Check for cached messages */ + if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED) + priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN; + else + priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE; helper = g_slice_new0 (GetMsgAsyncHelper); helper->mail_op = self; @@ -1836,104 +2045,11 @@ void modest_mail_operation_get_msg (ModestMailOperation *self, } } -static gboolean -idle_get_mime_part_size_cb (gpointer userdata) -{ - GetMimePartSizeInfo *idle_info; - - idle_info = (GetMimePartSizeInfo *) userdata; - - gdk_threads_enter (); - idle_info->callback (idle_info->mail_op, - idle_info->size, - idle_info->userdata); - gdk_threads_leave (); - - g_object_unref (idle_info->mail_op); - g_slice_free (GetMimePartSizeInfo, idle_info); - - return FALSE; -} - -static gpointer -get_mime_part_size_thread (gpointer thr_user_data) -{ - GetMimePartSizeInfo *info; - gchar read_buffer[GET_SIZE_BUFFER_SIZE]; - TnyStream *stream; - gssize readed_size; - gssize total = 0; - ModestMailOperationPrivate *priv; - - info = (GetMimePartSizeInfo *) thr_user_data; - priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op); - - stream = tny_camel_mem_stream_new (); - tny_mime_part_decode_to_stream (info->mime_part, stream); - tny_stream_reset (stream); - if (tny_stream_is_eos (stream)) { - tny_stream_close (stream); - stream = tny_mime_part_get_stream (info->mime_part); - } - - while (!tny_stream_is_eos (stream)) { - readed_size = tny_stream_read (stream, read_buffer, GET_SIZE_BUFFER_SIZE); - total += readed_size; - } - - if (info->callback) { - GetMimePartSizeInfo *idle_info; - - idle_info = g_slice_new0 (GetMimePartSizeInfo); - idle_info->mail_op = g_object_ref (info->mail_op); - idle_info->size = total; - idle_info->callback = info->callback; - idle_info->userdata = info->userdata; - g_idle_add (idle_get_mime_part_size_cb, idle_info); - } - - g_idle_add (idle_notify_queue, g_object_ref (info->mail_op)); - - g_object_unref (info->mail_op); - g_object_unref (stream); - g_object_unref (info->mime_part); - g_slice_free (GetMimePartSizeInfo, info); - - return NULL; -} - -void -modest_mail_operation_get_mime_part_size (ModestMailOperation *self, - TnyMimePart *part, - GetMimePartSizeCallback user_callback, - gpointer user_data, - GDestroyNotify notify) -{ - GetMimePartSizeInfo *info; - ModestMailOperationPrivate *priv; - GThread *thread; - - g_return_if_fail (MODEST_IS_MAIL_OPERATION (self)); - g_return_if_fail (TNY_IS_MIME_PART (part)); - - priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self); - - priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS; - info = g_slice_new0 (GetMimePartSizeInfo); - info->mail_op = g_object_ref (self); - info->mime_part = g_object_ref (part); - info->callback = user_callback; - info->userdata = user_data; - - thread = g_thread_create (get_mime_part_size_thread, info, FALSE, NULL); - -} - static void get_msg_cb (TnyFolder *folder, gboolean cancelled, TnyMsg *msg, - GError **error, + GError *error, gpointer user_data) { GetMsgAsyncHelper *helper = NULL; @@ -1947,8 +2063,8 @@ get_msg_cb (TnyFolder *folder, priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self); /* Check errors and cancel */ - if (*error) { - priv->error = g_error_copy (*error); + if (error) { + priv->error = g_error_copy (error); priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; } else if (cancelled) { priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED; @@ -1963,11 +2079,12 @@ get_msg_cb (TnyFolder *folder, /* If user defined callback function was defined, call it even if the operation failed*/ if (helper->user_callback) { - /* This callback is called into an iddle by tinymail, - and idles are not in the main lock */ - gdk_threads_enter (); + /* This is not a GDK lock because we are a Tinymail callback + * which is already GDK locked by Tinymail */ + + /* no gdk_threads_enter (), CHECKED */ helper->user_callback (self, helper->header, msg, helper->user_data); - gdk_threads_leave (); + /* no gdk_threads_leave (), CHECKED */ } /* Notify about operation end */ @@ -1998,28 +2115,20 @@ get_msg_status_cb (GObject *obj, self = helper->mail_op; priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self); - if(priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED) { - TnyFolder *folder = tny_header_get_folder (helper->header); - if (folder) { - TnyAccount *account; - account = tny_folder_get_account (folder); - if (account) { - tny_account_cancel (account); - g_object_unref (account); - } - g_object_unref (folder); - } - - return; - } - priv->done = 1; priv->total = 1; state = modest_mail_operation_clone_state (self); state->bytes_done = status->position; state->bytes_total = status->of_total; + + /* This is not a GDK lock because we are a Tinymail callback + * which is already GDK locked by Tinymail */ + + /* no gdk_threads_enter (), CHECKED */ g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); + /* no gdk_threads_leave (), CHECKED */ + g_slice_free (ModestMailOperationState, state); } @@ -2052,11 +2161,12 @@ notify_get_msgs_full (gpointer data) info = (NotifyGetMsgsInfo *) data; - /* Call the user callback. Idles are not in the main lock, so - lock it */ - gdk_threads_enter (); + /* This is a GDK lock because we are an idle callback and + * because info->user_callback can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED */ info->user_callback (info->mail_op, info->header, info->msg, info->user_data); - gdk_threads_leave (); + gdk_threads_leave (); /* CHECKED */ g_slice_free (NotifyGetMsgsInfo, info); @@ -2075,9 +2185,13 @@ get_msgs_full_destroyer (gpointer data) info = (GetFullMsgsInfo *) data; if (info->notify) { - gdk_threads_enter (); + + /* This is a GDK lock because we are an idle callback and + * because info->notify can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED */ info->notify (info->user_data); - gdk_threads_leave (); + gdk_threads_leave (); /* CHECKED */ } /* free */ @@ -2105,6 +2219,12 @@ get_msgs_full_thread (gpointer thr_user_data) header = TNY_HEADER (tny_iterator_get_current (iter)); folder = tny_header_get_folder (header); + /* Check for cached messages */ + if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED) + priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN; + else + priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE; + /* Get message from folder */ if (folder) { TnyMsg *msg; @@ -2146,7 +2266,10 @@ get_msgs_full_thread (gpointer thr_user_data) MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND, "Error trying to get a message. No folder found for header"); } - g_object_unref (header); + + if (header) + g_object_unref (header); + tny_iterator_next (iter); } @@ -2191,10 +2314,16 @@ modest_mail_operation_get_msgs_full (ModestMailOperation *self, if (tny_list_get_length (header_list) >= 1) { iter = tny_list_create_iterator (header_list); header = TNY_HEADER (tny_iterator_get_current (iter)); - folder = tny_header_get_folder (header); - priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder)); - g_object_unref (header); - g_object_unref (folder); + if (header) { + folder = tny_header_get_folder (header); + if (folder) { + priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder)); + + g_object_unref (folder); + } + + g_object_unref (header); + } if (tny_list_get_length (header_list) == 1) { g_object_unref (iter); @@ -2218,9 +2347,12 @@ modest_mail_operation_get_msgs_full (ModestMailOperation *self, if (iter != NULL) { while (!tny_iterator_is_done (iter) && size_ok) { header = TNY_HEADER (tny_iterator_get_current (iter)); - if (tny_header_get_message_size (header) >= max_size) - size_ok = FALSE; - g_object_unref (header); + if (header) { + if (tny_header_get_message_size (header) >= max_size) + size_ok = FALSE; + g_object_unref (header); + } + tny_iterator_next (iter); } g_object_unref (iter); @@ -2272,20 +2404,23 @@ modest_mail_operation_remove_msg (ModestMailOperation *self, TnyHeader *header, priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS; - + /* remove message from folder */ tny_folder_remove_msg (folder, header, &(priv->error)); - if (!priv->error) { - tny_header_set_flags (header, TNY_HEADER_FLAG_DELETED); - tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN); - - if (TNY_IS_CAMEL_IMAP_FOLDER (folder)) - tny_folder_sync(folder, FALSE, &(priv->error)); /* FALSE --> don't expunge */ - else if (TNY_IS_CAMEL_POP_FOLDER (folder)) - tny_folder_sync(folder, TRUE, &(priv->error)); /* TRUE --> expunge */ - else - /* lcoal folders */ - tny_folder_sync(folder, TRUE, &(priv->error)); /* TRUE --> expunge */ - } +/* if (!priv->error) { */ +/* tny_header_set_flags (header, TNY_HEADER_FLAG_DELETED); */ +/* tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN); */ + +/* if (TNY_IS_CAMEL_IMAP_FOLDER (folder)) */ +/* tny_folder_sync_async(folder, FALSE, NULL, NULL, NULL); /\* FALSE --> don't expunge *\/ */ +/* /\* tny_folder_sync (folder, FALSE, &(priv->error)); /\\* FALSE --> don't expunge *\\/ *\/ */ +/* else if (TNY_IS_CAMEL_POP_FOLDER (folder)) */ +/* tny_folder_sync_async(folder, FALSE, NULL, NULL, NULL); /\* TRUE --> dont expunge *\/ */ +/* /\* tny_folder_sync (folder, TRUE, &(priv->error)); /\\* TRUE --> expunge *\\/ *\/ */ +/* else */ +/* /\* local folders *\/ */ +/* tny_folder_sync_async(folder, TRUE, NULL, NULL, NULL); /\* TRUE --> expunge *\/ */ +/* /\* tny_folder_sync (folder, TRUE, &(priv->error)); /\\* TRUE --> expunge *\\/ *\/ */ +/* } */ /* Set status */ @@ -2325,25 +2460,36 @@ transfer_msgs_status_cb (GObject *obj, priv->total = status->of_total; state = modest_mail_operation_clone_state (self); + + /* This is not a GDK lock because we are a Tinymail callback and + * Tinymail already acquires the Gdk lock */ + + /* no gdk_threads_enter (), CHECKED */ + g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); + + /* no gdk_threads_leave (), CHECKED */ + g_slice_free (ModestMailOperationState, state); } static void -transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError **err, gpointer user_data) +transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError *err, gpointer user_data) { XFerMsgAsyncHelper *helper; ModestMailOperation *self; ModestMailOperationPrivate *priv; + TnyIterator *iter = NULL; + TnyHeader *header = NULL; helper = (XFerMsgAsyncHelper *) user_data; self = helper->mail_op; priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self); - if (*err) { - priv->error = g_error_copy (*err); + if (err) { + priv->error = g_error_copy (err); priv->done = 0; priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; } else if (cancelled) { @@ -2357,22 +2503,48 @@ transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError **err, gpointer priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS; } + + /* Mark headers as deleted and seen */ + if ((helper->delete) && + (priv->status == MODEST_MAIL_OPERATION_STATUS_SUCCESS)) { + iter = tny_list_create_iterator (helper->headers); + while (!tny_iterator_is_done (iter)) { + header = TNY_HEADER (tny_iterator_get_current (iter)); + tny_header_set_flags (header, TNY_HEADER_FLAG_DELETED); + tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN); + g_object_unref (header); + + tny_iterator_next (iter); + } + + } + + /* Notify about operation end */ modest_mail_operation_notify_end (self); /* If user defined callback function was defined, call it */ if (helper->user_callback) { - gdk_threads_enter (); + /* This is not a GDK lock because we are a Tinymail callback and + * Tinymail already acquires the Gdk lock */ + + /* no gdk_threads_enter (), CHECKED */ helper->user_callback (priv->source, helper->user_data); - gdk_threads_leave (); + /* no gdk_threads_leave (), CHECKED */ } /* Free */ - g_object_unref (helper->headers); - g_object_unref (helper->dest_folder); - g_object_unref (helper->mail_op); + if (helper->headers) + g_object_unref (helper->headers); + if (helper->dest_folder) + g_object_unref (helper->dest_folder); + if (helper->mail_op) + g_object_unref (helper->mail_op); + if (folder) + g_object_unref (folder); + if (iter) + g_object_unref (iter); g_slice_free (XFerMsgAsyncHelper, helper); - g_object_unref (folder); } @@ -2384,12 +2556,12 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self, XferMsgsAsynUserCallback user_callback, gpointer user_data) { - ModestMailOperationPrivate *priv; - TnyIterator *iter; - TnyFolder *src_folder; - XFerMsgAsyncHelper *helper; - TnyHeader *header; - ModestTnyFolderRules rules; + ModestMailOperationPrivate *priv = NULL; + TnyIterator *iter = NULL; + TnyFolder *src_folder = NULL; + XFerMsgAsyncHelper *helper = NULL; + TnyHeader *header = NULL; + ModestTnyFolderRules rules = 0; const gchar *id1 = NULL; const gchar *id2 = NULL; gboolean same_folder = FALSE; @@ -2419,8 +2591,11 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self, /* Get source folder */ iter = tny_list_create_iterator (headers); header = TNY_HEADER (tny_iterator_get_current (iter)); - src_folder = tny_header_get_folder (header); - g_object_unref (header); + if (header) { + src_folder = tny_header_get_folder (header); + g_object_unref (header); + } + g_object_unref (iter); /* Check folder source and destination */ @@ -2449,6 +2624,7 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self, helper->headers = g_object_ref(headers); helper->user_callback = user_callback; helper->user_data = user_data; + helper->delete = delete_original; /* Get account and set it into mail_operation */ priv->account = modest_tny_folder_get_account (src_folder); @@ -2467,7 +2643,7 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self, static void on_refresh_folder (TnyFolder *folder, gboolean cancelled, - GError **error, + GError *error, gpointer user_data) { RefreshAsyncHelper *helper = NULL; @@ -2478,9 +2654,13 @@ on_refresh_folder (TnyFolder *folder, self = helper->mail_op; priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self); - if (*error) { - priv->error = g_error_copy (*error); + g_return_if_fail(priv!=NULL); + + if (error) { + priv->error = g_error_copy (error); priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED; + printf("DEBUG: %s: Operation error:\n %s", __FUNCTION__, + error->message); goto out; } @@ -2490,25 +2670,30 @@ on_refresh_folder (TnyFolder *folder, MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND, _("Error trying to refresh the contents of %s"), tny_folder_get_name (folder)); + printf("DEBUG: %s: Operation cancelled.\n", __FUNCTION__); goto out; } priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS; - out: + /* Call user defined callback, if it exists */ if (helper->user_callback) { - gdk_threads_enter (); + + /* This is not a GDK lock because we are a Tinymail callback and + * Tinymail already acquires the Gdk lock */ + + /* no gdk_threads_enter (), CHECKED */ helper->user_callback (self, folder, helper->user_data); - gdk_threads_leave (); + /* no gdk_threads_leave (), CHECKED */ } + out: /* Free */ - g_object_unref (helper->mail_op); g_slice_free (RefreshAsyncHelper, helper); - g_object_unref (folder); /* Notify about operation end */ modest_mail_operation_notify_end (self); + g_object_unref(self); } static void @@ -2535,7 +2720,16 @@ on_refresh_folder_status_update (GObject *obj, priv->total = status->of_total; state = modest_mail_operation_clone_state (self); + + /* This is not a GDK lock because we are a Tinymail callback and + * Tinymail already acquires the Gdk lock */ + + /* no gdk_threads_enter (), CHECKED */ + g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); + + /* no gdk_threads_leave (), CHECKED */ + g_slice_free (ModestMailOperationState, state); } @@ -2550,9 +2744,6 @@ modest_mail_operation_refresh_folder (ModestMailOperation *self, priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self); - /* Pick a reference */ - g_object_ref (folder); - priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS; /* Get account and set it into mail_operation */ @@ -2599,7 +2790,9 @@ modest_mail_operation_notify_end (ModestMailOperation *self) priv->account_name = NULL; } - /* Notify the observers about the mail opertation end */ + /* Notify the observers about the mail operation end */ + /* We do not wrapp this emission because we assume that this + function is always called from within the main lock */ state = modest_mail_operation_clone_state (self); g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); g_slice_free (ModestMailOperationState, state);