X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-mail-operation.c;h=7c78ded457ce17130a5aa0cda12ce74bf3532d32;hp=315cf74f1d2b6a55868ca59fde0d4082a0d91be8;hb=77ceea6adee9a9d22007093bf92ea989bb6430fb;hpb=b0f563c348480ad3cff6480a2a3c334646e534db

diff --git a/src/modest-mail-operation.c b/src/modest-mail-operation.c
index 315cf74..7c78ded 100644
--- a/src/modest-mail-operation.c
+++ b/src/modest-mail-operation.c
@@ -93,6 +93,11 @@ static void     notify_progress_of_multiple_messages (ModestMailOperation *self,
 
 static guint    compute_message_list_size (TnyList *headers);
 
+static guint    compute_message_array_size (GPtrArray *headers);
+
+static int      compare_headers_by_date   (gconstpointer a,
+					   gconstpointer b);
+
 enum _ModestMailOperationSignals 
 {
 	PROGRESS_CHANGED_SIGNAL,
@@ -135,6 +140,20 @@ 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;	
@@ -369,6 +388,8 @@ void
 modest_mail_operation_execute_error_handler (ModestMailOperation *self)
 {
 	ModestMailOperationPrivate *priv;
+
+	g_return_if_fail (self && MODEST_IS_MAIL_OPERATION(self));
 	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 	g_return_if_fail(priv->status != MODEST_MAIL_OPERATION_STATUS_SUCCESS);	    
@@ -384,6 +405,9 @@ modest_mail_operation_get_type_operation (ModestMailOperation *self)
 {
 	ModestMailOperationPrivate *priv;
 
+	g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
+			      MODEST_MAIL_OPERATION_TYPE_UNKNOWN);
+	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 	
 	return priv->op_type;
@@ -395,6 +419,9 @@ modest_mail_operation_is_mine (ModestMailOperation *self,
 {
 	ModestMailOperationPrivate *priv;
 
+	g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
+			      FALSE);
+	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 	if (priv->source == NULL) return FALSE;
 
@@ -406,7 +433,8 @@ modest_mail_operation_get_source (ModestMailOperation *self)
 {
 	ModestMailOperationPrivate *priv;
 
-	g_return_val_if_fail (self, NULL);
+	g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
+			      NULL);
 	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 	if (!priv) {
@@ -458,8 +486,8 @@ modest_mail_operation_cancel (ModestMailOperation *self)
 {
 	ModestMailOperationPrivate *priv;
 	gboolean canceled = FALSE;
-
-	g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), FALSE);
+	
+	g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION (self), FALSE);
 
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 
@@ -494,8 +522,9 @@ modest_mail_operation_get_task_done (ModestMailOperation *self)
 {
 	ModestMailOperationPrivate *priv;
 
-	g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), 0);
-
+	g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
+			      0);
+	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 	return priv->done;
 }
@@ -505,7 +534,8 @@ modest_mail_operation_get_task_total (ModestMailOperation *self)
 {
 	ModestMailOperationPrivate *priv;
 
-	g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), 0);
+	g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
+			      0);
 
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 	return priv->total;
@@ -517,11 +547,9 @@ modest_mail_operation_is_finished (ModestMailOperation *self)
 	ModestMailOperationPrivate *priv;
 	gboolean retval = FALSE;
 
-	if (!MODEST_IS_MAIL_OPERATION (self)) {
-		g_warning ("%s: invalid parametter", G_GNUC_FUNCTION);
-		return retval;
-	}
-
+	g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
+			      FALSE);
+	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 
 	if (priv->status == MODEST_MAIL_OPERATION_STATUS_SUCCESS   ||
@@ -582,10 +610,11 @@ modest_mail_operation_send_mail (ModestMailOperation *self,
 {
 	TnySendQueue *send_queue = NULL;
 	ModestMailOperationPrivate *priv;
+	SendMsgInfo *info;
 	
-	g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
-	g_return_if_fail (TNY_IS_TRANSPORT_ACCOUNT (transport_account));
-	g_return_if_fail (TNY_IS_MSG (msg));
+	g_return_if_fail (self && MODEST_IS_MAIL_OPERATION (self));
+	g_return_if_fail (transport_account && TNY_IS_TRANSPORT_ACCOUNT (transport_account));
+	g_return_if_fail (msg && TNY_IS_MSG (msg));
 	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 
@@ -601,6 +630,7 @@ modest_mail_operation_send_mail (ModestMailOperation *self,
 			     MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
 			     "modest: could not find send queue for account\n");
 		priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+		modest_mail_operation_notify_end (self);
 
 	} else {
 		/* Add the msg to the queue */
@@ -609,19 +639,87 @@ modest_mail_operation_send_mail (ModestMailOperation *self,
 					   msg, 
 					   &(priv->error));
 
-		/* TODO: we're setting always success, do the check in
-		   the handler */
+		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);
+
+	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);
 	}
+	g_object_unref(G_OBJECT(hdr1));
+	g_object_unref(G_OBJECT(hdr2));
+}
 
-	if (priv->status == MODEST_MAIL_OPERATION_STATUS_SUCCESS)
-		modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
+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");
 
-	/* TODO: do this in the handler of the "msg-sent"
-	   signal.Notify about operation end */
-	modest_mail_operation_notify_end (self);
+		common_send_mail_operation_end (queue, msg, info);
+	}
+	g_object_unref(G_OBJECT(hdr1));
+	g_object_unref(G_OBJECT(hdr2));
 }
 
+
 static gboolean
 idle_create_msg_cb (gpointer idle_data)
 {
@@ -707,6 +805,7 @@ 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;
 }
 
@@ -815,7 +914,6 @@ end:
 	if (info->transport_account)
 		g_object_unref (info->transport_account);
 	g_slice_free (SendNewMailInfo, info);
-	modest_mail_operation_notify_end (self);
 }
 
 void
@@ -839,7 +937,8 @@ modest_mail_operation_send_new_mail (ModestMailOperation *self,
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 	priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND;
 	priv->account = TNY_ACCOUNT (g_object_ref (transport_account));
-
+	priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
+	
 	/* Check parametters */
 	if (to == NULL) {
  		/* Set status failed and set an error */
@@ -1031,20 +1130,6 @@ modest_mail_operation_save_to_drafts (ModestMailOperation *self,
 					  modest_mail_operation_save_to_drafts_cb, info);
 }
 
-typedef struct 
-{
-	ModestMailOperation *mail_op;
-	TnyStoreAccount *account;
-	TnyTransportAccount *transport_account;
-	gint max_size;
-	gint retrieve_limit;
-	gchar *retrieve_type;
-	gchar *account_name;
-	UpdateAccountCallback callback;
-	gpointer user_data;
-	TnyList *new_headers;
-} UpdateAccountInfo;
-
 typedef struct
 {
 	ModestMailOperation *mail_op;
@@ -1136,442 +1221,345 @@ internal_folder_observer_class_init (InternalFolderObserverClass *klass)
 	object_class->finalize = internal_folder_observer_finalize;
 }
 
-/*****************/
-
-static void
-recurse_folders (TnyFolderStore *store, TnyFolderStoreQuery *query, TnyList *all_folders)
+typedef struct 
 {
-	TnyIterator *iter;
-	TnyList *folders = tny_simple_list_new ();
-
-	tny_folder_store_get_folders (store, folders, query, NULL);
-	iter = tny_list_create_iterator (folders);
-
-	while (!tny_iterator_is_done (iter)) {
-
-		TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter);
-		if (folder) {
-			tny_list_prepend (all_folders, G_OBJECT (folder));
-			recurse_folders (folder, query, all_folders);    
- 			g_object_unref (G_OBJECT (folder));
-		}
+	ModestMailOperation *mail_op;
+	gchar *account_name;
+	UpdateAccountCallback callback;
+	gpointer user_data;
+	TnyList *folders;
+	gint pending_calls;
+	gboolean poke_all;
+	TnyFolderObserver *inbox_observer;
+	guint update_timeout;
+	RetrieveAllCallback retrieve_all_cb;
+} UpdateAccountInfo;
 
-		tny_iterator_next (iter);
-	}
-	 g_object_unref (G_OBJECT (iter));
-	 g_object_unref (G_OBJECT (folders));
-}
 
-/* 
- * 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
-idle_notify_progress (gpointer data)
+static void
+destroy_update_account_info (UpdateAccountInfo *info)
 {
-	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 */
+	if (info->update_timeout) {
+		g_source_remove (info->update_timeout);
+		info->update_timeout = 0;
+	}
 
-	g_slice_free (ModestMailOperationState, state);
-	
-	return TRUE;
+	g_free (info->account_name);
+	g_object_unref (info->folders);
+	g_object_unref (info->mail_op);
+	g_slice_free (UpdateAccountInfo, info);
 }
 
-/* 
- * Issues the "progress-changed" signal and removes the timer. It uses
- * a lock to ensure that the progress information of the mail
- * operation is not modified while there are notifications pending
- */
-static gboolean
-idle_notify_progress_once (gpointer data)
+static void
+update_account_get_msg_async_cb (TnyFolder *folder, 
+				 gboolean canceled, 
+				 TnyMsg *msg, 
+				 GError *err, 
+				 gpointer user_data)
 {
-	ModestPair *pair;
-
-	pair = (ModestPair *) data;
+	GetMsgInfo *msg_info = (GetMsgInfo *) user_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);
-	g_object_unref (pair->first);
-
-	return FALSE;
+	/* Just delete the helper. Don't do anything with the new
+	   msg. There is also no need to check for errors */
+	g_object_unref (msg_info->mail_op);
+	g_object_unref (msg_info->header);
+	g_slice_free (GetMsgInfo, msg_info);
 }
 
-/* 
- * Used to notify the queue from the main
- * loop. We call it inside an idle call to achieve that
- */
-static gboolean
-idle_notify_queue (gpointer data)
-{
-	ModestMailOperation *mail_op = MODEST_MAIL_OPERATION (data);
-
-	gdk_threads_enter ();
-	modest_mail_operation_notify_end (mail_op);
-	gdk_threads_leave ();
-	g_object_unref (mail_op);
 
-	return FALSE;
-}
-
-static int
-compare_headers_by_date (gconstpointer a, 
-			 gconstpointer b)
-{
-	TnyHeader **header1, **header2;
-	time_t sent1, sent2;
+static void
+inbox_refreshed_cb (TnyFolder *inbox, 
+		    gboolean canceled, 
+		    GError *err, 
+		    gpointer user_data)
+{	
+	UpdateAccountInfo *info;
+	ModestMailOperationPrivate *priv;
+	TnyIterator *new_headers_iter;
+	GPtrArray *new_headers_array = NULL;   
+	gint max_size, retrieve_limit, i;
+	ModestAccountMgr *mgr;
+	ModestAccountRetrieveType retrieve_type;
+	TnyList *new_headers = NULL;
+	gboolean headers_only, ignore_limit;
+	TnyTransportAccount *transport_account;
+	ModestTnySendQueue *send_queue;
 
-	header1 = (TnyHeader **) a;
-	header2 = (TnyHeader **) b;
+	info = (UpdateAccountInfo *) user_data;
+	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
+	mgr = modest_runtime_get_account_mgr ();
 
-	sent1 = tny_header_get_date_sent (*header1);
-	sent2 = tny_header_get_date_sent (*header2);
+	if (canceled || err || !inbox) {
+		/* Try to send anyway */
+		goto send_mail;
+	}
 
-	/* We want the most recent ones (greater time_t) at the
-	   beginning */
-	if (sent1 < sent2)
-		return 1;
+	/* Get the message max size */
+	max_size  = modest_conf_get_int (modest_runtime_get_conf (),
+					 MODEST_CONF_MSG_SIZE_LIMIT, NULL);
+	if (max_size == 0)
+		max_size = G_MAXINT;
 	else
-		return -1;
-}
-
-static gboolean 
-set_last_updated_idle (gpointer data)
-{
-
-	/* This is a GDK lock because we are an idle callback and
- 	 * modest_account_mgr_set_last_updated can issue 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_last_updated (modest_runtime_get_account_mgr (), 
-					     (gchar *) data, 
-					     time (NULL));
-
-	gdk_threads_leave (); /* CHECKED - please recheck */
-
-	return FALSE;
-}
+		max_size = max_size * KB;
 
-static gboolean
-idle_update_account_cb (gpointer data)
-{
-	UpdateAccountInfo *idle_info;
+	/* Create the new headers array. We need it to sort the
+	   new headers by date */
+	new_headers_array = g_ptr_array_new ();
+	new_headers_iter = tny_list_create_iterator (((InternalFolderObserver *) info->inbox_observer)->new_headers);
+	while (!tny_iterator_is_done (new_headers_iter)) {
+		TnyHeader *header = NULL;
+
+		header = TNY_HEADER (tny_iterator_get_current (new_headers_iter));
+		/* Apply per-message size limits */
+		if (tny_header_get_message_size (header) < max_size)
+			g_ptr_array_add (new_headers_array, g_object_ref (header));
+				
+		g_object_unref (header);
+		tny_iterator_next (new_headers_iter);
+	}
+	g_object_unref (new_headers_iter);
+	tny_folder_remove_observer (inbox, info->inbox_observer);
+	g_object_unref (info->inbox_observer);
+	info->inbox_observer = NULL;
 
-	idle_info = (UpdateAccountInfo *) data;
+	/* 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 (new_headers_array->len == 0)
+		goto send_mail;
 
-	/* This is a GDK lock because we are an idle callback and
- 	 * idle_info->callback can contain Gtk+ code */
+	/* Get per-account message amount retrieval limit */
+	retrieve_limit = modest_account_mgr_get_retrieve_limit (mgr, info->account_name);
+	if (retrieve_limit == 0)
+		retrieve_limit = G_MAXINT;
+	
+	/* Get per-account retrieval type */
+	retrieve_type = modest_account_mgr_get_retrieve_type (mgr, info->account_name);	
+	headers_only = (retrieve_type == MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY);
 
-	gdk_threads_enter (); /* CHECKED */
-	idle_info->callback (idle_info->mail_op,
-			     idle_info->new_headers,
-			     idle_info->user_data);
-	gdk_threads_leave (); /* CHECKED */
+	/* Order by date */
+	g_ptr_array_sort (new_headers_array, (GCompareFunc) compare_headers_by_date);
+	
+	/* Ask the users if they want to retrieve all the messages
+	   even though the limit was exceeded */
+	ignore_limit = FALSE;
+	if (new_headers_array->len > retrieve_limit) {
+		/* Ask the user if a callback has been specified and
+		   if the mail operation has a source (this means that
+		   was invoked by the user and not automatically by a
+		   D-Bus method) */
+		if (info->retrieve_all_cb && priv->source)
+			ignore_limit = info->retrieve_all_cb (priv->source,
+							      new_headers_array->len,
+							      retrieve_limit);
+	}
+	
+	if (!headers_only) {
+		gint msg_num = 0;
+		const gint msg_list_size = compute_message_array_size (new_headers_array);
 
-	/* Frees */
-	g_object_unref (idle_info->mail_op);
-	if (idle_info->new_headers)
-		g_object_unref (idle_info->new_headers);
-	g_free (idle_info);
+		priv->done = 0;
+		if (ignore_limit)
+			priv->total = new_headers_array->len;
+		else
+			priv->total = MIN (new_headers_array->len, retrieve_limit);
+		while (msg_num < priv->total) {		
+			TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers_array, msg_num));
+			TnyFolder *folder = tny_header_get_folder (header);
+			GetMsgInfo *msg_info;
 
-	return FALSE;
-}
+			/* Create the message info */
+			msg_info = g_slice_new0 (GetMsgInfo);
+			msg_info->mail_op = g_object_ref (info->mail_op);
+			msg_info->header = g_object_ref (header);
+			msg_info->total_bytes = msg_list_size;
 
-static TnyList *
-get_all_folders_from_account (TnyStoreAccount *account,
-			      GError **error)
-{
-	TnyList *all_folders = NULL;
-	TnyIterator *iter = NULL;
-	TnyFolderStoreQuery *query = NULL;
-
-	all_folders = tny_simple_list_new ();
-	query = tny_folder_store_query_new ();
-	tny_folder_store_query_add_item (query, NULL, TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
-	tny_folder_store_get_folders (TNY_FOLDER_STORE (account),
-				      all_folders,
-				      query,
-				      error);
-
-	if (*error) {
-		if (all_folders)
-			g_object_unref (all_folders);
-		return NULL;
-	}
+			/* Get message in an async way */
+			tny_folder_get_msg_async (folder, header, update_account_get_msg_async_cb, 
+						  get_msg_status_cb, msg_info);
 
-	iter = tny_list_create_iterator (all_folders);
-	while (!tny_iterator_is_done (iter)) {
-		TnyFolderStore *folder = TNY_FOLDER_STORE (tny_iterator_get_current (iter));
-		if (folder) {
-			recurse_folders (folder, query, all_folders);
 			g_object_unref (folder);
+			
+			msg_num++;
 		}
-		tny_iterator_next (iter);
 	}
-	g_object_unref (G_OBJECT (iter));
-
-	return all_folders;
-}
-
-
-static gpointer
-update_account_thread (gpointer thr_user_data)
-{
-	static gboolean first_time = TRUE;
-	UpdateAccountInfo *info = NULL;
-	TnyList *all_folders = NULL, *new_headers = NULL;
-	GPtrArray *new_headers_array = NULL;
-	TnyIterator *iter = NULL;
-	ModestMailOperationPrivate *priv = NULL;
-	ModestTnySendQueue *send_queue = NULL;
-	gint i = 0, timeout = 0;
 
-	info = (UpdateAccountInfo *) thr_user_data;
-	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mail_op);
-
-	/* Get account and set it into mail_operation */
-	priv->account = g_object_ref (info->account);
-
-	/* Get all the folders. We can do it synchronously because
-	   we're already running in a different thread than the UI */
-	all_folders = get_all_folders_from_account (info->account, &(priv->error));
-	if (!all_folders) {
-		priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
-		goto out;
+	/* Copy the headers to a list and free the array */
+	new_headers = tny_simple_list_new ();
+	for (i=0; i < new_headers_array->len; i++) {
+		TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers_array, i));
+		tny_list_append (new_headers, G_OBJECT (header));
 	}
+	g_ptr_array_foreach (new_headers_array, (GFunc) g_object_unref, NULL);
+	g_ptr_array_free (new_headers_array, FALSE);
 
-	/* Update status and notify. We need to call the notification
-	   with a source function in order to call it from the main
-	   loop. We need that in order not to get into trouble with
-	   Gtk+. We use a timeout in order to provide more status
-	   information, because the sync tinymail call does not
-	   provide it for the moment */
-	timeout = g_timeout_add (100, idle_notify_progress, info->mail_op);
+ send_mail:
+	/* Send mails */
+	priv->done = 0;
+	priv->total = 0;
 
-	new_headers_array = g_ptr_array_new ();
-	iter = tny_list_create_iterator (all_folders);
+	/* 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);
 
-	while (!tny_iterator_is_done (iter) && !priv->error && 
-	       priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
+	/* Check if the operation was a success */
+	if (!priv->error)
+		priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
 
-		TnyFolderType folder_type;
-		TnyFolder *folder = NULL;
+	/* Set the account back to not busy */
+	modest_account_mgr_set_account_busy (mgr, info->account_name, FALSE);
 
-		folder = TNY_FOLDER (tny_iterator_get_current (iter));
-		folder_type = tny_folder_get_folder_type (folder);
+	/* Call the user callback */
+	if (info->callback)
+		info->callback (info->mail_op, new_headers, info->user_data);
 
-		/* Refresh it only if it's the INBOX */
-		if (folder_type == TNY_FOLDER_TYPE_INBOX) {
-			InternalFolderObserver *observer = NULL;
-			TnyIterator *new_headers_iter = NULL;
+	/* Notify about operation end */
+	modest_mail_operation_notify_end (info->mail_op);
 
-			/* Refresh the folder. Our observer receives
-			 * the new emails during folder refreshes, so
-			 * we can use observer->new_headers
-			 */
-			observer = g_object_new (internal_folder_observer_get_type (), NULL);
-			tny_folder_add_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
-		
-			tny_folder_refresh (TNY_FOLDER (folder), &(priv->error));
+	/* Frees */
+	if (new_headers)
+		g_object_unref (new_headers);
+	destroy_update_account_info (info);
+}
 
-			new_headers_iter = tny_list_create_iterator (observer->new_headers);
-			while (!tny_iterator_is_done (new_headers_iter)) {
-				TnyHeader *header = NULL;
+static void 
+recurse_folders_async_cb (TnyFolderStore *folder_store, 
+			  gboolean canceled,
+			  TnyList *list, 
+			  GError *err, 
+			  gpointer user_data)
+{
+	UpdateAccountInfo *info;
+	ModestMailOperationPrivate *priv;
+    
+	info = (UpdateAccountInfo *) user_data;
+	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
 
-				header = TNY_HEADER (tny_iterator_get_current (new_headers_iter));
-				/* Apply per-message size limits */
-				if (tny_header_get_message_size (header) < info->max_size)
-					g_ptr_array_add (new_headers_array, g_object_ref (header));
-				
-				g_object_unref (header);
-				tny_iterator_next (new_headers_iter);
-			}
-			g_object_unref (new_headers_iter);
+	if (err || canceled) {
+		/* Try to continue anyway */
+	} else {
+		TnyIterator *iter = tny_list_create_iterator (list);
+		while (!tny_iterator_is_done (iter)) {
+			TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter);
+			TnyList *folders = tny_simple_list_new ();
 
-			tny_folder_remove_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
-			g_object_unref (observer);
-		} else {
-			/* We no not need to do it the first time,
-			   because it's automatically done by the tree
-			   model */
-			if (G_LIKELY (!first_time))
-				tny_folder_poke_status (folder);
+			/* Add to the list of all folders */
+			tny_list_append (info->folders, (GObject *) folder);
+			
+			/* Add pending call */
+			info->pending_calls++;
+			
+			tny_folder_store_get_folders_async (folder, folders, recurse_folders_async_cb, 
+							    NULL, NULL, info);
+			
+			g_object_unref (G_OBJECT (folder));
+			
+			tny_iterator_next (iter);	    
 		}
-		g_object_unref (folder);
-
-		tny_iterator_next (iter);
+		g_object_unref (G_OBJECT (iter));
+		g_object_unref (G_OBJECT (list));
 	}
-	g_object_unref (G_OBJECT (iter));
-	g_source_remove (timeout);
 
-	if (priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED && 
-	    priv->status != MODEST_MAIL_OPERATION_STATUS_FAILED &&
-	    new_headers_array->len > 0) {
-		gint msg_num = 0;
+	/* Remove my own pending call */
+	info->pending_calls--;
 
-		/* Order by date */
-		g_ptr_array_sort (new_headers_array, (GCompareFunc) compare_headers_by_date);
+	/* This means that we have all the folders */
+	if (info->pending_calls == 0) {
+		TnyIterator *iter_all_folders;
+		TnyFolder *inbox = NULL;
 
-		/* TODO: Ask the user, instead of just failing,
-		 * showing mail_nc_msg_count_limit_exceeded, with 'Get
-		 * all' and 'Newest only' buttons. */
-		if (new_headers_array->len > info->retrieve_limit) {
-			/* TODO */
-		}
+		iter_all_folders = tny_list_create_iterator (info->folders);
 
-		/* Should be get only the headers or the message as well? */
-		if (g_ascii_strcasecmp (info->retrieve_type, 
-					MODEST_ACCOUNT_RETRIEVE_VALUE_HEADERS_ONLY) != 0) {	
-			priv->done = 0;
-			priv->total = MIN (new_headers_array->len, info->retrieve_limit);
-			while (msg_num < priv->total) {
+		/* Do a poke status over all folders */
+		while (!tny_iterator_is_done (iter_all_folders) &&
+		       priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
+			TnyFolder *folder = NULL;
 
-				TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers_array, msg_num));
-				TnyFolder *folder = tny_header_get_folder (header);
-				TnyMsg *msg       = tny_folder_get_msg (folder, header, NULL);
-				ModestMailOperationState *state;
-				ModestPair* pair;
+			folder = TNY_FOLDER (tny_iterator_get_current (iter_all_folders));
 
-				priv->done++;
-				/* We can not just use the mail operation because the
-				   values of done and total could change before the
-				   idle is called */
-				state = modest_mail_operation_clone_state (info->mail_op);
-				pair = modest_pair_new (g_object_ref (info->mail_op), state, FALSE);
-				g_idle_add_full (G_PRIORITY_HIGH_IDLE, idle_notify_progress_once,
-						 pair, (GDestroyNotify) modest_pair_free);
-
-				g_object_unref (msg);
-				g_object_unref (folder);
-
-				msg_num++;
+			if (tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_INBOX) {
+				/* Get a reference to the INBOX */
+				inbox = g_object_ref (folder);
+			} else {
+				/* Issue a poke status over the folder */
+				if (info->poke_all)
+					tny_folder_poke_status (folder);
 			}
-		}
-	}
 
-	if (priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED)
-		goto out;
+			/* Free and go to next */
+			g_object_unref (folder);
+			tny_iterator_next (iter_all_folders);
+		}
+		g_object_unref (iter_all_folders);
 
-	/* Copy the headers to a list and free the array */
-	new_headers = tny_simple_list_new ();
-	for (i=0; i < new_headers_array->len; i++) {
-		TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers_array, i));
-		tny_list_append (new_headers, G_OBJECT (header));
-	}
-	g_ptr_array_foreach (new_headers_array, (GFunc) g_object_unref, NULL);
-	g_ptr_array_free (new_headers_array, FALSE);
-	
+		/* Stop the progress notification */
+		g_source_remove (info->update_timeout);
+		info->update_timeout = 0;
 
-	/* Perform send (if operation was not cancelled) */
-	priv->done = 0;
-	priv->total = 0;
-	if (priv->account != NULL) 
-		g_object_unref (priv->account);
+		/* Refresh the INBOX */
+		if (inbox) {
+			/* Refresh the folder. Our observer receives
+			 * the new emails during folder refreshes, so
+			 * we can use observer->new_headers
+			 */
+			info->inbox_observer = g_object_new (internal_folder_observer_get_type (), NULL);
+			tny_folder_add_observer (inbox, info->inbox_observer);
 
-	if (info->transport_account) {
-		priv->account = g_object_ref (info->transport_account);
-	
-		send_queue = modest_runtime_get_send_queue (info->transport_account);
-		if (send_queue) {
-			modest_tny_send_queue_try_to_send (send_queue);
+			/* Refresh the INBOX */
+			tny_folder_refresh_async (inbox, inbox_refreshed_cb, NULL, info);
+			g_object_unref (inbox);
 		} else {
-			g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
-				     MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
-				     "cannot create a send queue for %s\n", 
-				     tny_account_get_name (TNY_ACCOUNT (info->transport_account)));
-			priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+			/* We could not perform the inbox refresh but
+			   we'll try to send mails anyway */
+			inbox_refreshed_cb (inbox, FALSE, NULL, info);
 		}
 	}
-	
-	/* Check if the operation was a success */
-	if (!priv->error) {
-		priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
-
-		/* Update the last updated key */
-		g_idle_add_full (G_PRIORITY_HIGH_IDLE, 
-				 set_last_updated_idle, 
-				 g_strdup (tny_account_get_id (TNY_ACCOUNT (info->account))),
-				 (GDestroyNotify) g_free);
-	}
-
- out:
-	/* Set the account back to not busy */
-	modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr(), 
-					     info->account_name, FALSE);
-	
-	if (info->callback) {
-		UpdateAccountInfo *idle_info;
+}
 
-		/* 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) ? g_object_ref (new_headers) : NULL;
-		idle_info->callback = info->callback;
-		idle_info->user_data = info->user_data;
-		g_idle_add (idle_update_account_cb, idle_info);
-	}
+/* 
+ * 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;
 
-	/* Notify about operation end. Note that the info could be
-	   freed before this idle happens, but the mail operation will
-	   be still alive */
-	g_idle_add (idle_notify_queue, g_object_ref (info->mail_op));
+	state = modest_mail_operation_clone_state (mail_op);
 
-	/* Frees */
-	if (new_headers)
-		g_object_unref (new_headers);
-	if (all_folders)
-		g_object_unref (all_folders);
-	g_object_unref (info->account);
-	if (info->transport_account)
-		g_object_unref (info->transport_account);
-	g_free (info->account_name);
-	g_free (info->retrieve_type);
-	g_slice_free (UpdateAccountInfo, info);
+	/* This is a GDK lock because we are an idle callback and
+ 	 * the handlers of this signal can contain Gtk+ code */
 
-	first_time = FALSE;
+	gdk_threads_enter (); /* CHECKED */
+	g_signal_emit (G_OBJECT (mail_op), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
+	gdk_threads_leave (); /* CHECKED */
 
-	return NULL;
+	g_slice_free (ModestMailOperationState, state);
+	
+	return TRUE;
 }
 
-gboolean
+void
 modest_mail_operation_update_account (ModestMailOperation *self,
 				      const gchar *account_name,
+				      gboolean poke_all,
+				      RetrieveAllCallback retrieve_all_cb,
 				      UpdateAccountCallback callback,
 				      gpointer user_data)
 {
-	GThread *thread = NULL;
 	UpdateAccountInfo *info = NULL;
 	ModestMailOperationPrivate *priv = NULL;
-	ModestAccountMgr *mgr = NULL;
+	ModestTnyAccountStore *account_store = 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);
+	TnyList *folders;
 
-	/* Init mail operation. Set total and done to 0, and do not
-	   update them, this way the progress objects will know that
-	   we have no clue about the number of the objects */
+	/* Init mail operation */
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 	priv->total = 0;
 	priv->done  = 0;
@@ -1579,96 +1567,135 @@ modest_mail_operation_update_account (ModestMailOperation *self,
 	priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
 
 	/* Get the store account */
+	account_store = modest_runtime_get_account_store ();
 	store_account = (TnyStoreAccount *)
-		modest_tny_account_store_get_server_account (modest_runtime_get_account_store (),
-								     account_name,
-								     TNY_ACCOUNT_TYPE_STORE);
-								     
-	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);
-		goto error;
-	}
-
+		modest_tny_account_store_get_server_account (account_store,
+							     account_name,
+							     TNY_ACCOUNT_TYPE_STORE);
 	priv->account = g_object_ref (store_account);
-	
-	/* Get the transport account, we can not do it in the thread
-	   due to some problems with dbus */
-	transport_account = (TnyTransportAccount *)
-		modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
-										    account_name);
-	if (!transport_account) {
-		g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
-			     MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
-			     "cannot get tny transport account for %s\n", account_name);
-		goto error;
-	}
 
 	/* Create the helper object */
-	info = g_slice_new (UpdateAccountInfo);
-	info->mail_op = self;
-	info->account = store_account;
-	info->transport_account = transport_account;
-	info->callback = callback;
+	info = g_slice_new0 (UpdateAccountInfo);
+	info->pending_calls = 1;
+	info->folders = tny_simple_list_new ();
+	info->mail_op = g_object_ref (self);
+	info->poke_all = poke_all;
 	info->account_name = g_strdup (account_name);
+	info->callback = callback;
 	info->user_data = user_data;
-
-	/* Get the message size limit */
-	info->max_size  = modest_conf_get_int (modest_runtime_get_conf (), 
-					       MODEST_CONF_MSG_SIZE_LIMIT, NULL);
-	if (info->max_size == 0)
-		info->max_size = G_MAXINT;
-	else
-		info->max_size = info->max_size * KB;
-
-	/* Get per-account retrieval type */
-	mgr = modest_runtime_get_account_mgr ();
-	info->retrieve_type = modest_account_mgr_get_retrieve_type (mgr, account_name);
-
-	/* Get per-account message amount retrieval limit */
-	info->retrieve_limit = modest_account_mgr_get_retrieve_limit (mgr, account_name);
-	if (info->retrieve_limit == 0)
-		info->retrieve_limit = G_MAXINT;
-		
-	/* printf ("DEBUG: %s: info->retrieve_limit = %d\n", __FUNCTION__, info->retrieve_limit); */
+	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(mgr, account_name, TRUE);
-	
+	modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), account_name, TRUE);
 	modest_mail_operation_notify_start (self);
-	thread = g_thread_create (update_account_thread, info, FALSE, NULL);
 
-	return TRUE;
+	/* 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);
+}
+
+/*
+ * Used to notify the queue from the main
+ * loop. We call it inside an idle call to achieve that
+ */
+static gboolean
+idle_notify_queue (gpointer data)
+{
+	ModestMailOperation *mail_op = MODEST_MAIL_OPERATION (data);
+
+	gdk_threads_enter ();
+	modest_mail_operation_notify_end (mail_op);
+	gdk_threads_leave ();
+	g_object_unref (mail_op);
 
- error:
-	if (store_account)
-		g_object_unref (store_account);
-	if (transport_account)
-		g_object_unref (transport_account);
-	priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
-	if (callback) {
-		callback (self, NULL, user_data);
-	}
-	modest_mail_operation_notify_end (self);
 	return FALSE;
 }
 
+static int
+compare_headers_by_date (gconstpointer a,
+			 gconstpointer b)
+{
+	TnyHeader **header1, **header2;
+	time_t sent1, sent2;
+
+	header1 = (TnyHeader **) a;
+	header2 = (TnyHeader **) b;
+
+	sent1 = tny_header_get_date_sent (*header1);
+	sent2 = tny_header_get_date_sent (*header2);
+
+	/* We want the most recent ones (greater time_t) at the
+	   beginning */
+	if (sent1 < sent2)
+		return 1;
+	else
+		return -1;
+}
+
+
 /* ******************************************************************* */
 /* ************************** STORE  ACTIONS ************************* */
 /* ******************************************************************* */
 
+typedef struct {
+	ModestMailOperation *mail_op;
+	CreateFolderUserCallback callback;
+	gpointer user_data;
+} CreateFolderInfo;
+
 
-TnyFolder *
+static void
+create_folder_cb (TnyFolderStore *parent_folder, 
+		  gboolean canceled, 
+		  TnyFolder *new_folder, 
+		  GError *err, 
+		  gpointer user_data)
+{
+	ModestMailOperationPrivate *priv;
+	CreateFolderInfo *info;
+
+	info = (CreateFolderInfo *) user_data;
+	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
+
+	if (canceled || err) {
+		priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+		if (err)
+			priv->error = g_error_copy (err);
+		else
+			g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+				     MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
+				     "canceled");		
+	} else {
+		priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+	}
+
+	/* The user will unref the new_folder */
+	if (info->callback)
+		info->callback (info->mail_op, parent_folder, 
+				new_folder, info->user_data);
+	
+	/* Notify about operation end */
+	modest_mail_operation_notify_end (info->mail_op);
+
+	/* Frees */
+	g_object_unref (info->mail_op);
+	g_slice_free (CreateFolderInfo, info);
+}
+
+void
 modest_mail_operation_create_folder (ModestMailOperation *self,
 				     TnyFolderStore *parent,
-				     const gchar *name)
+				     const gchar *name,
+				     CreateFolderUserCallback callback,
+				     gpointer user_data)
 {
 	ModestMailOperationPrivate *priv;
-	TnyFolder *new_folder = NULL;
 
-	g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), NULL);
-	g_return_val_if_fail (name, NULL);
+	g_return_if_fail (TNY_IS_FOLDER_STORE (parent));
+	g_return_if_fail (name);
 	
 	priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 	priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
@@ -1705,18 +1732,25 @@ modest_mail_operation_create_folder (ModestMailOperation *self,
 	}
 
 	if (!priv->error) {
-		/* Create the folder */
-		modest_mail_operation_notify_start (self);
-		new_folder = tny_folder_store_create_folder (parent, name, &(priv->error));
-		CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
-		if (!priv->error)
-			priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
-	}
+		CreateFolderInfo *info;
 
-	/* Notify about operation end */
-	modest_mail_operation_notify_end (self);
+		info = g_slice_new0 (CreateFolderInfo);
+		info->mail_op = g_object_ref (self);
+		info->callback = callback;
+		info->user_data = user_data;
+
+		modest_mail_operation_notify_start (self);
 
-	return new_folder;
+		/* Create the folder */
+		tny_folder_store_create_folder_async (parent, name, create_folder_cb, 
+						      NULL, info);
+	} else {
+		/* Call the user callback anyway */
+		if (callback)
+			callback (self, parent, NULL, user_data);
+		/* Notify about operation end */
+		modest_mail_operation_notify_end (self);
+	}
 }
 
 void
@@ -1764,16 +1798,17 @@ modest_mail_operation_remove_folder (ModestMailOperation *self,
 		}
 	} else {
 		TnyFolderStore *parent = tny_folder_get_folder_store (folder);
+		if (parent) {
+			modest_mail_operation_notify_start (self);
+			tny_folder_store_remove_folder (parent, folder, &(priv->error));
+			CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
+			
+			if (!priv->error)
+				priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
 
-		modest_mail_operation_notify_start (self);
-		tny_folder_store_remove_folder (parent, folder, &(priv->error));
-		CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
-
-		if (!priv->error)
-			priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
-
-		if (parent)
-			g_object_unref (G_OBJECT (parent));
+			g_object_unref (parent);
+		} else
+			g_warning ("%s: could not get parent folder", __FUNCTION__);
 	}
 	g_object_unref (G_OBJECT (account));
 
@@ -2095,7 +2130,6 @@ modest_mail_operation_get_msg (ModestMailOperation *self,
 	folder = tny_header_get_folder (header);
 
 	priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
-	priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
 	priv->total = 1;
 	priv->done = 0;
 
@@ -2263,8 +2297,9 @@ modest_mail_operation_get_msgs_full (ModestMailOperation *self,
 	}
 
 	if (size_ok) {
-		modest_mail_operation_notify_start (self);
+		const gint msg_list_size = compute_message_list_size (header_list);
 
+		modest_mail_operation_notify_start (self);
 		iter = tny_list_create_iterator (header_list);
 		while (!tny_iterator_is_done (iter)) { 
 			GetMsgInfo *msg_info = NULL;
@@ -2280,7 +2315,7 @@ modest_mail_operation_get_msgs_full (ModestMailOperation *self,
 			msg_info->destroy_notify = notify;
 			msg_info->last_total_bytes = 0;
 			msg_info->sum_total_bytes = 0;
-			msg_info->total_bytes = compute_message_list_size (header_list);
+			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);
@@ -2331,16 +2366,32 @@ modest_mail_operation_remove_msg (ModestMailOperation *self,
 	/* remove message from folder */
 	tny_folder_remove_msg (folder, header, &(priv->error));
 	if (!priv->error) {
+		gboolean expunge, leave_on_server;
+		const gchar *account_name;
+		TnyAccount *account;
+
 		tny_header_set_flag (header, TNY_HEADER_FLAG_DELETED);
 		tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
 
 		modest_mail_operation_notify_start (self);
 
-		if (TNY_IS_CAMEL_IMAP_FOLDER (folder) ||
-		    TNY_IS_CAMEL_POP_FOLDER (folder))
-			tny_folder_sync_async(folder, FALSE, NULL, NULL, NULL); /* FALSE --> dont expunge */
+		/* Get leave on server setting */
+		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)
+			expunge = TRUE;
 		else
-			tny_folder_sync_async(folder, TRUE, NULL, NULL, NULL); /* TRUE --> expunge */
+			expunge = FALSE;
+
+		/* Sync folder */
+		tny_folder_sync_async(folder, expunge, NULL, NULL, NULL);
+
+		/* Unref */
+		g_object_unref (account);
 	}
 	
 	
@@ -2425,12 +2476,25 @@ modest_mail_operation_remove_msgs (ModestMailOperation *self,
 
 	tny_folder_remove_msgs (folder, remove_headers, &(priv->error));
 	if (!priv->error) {
-		if (TNY_IS_CAMEL_IMAP_FOLDER (folder) || 
-		    TNY_IS_CAMEL_POP_FOLDER (folder))
- 			tny_folder_sync_async(folder, FALSE, NULL, NULL, NULL); /* FALSE --> don't expunge */ 
+		gboolean expunge, leave_on_server;
+		const gchar *account_name;
+		TnyAccount *account;
+		
+		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)
+			expunge = TRUE;
 		else
-			/* local folders */
- 			tny_folder_sync_async(folder, TRUE, NULL, NULL, NULL); /* TRUE --> expunge */
+			expunge = FALSE;
+
+		/* Sync folder */
+		tny_folder_sync_async(folder, expunge, NULL, NULL, NULL);
+		
+		g_object_unref (account);
 	}
 	
 	
@@ -2611,6 +2675,21 @@ compute_message_list_size (TnyList *headers)
 	return size;
 }
 
+static guint
+compute_message_array_size (GPtrArray *headers)
+{
+	guint size = 0;
+	gint i;
+
+	for (i = 0; i < headers->len; i++) {
+		TnyHeader *header = TNY_HEADER (g_ptr_array_index (headers, i));
+		size += tny_header_get_message_size (header);
+	}
+
+	return size;
+}
+
+
 void
 modest_mail_operation_xfer_msgs (ModestMailOperation *self,
 				 TnyList *headers, 
@@ -2673,7 +2752,7 @@ modest_mail_operation_xfer_msgs (ModestMailOperation *self,
 		priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
 		g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 			     MODEST_MAIL_OPERATION_ERROR_BAD_PARAMETER,
-			     _("mcen_ib_unable_to_copy_samefolder"));
+			     _("mail_in_ui_folder_copy_target_error"));
 		
 		/* Notify the queue */
 		modest_mail_operation_notify_end (self);