Work to fix bug NB#81989:
[modest] / src / modest-mail-operation.c
index d9e31bc..7c522bc 100644 (file)
@@ -57,6 +57,9 @@
 #include "modest-marshal.h"
 #include "modest-error.h"
 #include "modest-mail-operation.h"
+#include <modest-count-stream.h>
+#include <libgnomevfs/gnome-vfs.h>
+#include "modest-utils.h"
 
 #define KB 1024
 
@@ -132,6 +135,7 @@ struct _ModestMailOperationPrivate {
 typedef struct {
        GetMsgAsyncUserCallback user_callback;
        TnyHeader *header;
+       TnyIterator *more_msgs;
        gpointer user_data;
        ModestMailOperation *mail_op;
        GDestroyNotify destroy_notify;
@@ -140,38 +144,32 @@ typedef struct {
        gint total_bytes;
 } GetMsgInfo;
 
-typedef struct {
-       ModestMailOperation *mail_op;
-       TnyMsg *msg;
-       gulong msg_sent_handler;
-       gulong error_happened_handler;
-} SendMsgInfo;
-
-static void     send_mail_msg_sent_handler (TnySendQueue *queue, TnyHeader *header, TnyMsg *msg,
-                                           guint nth, guint total, gpointer userdata);
-static void     send_mail_error_happened_handler (TnySendQueue *queue, TnyHeader *header, TnyMsg *msg,
-                                                 GError *error, gpointer userdata);
-static void     common_send_mail_operation_end (TnySendQueue *queue, TnyMsg *msg, 
-                                               SendMsgInfo *info);
-
 typedef struct _RefreshAsyncHelper {   
        ModestMailOperation *mail_op;
        RefreshAsyncUserCallback user_callback; 
        gpointer user_data;
 } RefreshAsyncHelper;
 
-typedef struct _XFerMsgAsyncHelper
+typedef struct _XFerMsgsAsyncHelper
 {
        ModestMailOperation *mail_op;
        TnyList *headers;
+       TnyIterator *more_msgs;
        TnyFolder *dest_folder;
-       XferAsyncUserCallback user_callback;    
+       XferMsgsAsyncUserCallback user_callback;        
        gboolean delete;
        gpointer user_data;
        gint last_total_bytes;
        gint sum_total_bytes;
        gint total_bytes;
-} XFerMsgAsyncHelper;
+} XFerMsgsAsyncHelper;
+
+typedef struct _XFerFolderAsyncHelper
+{
+       ModestMailOperation *mail_op;
+       XferFolderAsyncUserCallback user_callback;      
+       gpointer user_data;
+} XFerFolderAsyncHelper;
 
 typedef void (*ModestMailOperationCreateMsgCallback) (ModestMailOperation *mail_op,
                                                      TnyMsg *msg,
@@ -491,29 +489,21 @@ modest_mail_operation_cancel (ModestMailOperation *self)
 
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 
-       /* 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;
        
-       /* Cancel the mail operation. We need to wrap it between this
-          start/stop operations to allow following calls to the
-          account */
+       /* Cancel the mail operation */
        g_return_val_if_fail (priv->account, FALSE);
+       tny_account_cancel (priv->account);
 
        if (priv->op_type == MODEST_MAIL_OPERATION_TYPE_SEND) {
                ModestTnySendQueue *queue;
                queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (priv->account));
-               /* Cancel sending without removing the item */
-               tny_send_queue_cancel (TNY_SEND_QUEUE (queue), FALSE, NULL);
-       } else {
-               /* Cancel operation */
-               tny_account_cancel (priv->account);
-       }
 
+               /* Cancel the sending of the following next messages */
+               tny_send_queue_cancel (TNY_SEND_QUEUE (queue), TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, NULL);
+       }
+       
        return canceled;
 }
 
@@ -610,7 +600,6 @@ modest_mail_operation_send_mail (ModestMailOperation *self,
 {
        TnySendQueue *send_queue = NULL;
        ModestMailOperationPrivate *priv;
-       SendMsgInfo *info;
        
        g_return_if_fail (self && MODEST_IS_MAIL_OPERATION (self));
        g_return_if_fail (transport_account && TNY_IS_TRANSPORT_ACCOUNT (transport_account));
@@ -635,88 +624,14 @@ modest_mail_operation_send_mail (ModestMailOperation *self,
        } else {
                /* Add the msg to the queue */
                modest_mail_operation_notify_start (self);
-               modest_tny_send_queue_add (MODEST_TNY_SEND_QUEUE(send_queue), 
-                                          msg, 
-                                          &(priv->error));
-
-               priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
-
-               info = g_slice_new0 (SendMsgInfo);
-
-               info->mail_op = g_object_ref (self);
-               info->msg = g_object_ref (msg);
-               info->msg_sent_handler = g_signal_connect (G_OBJECT (send_queue), "msg-sent",
-                                                          G_CALLBACK (send_mail_msg_sent_handler), info);
-               info->error_happened_handler = g_signal_connect (G_OBJECT (send_queue), "error-happened",
-                                                                G_CALLBACK (send_mail_error_happened_handler), info);
-       }
-
-}
-
-static void
-common_send_mail_operation_end (TnySendQueue *queue, TnyMsg *msg,
-                               SendMsgInfo *info)
-{
-       g_signal_handler_disconnect (queue, info->msg_sent_handler);
-       g_signal_handler_disconnect (queue, info->error_happened_handler);
 
-       g_object_unref (info->msg);
-       modest_mail_operation_notify_end (info->mail_op);
-       g_object_unref (info->mail_op);
+               tny_send_queue_add_async (send_queue, msg, NULL, NULL, NULL);
+               modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue), FALSE);
 
-       g_slice_free (SendMsgInfo, info);
-}
-
-static void     
-send_mail_msg_sent_handler (TnySendQueue *queue, TnyHeader *header, TnyMsg *msg,
-                           guint nth, guint total, gpointer userdata)
-{
-       SendMsgInfo *info = (SendMsgInfo *) userdata;
-       TnyHeader *hdr1, *hdr2;
-       const char *msgid1, *msgid2;
-       hdr1 = tny_msg_get_header(msg);
-       hdr2 = tny_msg_get_header(info->msg);
-       msgid1 = tny_header_get_message_id(hdr1);
-       msgid2 = tny_header_get_message_id(hdr2);
-       if (msgid1 == NULL) msgid1 = "(null)";
-       if (msgid2 == NULL) msgid2 = "(null)";
-
-       if (!strcmp (msgid1, msgid2)) {
-               ModestMailOperationPrivate *priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
                priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
-
-               common_send_mail_operation_end (queue, msg, info);
+               modest_mail_operation_notify_end (self);
        }
-       g_object_unref(G_OBJECT(hdr1));
-       g_object_unref(G_OBJECT(hdr2));
-}
 
-static void     
-send_mail_error_happened_handler (TnySendQueue *queue, TnyHeader *header, TnyMsg *msg,
-                                 GError *error, gpointer userdata)
-{
-       SendMsgInfo *info = (SendMsgInfo *) userdata;
-       TnyHeader *hdr1, *hdr2;
-       const char *msgid1, *msgid2;
-       
-       hdr1 = tny_msg_get_header(msg);
-       hdr2 = tny_msg_get_header(info->msg);
-       msgid1 = tny_header_get_message_id(hdr1);
-       msgid2 = tny_header_get_message_id(hdr2);
-       if (msgid1 == NULL) msgid1 = "(null)";
-       if (msgid2 == NULL) msgid2 = "(null)";
-
-       if (!strcmp (msgid1, msgid2)) {
-               ModestMailOperationPrivate *priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
-               priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
-               g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
-                            MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
-                            "modest: send mail failed\n");
-
-               common_send_mail_operation_end (queue, msg, info);
-       }
-       g_object_unref(G_OBJECT(hdr1));
-       g_object_unref(G_OBJECT(hdr2));
 }
 
 
@@ -805,9 +720,11 @@ create_msg_thread (gpointer thread_data)
 
        g_object_unref (info->mail_op);
        g_slice_free (CreateMsgInfo, info);
+       if (new_msg) g_object_unref(new_msg);
        return NULL;
 }
 
+
 void
 modest_mail_operation_create_msg (ModestMailOperation *self,
                                  const gchar *from, const gchar *to,
@@ -855,28 +772,59 @@ modest_mail_operation_send_new_mail_cb (ModestMailOperation *self,
                                        TnyMsg *msg,
                                        gpointer userdata)
 {
+       ModestMailOperationPrivate *priv = NULL;
        SendNewMailInfo *info = (SendNewMailInfo *) userdata;
        TnyFolder *draft_folder = NULL;
        TnyFolder *outbox_folder = NULL;
-       TnyHeader *header;
+       TnyHeader *header = NULL;
        GError *err = NULL;
 
        if (!msg) {
                goto end;
        }
 
+       priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+       if (priv->error) {
+               priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+               modest_mail_operation_notify_end (self);
+               goto end;
+       }
+
        /* Call mail operation */
        modest_mail_operation_send_mail (self, info->transport_account, msg);
 
-       /* 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;              
+               TnyTransportAccount *transport_account = NULL;
+
+               /* To remove the old mail from its source folder, we need to get the
+                * transport account of the original draft message (the transport account
+                * might have been changed by the user) */
+               header = tny_msg_get_header (info->draft_msg);
+               transport_account = modest_tny_account_store_get_transport_account_from_outbox_header(
+                       modest_runtime_get_account_store(), header);
+               if (transport_account == NULL)
+                       transport_account = g_object_ref(info->transport_account);
+               draft_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account),
+                                                                     TNY_FOLDER_TYPE_DRAFTS);
+               outbox_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account),
+                                                                      TNY_FOLDER_TYPE_OUTBOX);
+               g_object_unref(transport_account);
+
+               if (!draft_folder) {
+                       g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL drafts folder",
+                                  __FUNCTION__);
+                       goto end;
+               }
+               if (!outbox_folder) {
+                       g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL outbox folder",
+                                  __FUNCTION__);
+                       goto end;
+               }
+
                folder = tny_msg_get_folder (info->draft_msg);          
                if (folder == NULL) goto end;
                folder_type = modest_tny_folder_guess_folder_type (folder);
@@ -891,17 +839,17 @@ modest_mail_operation_send_new_mail_cb (ModestMailOperation *self,
 
                /* 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_folder_sync (folder, TRUE, &err); /* FALSE --> don't expunge */
 /*             tny_folder_sync_async (src_folder, TRUE, NULL, NULL, NULL);  /\* expunge *\/ */
                
-               g_object_unref (header);
                g_object_unref (folder);
        }
 
 end:
+       if (header)
+               g_object_unref (header);
        if (err != NULL)
                g_error_free(err);      
        if (info->draft_msg)
@@ -1024,10 +972,10 @@ modest_mail_operation_save_to_drafts_add_msg_cb(TnyFolder *self,
                g_object_unref (G_OBJECT(info->drafts));
        if (info->msg)
                g_object_unref (G_OBJECT (info->msg));
-       g_slice_free (SaveToDraftsAddMsgInfo, info);
 
        modest_mail_operation_notify_end (info->mailop);
        g_object_unref(info->mailop);
+       g_slice_free (SaveToDraftsAddMsgInfo, info);
 }
 
 typedef struct
@@ -1050,13 +998,15 @@ modest_mail_operation_save_to_drafts_cb (ModestMailOperation *self,
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 
        if (!msg) {
-               g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
-                            MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
-                            "modest: failed to create a new msg\n");
+               if (!(priv->error)) {
+                       g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+                                    MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
+                                    "modest: failed to create a new msg\n");
+               }
        } else {
                drafts = modest_tny_account_get_special_folder (TNY_ACCOUNT (info->transport_account),
                                                                TNY_FOLDER_TYPE_DRAFTS);
-               if (!drafts) {
+               if (!drafts && !(priv->error)) {
                        g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
                                     MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
                                     "modest: failed to create a new msg\n");
@@ -1208,7 +1158,7 @@ internal_folder_observer_finalize (GObject *object)
 static void
 tny_folder_observer_init (TnyFolderObserverIface *iface) 
 {
-       iface->update_func = internal_folder_observer_update;
+       iface->update = internal_folder_observer_update;
 }
 static void
 internal_folder_observer_class_init (InternalFolderObserverClass *klass) 
@@ -1230,19 +1180,14 @@ typedef struct
        gint pending_calls;
        gboolean poke_all;
        TnyFolderObserver *inbox_observer;
-       guint update_timeout;
        RetrieveAllCallback retrieve_all_cb;
+       gboolean interactive;
 } UpdateAccountInfo;
 
 
 static void
 destroy_update_account_info (UpdateAccountInfo *info)
 {
-       if (info->update_timeout) {
-               g_source_remove (info->update_timeout);
-               info->update_timeout = 0;
-       }
-
        g_free (info->account_name);
        g_object_unref (info->folders);
        g_object_unref (info->mail_op);
@@ -1265,7 +1210,6 @@ update_account_get_msg_async_cb (TnyFolder *folder,
        g_slice_free (GetMsgInfo, msg_info);
 }
 
-
 static void
 inbox_refreshed_cb (TnyFolder *inbox, 
                    gboolean canceled, 
@@ -1280,9 +1224,8 @@ inbox_refreshed_cb (TnyFolder *inbox,
        ModestAccountMgr *mgr;
        ModestAccountRetrieveType retrieve_type;
        TnyList *new_headers = NULL;
-       gboolean headers_only, ignore_limit;
-       TnyTransportAccount *transport_account;
-       ModestTnySendQueue *send_queue;
+       gboolean headers_only, ignore_limit, succeeded;
+       TnyTransportAccount *transport_account = NULL;
 
        info = (UpdateAccountInfo *) user_data;
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
@@ -1323,6 +1266,8 @@ inbox_refreshed_cb (TnyFolder *inbox,
 
        /* Update the last updated key, even if we don't have to get new headers */
        modest_account_mgr_set_last_updated (mgr, tny_account_get_id (priv->account), time (NULL));
+       if (!canceled && !err) 
+               modest_account_mgr_set_server_account_username_has_succeeded (mgr, tny_account_get_id (priv->account), TRUE);
        
        if (new_headers_array->len == 0)
                goto send_mail;
@@ -1333,7 +1278,7 @@ inbox_refreshed_cb (TnyFolder *inbox,
                retrieve_limit = G_MAXINT;
        
        /* Get per-account retrieval type */
-       retrieve_type = modest_account_mgr_get_retrieve_type (mgr, info->account_name); 
+       retrieve_type = modest_account_mgr_get_retrieve_type (mgr, info->account_name);
        headers_only = (retrieve_type == MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY);
 
        /* Order by date */
@@ -1392,19 +1337,47 @@ inbox_refreshed_cb (TnyFolder *inbox,
        g_ptr_array_foreach (new_headers_array, (GFunc) g_object_unref, NULL);
        g_ptr_array_free (new_headers_array, FALSE);
 
+       if (priv->error)
+               succeeded = FALSE;
+       else
+               succeeded = TRUE;
+       modest_account_mgr_set_server_account_username_has_succeeded (modest_runtime_get_account_mgr (), 
+                                                                     tny_account_get_name (priv->account), 
+                                                                     succeeded);
  send_mail:
-       /* Send mails */
-       priv->done = 0;
-       priv->total = 0;
-
        /* Get the transport account */
        transport_account = (TnyTransportAccount *)
                modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
                                                                                    info->account_name);
-       
-       /* Try to send */
-       send_queue = modest_runtime_get_send_queue (transport_account);
-       modest_tny_send_queue_try_to_send (send_queue);
+
+       if (transport_account) {
+               ModestTnySendQueue *send_queue;
+               TnyFolder *outbox;
+               guint num_messages;
+
+               send_queue = modest_runtime_get_send_queue (transport_account);
+               g_object_unref (transport_account);
+
+               /* Get outbox folder */
+               outbox = tny_send_queue_get_outbox (TNY_SEND_QUEUE (send_queue));
+               if (outbox) { /* this could fail in some cases */
+                       num_messages = tny_folder_get_all_count (outbox);
+                       g_object_unref (outbox);
+               } else {
+                       g_warning ("%s: could not get outbox", __FUNCTION__);
+                       num_messages = 0;
+               }
+               
+               if (num_messages != 0) {
+                       /* Reenable suspended items */
+                       modest_tny_send_queue_wakeup (MODEST_TNY_SEND_QUEUE (send_queue));
+
+                       /* Try to send */
+                       tny_camel_send_queue_flush (TNY_CAMEL_SEND_QUEUE (send_queue));
+                       modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue), 
+                                                                         info->interactive);
+               }
+       }
 
        /* Check if the operation was a success */
        if (!priv->error)
@@ -1441,7 +1414,8 @@ recurse_folders_async_cb (TnyFolderStore *folder_store,
 
        if (err || canceled) {
                /* Try to continue anyway */
-       } else {
+       } else if (info->poke_all) {
+               /* We're not getting INBOX children if we don't want to poke all */
                TnyIterator *iter = tny_list_create_iterator (list);
                while (!tny_iterator_is_done (iter)) {
                        TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter);
@@ -1453,8 +1427,9 @@ recurse_folders_async_cb (TnyFolderStore *folder_store,
                        /* Add pending call */
                        info->pending_calls++;
                        
-                       tny_folder_store_get_folders_async (folder, folders, recurse_folders_async_cb, 
-                                                           NULL, NULL, info);
+                       tny_folder_store_get_folders_async (folder, folders, NULL,
+                                                           recurse_folders_async_cb, 
+                                                           NULL, info);
                        
                        g_object_unref (G_OBJECT (folder));
                        
@@ -1496,10 +1471,6 @@ recurse_folders_async_cb (TnyFolderStore *folder_store,
                }
                g_object_unref (iter_all_folders);
 
-               /* Stop the progress notification */
-               g_source_remove (info->update_timeout);
-               info->update_timeout = 0;
-
                /* Refresh the INBOX */
                if (inbox) {
                        /* Refresh the folder. Our observer receives
@@ -1520,34 +1491,11 @@ recurse_folders_async_cb (TnyFolderStore *folder_store,
        }
 }
 
-/* 
- * Issues the "progress-changed" signal. The timer won't be removed,
- * so you must call g_source_remove to stop the signal emission
- */
-static gboolean
-timeout_notify_progress (gpointer data)
-{
-       ModestMailOperation *mail_op = MODEST_MAIL_OPERATION (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;
-}
-
 void
 modest_mail_operation_update_account (ModestMailOperation *self,
                                      const gchar *account_name,
                                      gboolean poke_all,
+                                     gboolean interactive,
                                      RetrieveAllCallback retrieve_all_cb,
                                      UpdateAccountCallback callback,
                                      gpointer user_data)
@@ -1555,23 +1503,40 @@ modest_mail_operation_update_account (ModestMailOperation *self,
        UpdateAccountInfo *info = NULL;
        ModestMailOperationPrivate *priv = NULL;
        ModestTnyAccountStore *account_store = NULL;
-       TnyStoreAccount *store_account = NULL;
        TnyList *folders;
+       ModestMailOperationState *state;
 
        /* Init mail operation */
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
        priv->total = 0;
        priv->done  = 0;
        priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
-       priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
+       priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND_AND_RECEIVE;
 
        /* Get the store account */
        account_store = modest_runtime_get_account_store ();
-       store_account = (TnyStoreAccount *)
+       priv->account =
                modest_tny_account_store_get_server_account (account_store,
                                                             account_name,
                                                             TNY_ACCOUNT_TYPE_STORE);
-       priv->account = g_object_ref (store_account);
+
+       /* The above function could return NULL */
+       if (!priv->account) {
+               /* Check if the operation was a success */
+               g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+                            MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
+                            "no account");
+               priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+
+               /* Call the user callback */
+               if (callback)
+                       callback (self, NULL, user_data);
+
+               /* Notify about operation end */
+               modest_mail_operation_notify_end (self);
+
+               return;
+       }
 
        /* Create the helper object */
        info = g_slice_new0 (UpdateAccountInfo);
@@ -1579,21 +1544,31 @@ modest_mail_operation_update_account (ModestMailOperation *self,
        info->folders = tny_simple_list_new ();
        info->mail_op = g_object_ref (self);
        info->poke_all = poke_all;
+       info->interactive = interactive;
        info->account_name = g_strdup (account_name);
        info->callback = callback;
        info->user_data = user_data;
-       info->update_timeout = g_timeout_add (250, timeout_notify_progress, self);
        info->retrieve_all_cb = retrieve_all_cb;
 
        /* Set account busy */
        modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), account_name, TRUE);
        modest_mail_operation_notify_start (self);
 
-       /* Get all folders and continue in the callback */    
+       /* notify about the start of the operation */ 
+       state = modest_mail_operation_clone_state (self);
+       state->done = 0;
+       state->total = 0;
+
+       /* Start notifying progress */
+       g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
+       g_slice_free (ModestMailOperationState, state);
+       
+       /* Get all folders and continue in the callback */ 
        folders = tny_simple_list_new ();
-       tny_folder_store_get_folders_async (TNY_FOLDER_STORE (store_account),
-                               folders, recurse_folders_async_cb, 
-                               NULL, NULL, info);
+       tny_folder_store_get_folders_async (TNY_FOLDER_STORE (priv->account),
+                                           folders, NULL,
+                                           recurse_folders_async_cb, 
+                                           NULL, info);
 }
 
 /*
@@ -1757,7 +1732,6 @@ modest_mail_operation_remove_folder (ModestMailOperation *self,
                                     TnyFolder           *folder,
                                     gboolean             remove_to_trash)
 {
-       TnyAccount *account;
        ModestMailOperationPrivate *priv;
        ModestTnyFolderRules rules;
 
@@ -1778,14 +1752,13 @@ modest_mail_operation_remove_folder (ModestMailOperation *self,
        }
 
        /* Get the account */
-       account = modest_tny_folder_get_account (folder);
-       priv->account = g_object_ref(account);
+       priv->account = modest_tny_folder_get_account (folder);
        priv->op_type = MODEST_MAIL_OPERATION_TYPE_DELETE;
 
        /* Delete folder or move to trash */
        if (remove_to_trash) {
                TnyFolder *trash_folder = NULL;
-               trash_folder = modest_tny_account_get_special_folder (account,
+               trash_folder = modest_tny_account_get_special_folder (priv->account,
                                                                      TNY_FOLDER_TYPE_TRASH);
                /* TODO: error_handling */
                if (trash_folder) {
@@ -1794,6 +1767,8 @@ modest_mail_operation_remove_folder (ModestMailOperation *self,
                                                    TNY_FOLDER_STORE (trash_folder), 
                                                    TRUE, NULL, NULL);
                        g_object_unref (trash_folder);
+               } else {
+                       g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL trash folder", __FUNCTION__);
                }
        } else {
                TnyFolderStore *parent = tny_folder_get_folder_store (folder);
@@ -1809,7 +1784,6 @@ modest_mail_operation_remove_folder (ModestMailOperation *self,
                } else
                        g_warning ("%s: could not get parent folder", __FUNCTION__);
        }
-       g_object_unref (G_OBJECT (account));
 
  end:
        /* Notify about operation end */
@@ -1824,12 +1798,12 @@ transfer_folder_status_cb (GObject *obj,
        ModestMailOperation *self;
        ModestMailOperationPrivate *priv;
        ModestMailOperationState *state;
-       XFerMsgAsyncHelper *helper;
+       XFerFolderAsyncHelper *helper;
 
        g_return_if_fail (status != NULL);
        g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_COPY_FOLDER);
 
-       helper = (XFerMsgAsyncHelper *) user_data;
+       helper = (XFerFolderAsyncHelper *) user_data;
        g_return_if_fail (helper != NULL);
 
        self = helper->mail_op;
@@ -1861,11 +1835,11 @@ transfer_folder_cb (TnyFolder *folder,
                    GError *err, 
                    gpointer user_data)
 {
-       XFerMsgAsyncHelper *helper;
+       XFerFolderAsyncHelper *helper;
        ModestMailOperation *self = NULL;
        ModestMailOperationPrivate *priv = NULL;
 
-       helper = (XFerMsgAsyncHelper *) user_data;
+       helper = (XFerFolderAsyncHelper *) user_data;
        g_return_if_fail (helper != NULL);       
 
        self = helper->mail_op;
@@ -1896,13 +1870,13 @@ transfer_folder_cb (TnyFolder *folder,
                 * which is already GDK locked by Tinymail */
 
                /* no gdk_threads_enter (), CHECKED */
-               helper->user_callback (self, helper->user_data);
+               helper->user_callback (self, new_folder, helper->user_data);
                /* no gdk_threads_leave () , CHECKED */
        }
 
        /* Free */
        g_object_unref (helper->mail_op);
-       g_slice_free   (XFerMsgAsyncHelper, helper);
+       g_slice_free   (XFerFolderAsyncHelper, helper);
 }
 
 /**
@@ -1951,12 +1925,12 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self,
                                   TnyFolder *folder,
                                   TnyFolderStore *parent,
                                   gboolean delete_original,
-                                  XferAsyncUserCallback user_callback,
+                                  XferFolderAsyncUserCallback user_callback,
                                   gpointer user_data)
 {
        ModestMailOperationPrivate *priv = NULL;
        ModestTnyFolderRules parent_rules = 0, rules; 
-       XFerMsgAsyncHelper *helper = NULL;
+       XFerFolderAsyncHelper *helper = NULL;
        const gchar *folder_name = NULL;
        const gchar *error_msg;
 
@@ -2008,10 +1982,8 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self,
                goto error;
        } else {
                /* Create the helper */
-               helper = g_slice_new0 (XFerMsgAsyncHelper);
+               helper = g_slice_new0 (XFerFolderAsyncHelper);
                helper->mail_op = g_object_ref (self);
-               helper->dest_folder = NULL;
-               helper->headers = NULL;
                helper->user_callback = user_callback;
                helper->user_data = user_data;
                
@@ -2036,7 +2008,7 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self,
 
        /* Call the user callback if exists */
        if (user_callback)
-               user_callback (self, user_data);
+               user_callback (self, NULL, user_data);
 
        /* Notify the queue */
        modest_mail_operation_notify_end (self);
@@ -2045,11 +2017,13 @@ modest_mail_operation_xfer_folder (ModestMailOperation *self,
 void
 modest_mail_operation_rename_folder (ModestMailOperation *self,
                                     TnyFolder *folder,
-                                    const gchar *name)
+                                    const gchar *name,
+                                    XferFolderAsyncUserCallback user_callback,
+                                    gpointer user_data)
 {
        ModestMailOperationPrivate *priv;
        ModestTnyFolderRules rules;
-       XFerMsgAsyncHelper *helper;
+       XFerFolderAsyncHelper *helper;
 
        g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
        g_return_if_fail (TNY_IS_FOLDER_STORE (folder));
@@ -2064,21 +2038,9 @@ modest_mail_operation_rename_folder (ModestMailOperation *self,
        /* Check folder rules */
        rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
        if (rules & MODEST_FOLDER_RULES_FOLDER_NON_RENAMEABLE) {
-               /* 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,
-                            _("FIXME: unable to rename"));
-
-               /* Notify about operation end */
-               modest_mail_operation_notify_end (self);
+               goto error;
        } else if (!strcmp (name, " ") || strchr (name, '/')) {
-               priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
-               g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
-                            MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
-                            _("FIXME: unable to rename"));
-               /* Notify about operation end */
-               modest_mail_operation_notify_end (self);
+               goto error;
        } else {
                TnyFolderStore *into;
 
@@ -2088,12 +2050,10 @@ modest_mail_operation_rename_folder (ModestMailOperation *self,
                   special local folder */
                if (new_name_valid_if_local_account (priv, into, name)) {
                        /* Create the helper */
-                       helper = g_slice_new0 (XFerMsgAsyncHelper);
+                       helper = g_slice_new0 (XFerFolderAsyncHelper);
                        helper->mail_op = g_object_ref(self);
-                       helper->dest_folder = NULL;
-                       helper->headers = NULL;
-                       helper->user_callback = NULL;
-                       helper->user_data = NULL;
+                       helper->user_callback = user_callback;
+                       helper->user_data = user_data;
                
                        /* Rename. Camel handles folder subscription/unsubscription */
                        modest_mail_operation_notify_start (self);
@@ -2102,10 +2062,24 @@ modest_mail_operation_rename_folder (ModestMailOperation *self,
                                               transfer_folder_status_cb,
                                               helper);
                } else {
-                       modest_mail_operation_notify_end (self);
+                       goto error;
                }
                g_object_unref (into);
+
+               return;
        }
+ error:
+       /* 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,
+                    _("FIXME: unable to rename"));
+       
+       if (user_callback)
+               user_callback (self, NULL, user_data);
+
+       /* Notify about operation end */
+       modest_mail_operation_notify_end (self);
 }
 
 /* ******************************************************************* */
@@ -2153,6 +2127,15 @@ modest_mail_operation_get_msg (ModestMailOperation *self,
        helper->total_bytes = tny_header_get_message_size (header);
 
        modest_mail_operation_notify_start (self);
+       
+       /* notify about the start of the operation */ 
+       ModestMailOperationState *state;
+       state = modest_mail_operation_clone_state (self);
+       state->done = 0;
+       state->total = 0;
+       g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
+                               0, state, NULL);
+       
        tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, helper);
 
        g_object_unref (G_OBJECT (folder));
@@ -2191,19 +2174,32 @@ get_msg_async_cb (TnyFolder *folder,
 
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
        priv->done++;
-       finished = (priv->done == priv->total) ? TRUE : FALSE;
 
-       /* Check errors */
-       if (canceled || err) {
+       if (info->more_msgs) {
+               tny_iterator_next (info->more_msgs);
+               finished = (tny_iterator_is_done (info->more_msgs));
+       } else {
+               finished = (priv->done == priv->total) ? TRUE : FALSE;
+       }
+
+       /* If canceled by the user, ignore the error given by Tinymail */
+       if (priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED) {
+               canceled = TRUE;
+               finished = TRUE;
+       } else if (canceled || err) {
                priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
-               if (!priv->error)
+               if (err) {
+                       priv->error = g_error_copy ((const GError *) err);
+                       priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
+               }
+               if (!priv->error) {
                        g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
                                     MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
                                     err->message);
-       } else {
+               }
+       } else if (finished && priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
                /* Set the success status before calling the user callback */
-               if (finished && priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
-                       priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+               priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
        }
 
 
@@ -2220,12 +2216,28 @@ get_msg_async_cb (TnyFolder *folder,
 
                /* Notify about operation end */
                modest_mail_operation_notify_end (info->mail_op);
-       }
 
-       /* Clean */
-       g_object_unref (info->header);
-       g_object_unref (info->mail_op);
-       g_slice_free (GetMsgInfo, info);
+               /* Clean */
+               if (info->more_msgs)
+                       g_object_unref (info->more_msgs);
+               g_object_unref (info->header);
+               g_object_unref (info->mail_op);
+               g_slice_free (GetMsgInfo, info);
+       } else if (info->more_msgs) {
+               TnyHeader *header = TNY_HEADER (tny_iterator_get_current (info->more_msgs));
+               TnyFolder *folder = tny_header_get_folder (header);
+
+               g_object_unref (info->header);
+               info->header = g_object_ref (header);
+
+               /* Retrieve the next message */
+               tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, info);
+
+               g_object_unref (header);
+               g_object_unref (folder);
+       } else {
+               g_warning ("%s: finished != TRUE but no messages left", __FUNCTION__);
+       }
 }
 
 void 
@@ -2236,23 +2248,35 @@ modest_mail_operation_get_msgs_full (ModestMailOperation *self,
                                     GDestroyNotify notify)
 {
        ModestMailOperationPrivate *priv = NULL;
-       gboolean size_ok = TRUE;
-       gint max_size;
+       gint msg_list_size;
        TnyIterator *iter = NULL;
+       gboolean has_uncached_messages;
        
        g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
-       
+
        /* Init mail operation */
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
        priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
-       priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
        priv->done = 0;
        priv->total = tny_list_get_length(header_list);
 
+       /* Check uncached messages */
+       for (iter = tny_list_create_iterator (header_list), has_uncached_messages = FALSE;
+            !has_uncached_messages && !tny_iterator_is_done (iter); 
+            tny_iterator_next (iter)) {
+               TnyHeader *header;
+
+               header = (TnyHeader *) tny_iterator_get_current (iter);
+               if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
+                       has_uncached_messages = TRUE;
+               g_object_unref (header);
+       }       
+       priv->op_type = has_uncached_messages?MODEST_MAIL_OPERATION_TYPE_RECEIVE:MODEST_MAIL_OPERATION_TYPE_OPEN;
+
        /* Get account and set it into mail_operation */
        if (tny_list_get_length (header_list) >= 1) {
-               iter = tny_list_create_iterator (header_list);
-               TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
+               TnyIterator *iterator = tny_list_create_iterator (header_list);
+               TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iterator));
                if (header) {
                        TnyFolder *folder = tny_header_get_folder (header);
                        if (folder) {           
@@ -2261,82 +2285,47 @@ modest_mail_operation_get_msgs_full (ModestMailOperation *self,
                        }
                        g_object_unref (header);
                }
-
-               if (tny_list_get_length (header_list) == 1) {
-                       g_object_unref (iter);
-                       iter = NULL;
-               }
+               g_object_unref (iterator);
        }
 
-       /* Get msg size limit */
-       max_size  = modest_conf_get_int (modest_runtime_get_conf (), 
-                                        MODEST_CONF_MSG_SIZE_LIMIT, 
-                                        &(priv->error));
-       if (priv->error) {
-               g_clear_error (&(priv->error));
-               max_size = G_MAXINT;
-       } else {
-               max_size = max_size * KB;
-       }
-
-       /* Check message size limits. If there is only one message
-          always retrieve it */
-       if (iter != NULL) {
-               while (!tny_iterator_is_done (iter) && size_ok) {
-                       TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
-                       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);
-       }
+       msg_list_size = compute_message_list_size (header_list);
 
-       if (size_ok) {
-               const gint msg_list_size = compute_message_list_size (header_list);
+       modest_mail_operation_notify_start (self);
+       iter = tny_list_create_iterator (header_list);
+       if (!tny_iterator_is_done (iter)) {
+               /* notify about the start of the operation */
+               ModestMailOperationState *state;
+               state = modest_mail_operation_clone_state (self);
+               state->done = 0;
+               state->total = 0;
+               g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
+                              0, state, NULL);
 
-               modest_mail_operation_notify_start (self);
-               iter = tny_list_create_iterator (header_list);
-               while (!tny_iterator_is_done (iter)) { 
-                       GetMsgInfo *msg_info = NULL;
-                       TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
-                       TnyFolder *folder = tny_header_get_folder (header);
-                       
-                       /* Create the message info */
-                       msg_info = g_slice_new0 (GetMsgInfo);
-                       msg_info->mail_op = g_object_ref (self);
-                       msg_info->header = g_object_ref (header);
-                       msg_info->user_callback = user_callback;
-                       msg_info->user_data = user_data;
-                       msg_info->destroy_notify = notify;
-                       msg_info->last_total_bytes = 0;
-                       msg_info->sum_total_bytes = 0;
-                       msg_info->total_bytes = msg_list_size;
-                       
-                       /* The callback will call it per each header */
-                       tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, msg_info);
-                       
-                       /* Free and go on */
-                       g_object_unref (header);
-                       g_object_unref (folder);
-                       tny_iterator_next (iter);
-               }
-               g_object_unref (iter);
-       } else {
-               /* Set status failed and set an error */
-               priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
-               /* FIXME: the error msg is different for pop */
-               g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
-                            MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT,
-                            _("emev_ni_ui_imap_msg_size_exceed_error"));
-               /* Remove from queue and free resources */
-               modest_mail_operation_notify_end (self);
-               if (notify)
-                       notify (user_data);
+               GetMsgInfo *msg_info = NULL;
+               TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
+               TnyFolder *folder = tny_header_get_folder (header);
+
+               /* Create the message info */
+               msg_info = g_slice_new0 (GetMsgInfo);
+               msg_info->mail_op = g_object_ref (self);
+               msg_info->header = g_object_ref (header);
+               msg_info->more_msgs = g_object_ref (iter);
+               msg_info->user_callback = user_callback;
+               msg_info->user_data = user_data;
+               msg_info->destroy_notify = notify;
+               msg_info->last_total_bytes = 0;
+               msg_info->sum_total_bytes = 0;
+               msg_info->total_bytes = msg_list_size;
+
+               /* The callback will call it per each header */
+               tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, msg_info);
+
+               /* Free and go on */
+               g_object_unref (header);
+               g_object_unref (folder);
+               g_slice_free (ModestMailOperationState, state);
        }
+       g_object_unref (iter);
 }
 
 
@@ -2368,6 +2357,7 @@ modest_mail_operation_remove_msg (ModestMailOperation *self,
                gboolean expunge, leave_on_server;
                const gchar *account_name;
                TnyAccount *account;
+               ModestTransportStoreProtocol account_proto;
 
                tny_header_set_flag (header, TNY_HEADER_FLAG_DELETED);
                tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
@@ -2381,7 +2371,10 @@ modest_mail_operation_remove_msg (ModestMailOperation *self,
                        modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
                                                                account_name);
 
-               if (TNY_IS_CAMEL_POP_FOLDER (folder) && !leave_on_server)
+               account_proto = modest_protocol_info_get_transport_store_protocol (tny_account_get_proto (account));
+
+               if (((account_proto == MODEST_PROTOCOL_STORE_POP) && !leave_on_server) ||
+                   modest_tny_folder_is_remote_folder (folder) == FALSE)
                        expunge = TRUE;
                else
                        expunge = FALSE;
@@ -2412,7 +2405,7 @@ modest_mail_operation_remove_msgs (ModestMailOperation *self,
                                   TnyList *headers,
                                  gboolean remove_to_trash /*ignored*/)
 {
-       TnyFolder *folder;
+       TnyFolder *folder = NULL;
        ModestMailOperationPrivate *priv;
        TnyIterator *iter = NULL;
        TnyHeader *header = NULL;
@@ -2425,14 +2418,23 @@ modest_mail_operation_remove_msgs (ModestMailOperation *self,
        if (remove_to_trash)
                g_warning ("remove to trash is not implemented");
 
+       if (tny_list_get_length(headers) == 0) {
+               g_warning ("%s: list of headers is empty\n", __FUNCTION__);
+               goto cleanup; /* nothing to do */
+       }
+       
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
-
        remove_headers = g_object_ref(headers);
 
        /* Get folder from first header and sync it */
-       iter = tny_list_create_iterator (headers);
+       iter = tny_list_create_iterator (headers);      
        header = TNY_HEADER (tny_iterator_get_current (iter));
-       folder = tny_header_get_folder (header);
+
+       folder = tny_header_get_folder (header);        
+       if (!TNY_IS_FOLDER(folder)) {
+               g_warning ("%s: could not get folder for header\n", __FUNCTION__);
+               goto cleanup;
+       }
 
        /* Don't remove messages that are being sent */
        if (modest_tny_folder_is_local_folder (folder)) {
@@ -2477,15 +2479,23 @@ modest_mail_operation_remove_msgs (ModestMailOperation *self,
        if (!priv->error) {
                gboolean expunge, leave_on_server;
                const gchar *account_name;
+               const gchar *proto;
                TnyAccount *account;
+               ModestTransportStoreProtocol account_proto = MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN;
                
                account = tny_folder_get_account (folder);
                account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
                leave_on_server =
                        modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
-                                       account_name);
-
-               if (TNY_IS_CAMEL_POP_FOLDER (folder) && !leave_on_server)
+                                                               account_name);
+               
+               proto = tny_account_get_proto (account);
+               if (proto) {
+                       account_proto = modest_protocol_info_get_transport_store_protocol (proto);
+               }
+               
+               if (((account_proto == MODEST_PROTOCOL_STORE_POP) && !leave_on_server) ||
+                   modest_tny_folder_is_remote_folder (folder) == FALSE)
                        expunge = TRUE;
                else
                        expunge = FALSE;
@@ -2504,10 +2514,15 @@ modest_mail_operation_remove_msgs (ModestMailOperation *self,
                priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
 
        /* Free */
-       g_object_unref (remove_headers);
-       g_object_unref (header);
-       g_object_unref (iter);
-       g_object_unref (G_OBJECT (folder));
+cleanup:
+       if (remove_headers)
+               g_object_unref (remove_headers);
+       if (header)
+               g_object_unref (header);
+       if (iter)
+               g_object_unref (iter);
+       if (folder)
+               g_object_unref (folder);
 
        /* Notify about operation end */
        modest_mail_operation_notify_end (self);
@@ -2523,13 +2538,18 @@ notify_progress_of_multiple_messages (ModestMailOperation *self,
 {
        ModestMailOperationPrivate *priv;
        ModestMailOperationState *state;
-       gboolean is_num_bytes;
+       gboolean is_num_bytes = FALSE;
 
        priv =  MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 
        /* We know that tinymail sends us information about
-          transferred bytes with this particular message */
-       is_num_bytes = (g_ascii_strcasecmp (status->message, "Retrieving message") == 0);
+        *  transferred bytes with this particular message
+        *  
+        *  (FIXME: this is very ugly, and no I (djcb) didn't write this code,
+        *  I just added the 'if' so we don't get runtime warning)
+        */
+       if (status->message)
+               is_num_bytes = (g_ascii_strcasecmp (status->message, "Retrieving message") == 0);
 
        state = modest_mail_operation_clone_state (self);
        if (is_num_bytes && !((status->position == 1) && (status->of_total == 100))) {
@@ -2565,12 +2585,12 @@ transfer_msgs_status_cb (GObject *obj,
                         TnyStatus *status,  
                         gpointer user_data)
 {
-       XFerMsgAsyncHelper *helper;
+       XFerMsgsAsyncHelper *helper;
 
        g_return_if_fail (status != NULL);
        g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_XFER_MSGS);
 
-       helper = (XFerMsgAsyncHelper *) user_data;
+       helper = (XFerMsgsAsyncHelper *) user_data;
        g_return_if_fail (helper != NULL);       
 
        /* Notify progress */
@@ -2582,13 +2602,12 @@ transfer_msgs_status_cb (GObject *obj,
 static void
 transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError *err, gpointer user_data)
 {
-       XFerMsgAsyncHelper *helper;
+       XFerMsgsAsyncHelper *helper;
        ModestMailOperation *self;
        ModestMailOperationPrivate *priv;
-       TnyIterator *iter = NULL;
-       TnyHeader *header = NULL;
+       gboolean finished = TRUE;
 
-       helper = (XFerMsgAsyncHelper *) user_data;
+       helper = (XFerMsgsAsyncHelper *) user_data;
        self = helper->mail_op;
 
        priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
@@ -2603,57 +2622,66 @@ transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError *err, gpointer u
                             MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
                             _("Error trying to refresh the contents of %s"),
                             tny_folder_get_name (folder));
-       } else {
-               priv->done = 1;
-               priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+       } else if (priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
+               if (helper->more_msgs) {
+                       /* We'll transfer the next message in the list */
+                       tny_iterator_next (helper->more_msgs);
+                       if (!tny_iterator_is_done (helper->more_msgs)) {
+                               GObject *next_header;
+                               g_object_unref (helper->headers);
+                               helper->headers = tny_simple_list_new ();
+                               next_header = tny_iterator_get_current (helper->more_msgs);
+                               tny_list_append (helper->headers, next_header);
+                               g_object_unref (next_header);
+                               finished = FALSE;
+                       }
+               }
 
-               /* Update folder counts */
-               tny_folder_poke_status (folder);                
-               tny_folder_poke_status (helper->dest_folder);           
+               if (finished) {
+                       priv->done = 1;
+                       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_flag (header, TNY_HEADER_FLAG_DELETED);
-                       tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
-                       g_object_unref (header);
+       if (finished) {
 
-                       tny_iterator_next (iter);
-               }
+               /* Update folder counts */
+               tny_folder_poke_status (folder);
+               tny_folder_poke_status (helper->dest_folder);
 
-       }
-               
+               /* Notify about operation end */
+               modest_mail_operation_notify_end (self);
 
-       /* Notify about operation end */
-       modest_mail_operation_notify_end (self);
+               /* If user defined callback function was defined, call it */
+               if (helper->user_callback) {
+                       /* This is not a GDK lock because we are a Tinymail callback and
+                        * Tinymail already acquires the Gdk lock */
 
-       /* If user defined callback function was defined, call it */
-       if (helper->user_callback) {
-               /* 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, helper->user_data);
+                       /* no gdk_threads_leave (), CHECKED */
+               }
 
-               /* no gdk_threads_enter (), CHECKED */
-               helper->user_callback (self, helper->user_data);
-               /* no gdk_threads_leave (), CHECKED */
+               /* Free */
+               if (helper->more_msgs)
+                       g_object_unref (helper->more_msgs);
+               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);
+               g_slice_free (XFerMsgsAsyncHelper, helper);
+       } else {
+               /* Transfer more messages */
+               tny_folder_transfer_msgs_async (folder,
+                                               helper->headers,
+                                               helper->dest_folder,
+                                               helper->delete,
+                                               transfer_msgs_cb,
+                                               transfer_msgs_status_cb,
+                                               helper);
        }
-
-       /* Free */
-       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);
 }
 
 static guint
@@ -2694,15 +2722,17 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self,
                                 TnyList *headers, 
                                 TnyFolder *folder, 
                                 gboolean delete_original,
-                                XferAsyncUserCallback user_callback,
+                                XferMsgsAsyncUserCallback user_callback,
                                 gpointer user_data)
 {
        ModestMailOperationPrivate *priv = NULL;
        TnyIterator *iter = NULL;
        TnyFolder *src_folder = NULL;
-       XFerMsgAsyncHelper *helper = NULL;
+       XFerMsgsAsyncHelper *helper = NULL;
        TnyHeader *header = NULL;
        ModestTnyFolderRules rules = 0;
+       TnyAccount *dst_account = NULL;
+       gboolean leave_on_server;
 
        g_return_if_fail (self && MODEST_IS_MAIL_OPERATION (self));
        g_return_if_fail (headers && TNY_IS_LIST (headers));
@@ -2762,10 +2792,9 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self,
        }
 
        /* Create the helper */
-       helper = g_slice_new0 (XFerMsgAsyncHelper);
+       helper = g_slice_new0 (XFerMsgsAsyncHelper);
        helper->mail_op = g_object_ref(self);
        helper->dest_folder = g_object_ref(folder);
-       helper->headers = g_object_ref(headers);
        helper->user_callback = user_callback;
        helper->user_data = user_data;
        helper->delete = delete_original;
@@ -2775,16 +2804,53 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self,
 
        /* Get account and set it into mail_operation */
        priv->account = modest_tny_folder_get_account (src_folder);
+       dst_account = modest_tny_folder_get_account (folder);
+
+       if (priv->account == dst_account) {
+               /* Transfer all messages at once using the fast
+                * method. Note that depending on the server this
+                * might not be that fast, and might not be
+                * user-cancellable either */
+               helper->headers = g_object_ref (headers);
+               helper->more_msgs = NULL;
+       } else {
+               /* Transfer messages one by one so the user can cancel
+                * the operation */
+               GObject *hdr;
+               helper->headers = tny_simple_list_new ();
+               helper->more_msgs = tny_list_create_iterator (headers);
+               hdr = tny_iterator_get_current (helper->more_msgs);
+               tny_list_append (helper->headers, hdr);
+               g_object_unref (hdr);
+       }
+
+       /* If leave_on_server is set to TRUE then don't use
+          delete_original, we always pass FALSE. This is because
+          otherwise tinymail will try to sync the source folder and
+          this could cause an error if we're offline while
+          transferring an already downloaded message from a POP
+          account */
+        if (modest_protocol_info_get_transport_store_protocol (tny_account_get_proto (priv->account)) == 
+           MODEST_PROTOCOL_STORE_POP) {
+               const gchar *account_name;
+
+               account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (priv->account);
+               leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
+                                                                         account_name);
+       } else {
+               leave_on_server = FALSE;
+       }
 
-       /* Transfer messages */
        modest_mail_operation_notify_start (self);
        tny_folder_transfer_msgs_async (src_folder, 
-                                       headers, 
+                                       helper->headers, 
                                        folder, 
-                                       delete_original, 
+                                       (leave_on_server) ? FALSE : delete_original, 
                                        transfer_msgs_cb, 
                                        transfer_msgs_status_cb,
                                        helper);
+       g_object_unref (src_folder);
+       g_object_unref (dst_account);
 }
 
 
@@ -2893,16 +2959,95 @@ modest_mail_operation_refresh_folder  (ModestMailOperation *self,
        helper->user_callback = user_callback;
        helper->user_data = user_data;
 
-       /* Refresh the folder. TODO: tinymail could issue a status
-          updates before the callback call then this could happen. We
-          must review the design */
        modest_mail_operation_notify_start (self);
+       
+       /* notify that the operation was started */
+       ModestMailOperationState *state;
+       state = modest_mail_operation_clone_state (self);
+       state->done = 0;
+       state->total = 0;
+       g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
+                       0, state, NULL);
+
+       /* FIXME: we're leaking the state here, or? valgrind thinks so */
+       
        tny_folder_refresh_async (folder,
                                  on_refresh_folder,
                                  on_refresh_folder_status_update,
                                  helper);
 }
 
+static void
+run_queue_stop (ModestTnySendQueue *queue,
+               ModestMailOperation *self)
+{
+       ModestMailOperationPrivate *priv;
+
+       g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
+       g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (queue));
+       priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+       priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+
+       modest_mail_operation_notify_end (self);
+       g_signal_handlers_disconnect_by_func (queue, run_queue_stop, self);
+       g_object_unref (self);
+}
+void
+modest_mail_operation_run_queue (ModestMailOperation *self,
+                                ModestTnySendQueue *queue)
+{
+       ModestMailOperationPrivate *priv;
+
+       g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
+       g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (queue));
+       priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+       priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
+       priv->account = TNY_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (queue)));
+       priv->op_type = MODEST_MAIL_OPERATION_TYPE_RUN_QUEUE;
+
+       modest_mail_operation_notify_start (self);
+       g_object_ref (self);
+       g_signal_connect ((gpointer) queue, "queue-stop", G_CALLBACK (run_queue_stop), (gpointer) self);
+}
+
+static void
+sync_folder_finish_callback (TnyFolder *self, gboolean cancelled, GError *err, ModestMailOperation *mail_op)
+{
+       ModestMailOperationPrivate *priv;
+
+       priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
+       if (err != NULL) {
+               g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+                            MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
+                            err->message);
+               priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+       } else {
+               priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+       }
+       modest_mail_operation_notify_end (mail_op);
+       g_object_unref (mail_op);
+}
+
+void
+modest_mail_operation_sync_folder (ModestMailOperation *self,
+                                  TnyFolder *folder, gboolean expunge)
+{
+       ModestMailOperationPrivate *priv;
+
+       g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
+       g_return_if_fail (TNY_IS_FOLDER (folder));
+       priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+       priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
+       priv->account = TNY_ACCOUNT (tny_folder_get_account (folder));
+       priv->op_type = MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER;
+
+       modest_mail_operation_notify_start (self);
+       g_object_ref (self);
+       tny_folder_sync_async (folder, expunge, (TnyFolderCallback) sync_folder_finish_callback, NULL, self);
+}
 
 static void
 modest_mail_operation_notify_start (ModestMailOperation *self)
@@ -2978,3 +3123,47 @@ modest_mail_operation_noop (ModestMailOperation *self)
        modest_mail_operation_notify_start (self);
        modest_mail_operation_notify_end (self);
 }
+
+
+gchar*
+modest_mail_operation_to_string (ModestMailOperation *self)
+{
+       const gchar *type, *status, *account_id;
+       ModestMailOperationPrivate *priv = NULL;
+       
+       g_return_val_if_fail (self, NULL);
+
+       priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
+
+       /* new operations don't have anything interesting */
+       if (priv->op_type == MODEST_MAIL_OPERATION_TYPE_UNKNOWN)
+               return g_strdup_printf ("%p <new operation>", self);
+       
+       switch (priv->op_type) {
+       case MODEST_MAIL_OPERATION_TYPE_SEND:    type= "SEND";    break;
+       case MODEST_MAIL_OPERATION_TYPE_RECEIVE: type= "RECEIVE"; break;
+       case MODEST_MAIL_OPERATION_TYPE_OPEN:    type= "OPEN";    break;
+       case MODEST_MAIL_OPERATION_TYPE_DELETE:  type= "DELETE";  break;
+       case MODEST_MAIL_OPERATION_TYPE_INFO:    type= "INFO";    break;
+       case MODEST_MAIL_OPERATION_TYPE_RUN_QUEUE: type= "RUN-QUEUE"; break;
+       case MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER: type= "SYNC-FOLDER"; break;
+       case MODEST_MAIL_OPERATION_TYPE_UNKNOWN: type= "UNKNOWN"; break;
+       default: type = "UNEXPECTED"; break;
+       }
+
+       switch (priv->status) {
+       case MODEST_MAIL_OPERATION_STATUS_INVALID:              status= "INVALID"; break;
+       case MODEST_MAIL_OPERATION_STATUS_SUCCESS:              status= "SUCCESS"; break;
+       case MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS: status= "FINISHED-WITH-ERRORS"; break;
+       case MODEST_MAIL_OPERATION_STATUS_FAILED:               status= "FAILED"; break;
+       case MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS:          status= "IN-PROGRESS"; break;
+       case MODEST_MAIL_OPERATION_STATUS_CANCELED:             status= "CANCELLED"; break;
+       default:                                                status= "UNEXPECTED"; break;
+       } 
+
+       account_id = priv->account ? tny_account_get_id (priv->account) : "";
+
+       return g_strdup_printf ("%p \"%s\" (%s) [%s] {%d/%d} '%s'", self, account_id,type, status,
+                               priv->done, priv->total,
+                               priv->error && priv->error->message ? priv->error->message : "");
+}