Fix modest_tny_msg_header_get_all_recipients_list (in case from is empty)
[modest] / src / modest-mail-operation.c
1 /* Copyright (c) 2006, Nokia Corporation
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  * * Redistributions of source code must retain the above copyright
9  *   notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above copyright
11  *   notice, this list of conditions and the following disclaimer in the
12  *   documentation and/or other materials provided with the distribution.
13  * * Neither the name of the Nokia Corporation nor the names of its
14  *   contributors may be used to endorse or promote products derived from
15  *   this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include <string.h>
31 #include <stdarg.h>
32 #include <tny-mime-part.h>
33 #include <tny-store-account.h>
34 #include <tny-folder-store.h>
35 #include <tny-folder-store-query.h>
36 #include <tny-camel-stream.h>
37 #include <tny-camel-pop-store-account.h>
38 #include <tny-camel-pop-folder.h>
39 #include <tny-camel-imap-folder.h>
40 #include <tny-camel-mem-stream.h>
41 #include <tny-simple-list.h>
42 #include <tny-send-queue.h>
43 #include <tny-status.h>
44 #include <tny-error.h>
45 #include <tny-folder-observer.h>
46 #include <camel/camel-stream-mem.h>
47 #include <glib/gi18n.h>
48 #include <modest-defs.h>
49 #include "modest-platform.h"
50 #include "modest-account-mgr-helpers.h"
51 #include <modest-tny-account.h>
52 #include <modest-tny-send-queue.h>
53 #include <modest-runtime.h>
54 #include "modest-text-utils.h"
55 #include "modest-tny-msg.h"
56 #include "modest-tny-folder.h"
57 #include "modest-tny-account-store.h"
58 #include "modest-tny-platform-factory.h"
59 #include "modest-marshal.h"
60 #include "modest-error.h"
61 #include "modest-mail-operation.h"
62 #include <modest-count-stream.h>
63 #include <libgnomevfs/gnome-vfs.h>
64 #include "modest-utils.h"
65 #include "modest-debug.h"
66 #ifdef MODEST_USE_LIBTIME
67 #include <clockd/libtime.h>
68 #endif
69
70 #define KB 1024
71
72 /* 
73  * Remove all these #ifdef stuff when the tinymail's idle calls become
74  * locked
75  */
76 #define TINYMAIL_IDLES_NOT_LOCKED_YET 1
77
78 /* 'private'/'protected' functions */
79 static void modest_mail_operation_class_init (ModestMailOperationClass *klass);
80 static void modest_mail_operation_init       (ModestMailOperation *obj);
81 static void modest_mail_operation_finalize   (GObject *obj);
82
83 static void     get_msg_async_cb (TnyFolder *folder, 
84                                   gboolean cancelled, 
85                                   TnyMsg *msg, 
86                                   GError *rr, 
87                                   gpointer user_data);
88
89 static void     get_msg_status_cb (GObject *obj,
90                                    TnyStatus *status,  
91                                    gpointer user_data);
92
93 static void     modest_mail_operation_notify_start (ModestMailOperation *self);
94 static void     modest_mail_operation_notify_end (ModestMailOperation *self);
95
96 static void     notify_progress_of_multiple_messages (ModestMailOperation *self,
97                                                       TnyStatus *status,
98                                                       gint *last_total_bytes,
99                                                       gint *sum_total_bytes,
100                                                       gint total_bytes,
101                                                       gboolean increment_done);
102
103 static guint    compute_message_list_size (TnyList *headers, guint num_elements);
104
105 static int      compare_headers_by_date   (gconstpointer a,
106                                            gconstpointer b);
107
108 static void     sync_folder_finish_callback (TnyFolder *self, 
109                                              gboolean cancelled, 
110                                              GError *err, 
111                                              gpointer user_data);
112
113 static gboolean _check_memory_low         (ModestMailOperation *mail_op);
114
115
116 typedef struct {
117         ModestTnySendQueue *queue;
118         ModestMailOperation *self;
119         guint error_handler;
120         guint start_handler;
121         guint stop_handler;
122 } RunQueueHelper;
123
124 static void run_queue_notify_and_destroy (RunQueueHelper *helper,
125                                           ModestMailOperationStatus status);
126
127 /* Helpers for the update account operation (send & receive)*/
128 typedef struct 
129 {
130         ModestMailOperation *mail_op;
131         gchar *account_name;
132         UpdateAccountCallback callback;
133         gpointer user_data;
134         TnyList *folders;
135         gint pending_calls;
136         gboolean poke_all;
137         TnyFolderObserver *inbox_observer;
138         RetrieveAllCallback retrieve_all_cb;
139         gboolean interactive;
140         gboolean msg_readed;
141 } UpdateAccountInfo;
142
143 static void destroy_update_account_info         (UpdateAccountInfo *info);
144
145 static void update_account_send_mail            (UpdateAccountInfo *info);
146
147 static void update_account_get_msg_async_cb     (TnyFolder *folder, 
148                                                  gboolean canceled, 
149                                                  TnyMsg *msg, 
150                                                  GError *err, 
151                                                  gpointer user_data);
152
153 static void update_account_notify_user_and_free (UpdateAccountInfo *info, 
154                                                  TnyList *new_headers);
155
156 enum _ModestMailOperationSignals 
157 {
158         PROGRESS_CHANGED_SIGNAL,
159         OPERATION_STARTED_SIGNAL,
160         OPERATION_FINISHED_SIGNAL,
161         NUM_SIGNALS
162 };
163
164 typedef struct _ModestMailOperationPrivate ModestMailOperationPrivate;
165 struct _ModestMailOperationPrivate {
166         TnyAccount                *account;
167         guint                      done;
168         guint                      total;
169         GObject                   *source;
170         GError                    *error;
171         ErrorCheckingUserCallback  error_checking;
172         gpointer                   error_checking_user_data;
173         ErrorCheckingUserDataDestroyer error_checking_user_data_destroyer;
174         ModestMailOperationStatus  status;      
175         ModestMailOperationTypeOperation op_type;
176 };
177
178 #define MODEST_MAIL_OPERATION_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
179                                                    MODEST_TYPE_MAIL_OPERATION, \
180                                                    ModestMailOperationPrivate))
181
182 #define CHECK_EXCEPTION(priv, new_status)  if (priv->error) {\
183                                                    priv->status = new_status;\
184                                                }
185
186
187 typedef struct {
188         GetMsgAsyncUserCallback user_callback;
189         TnyHeader *header;
190         TnyIterator *more_msgs;
191         gpointer user_data;
192         ModestMailOperation *mail_op;
193         GDestroyNotify destroy_notify;
194         gint last_total_bytes;
195         gint sum_total_bytes;
196         gint total_bytes;
197 } GetMsgInfo;
198
199 typedef struct _RefreshAsyncHelper {    
200         ModestMailOperation *mail_op;
201         RefreshAsyncUserCallback user_callback; 
202         gpointer user_data;
203 } RefreshAsyncHelper;
204
205 typedef struct _XFerMsgsAsyncHelper
206 {
207         ModestMailOperation *mail_op;
208         TnyList *headers;
209         TnyIterator *more_msgs;
210         TnyFolder *dest_folder;
211         XferMsgsAsyncUserCallback user_callback;        
212         gboolean delete;
213         gpointer user_data;
214         gint last_total_bytes;
215         gint sum_total_bytes;
216         gint total_bytes;
217 } XFerMsgsAsyncHelper;
218
219 typedef struct _XFerFolderAsyncHelper
220 {
221         ModestMailOperation *mail_op;
222         XferFolderAsyncUserCallback user_callback;      
223         gpointer user_data;
224 } XFerFolderAsyncHelper;
225
226 typedef void (*ModestMailOperationCreateMsgCallback) (ModestMailOperation *mail_op,
227                                                       TnyMsg *msg,
228                                                       gpointer userdata);
229
230 static void          modest_mail_operation_create_msg (ModestMailOperation *self,
231                                                        const gchar *from, const gchar *to,
232                                                        const gchar *cc, const gchar *bcc,
233                                                        const gchar *subject, const gchar *plain_body,
234                                                        const gchar *html_body, const GList *attachments_list,
235                                                        const GList *images_list,
236                                                        TnyHeaderFlags priority_flags,
237                                                        const gchar *references, const gchar *in_reply_to,
238                                                        ModestMailOperationCreateMsgCallback callback,
239                                                        gpointer userdata);
240
241 static gboolean      idle_notify_queue (gpointer data);
242 typedef struct
243 {
244         ModestMailOperation *mail_op;
245         gchar *from;
246         gchar *to;
247         gchar *cc;
248         gchar *bcc;
249         gchar *subject;
250         gchar *references;
251         gchar *in_reply_to;
252         gchar *plain_body;
253         gchar *html_body;
254         GList *attachments_list;
255         GList *images_list;
256         TnyHeaderFlags priority_flags;
257         ModestMailOperationCreateMsgCallback callback;
258         gpointer userdata;
259 } CreateMsgInfo;
260
261 typedef struct
262 {
263         ModestMailOperation *mail_op;
264         TnyMsg *msg;
265         ModestMailOperationCreateMsgCallback callback;
266         gpointer userdata;
267 } CreateMsgIdleInfo;
268
269 /* globals */
270 static GObjectClass *parent_class = NULL;
271
272 static guint signals[NUM_SIGNALS] = {0};
273
274 GType
275 modest_mail_operation_get_type (void)
276 {
277         static GType my_type = 0;
278         if (!my_type) {
279                 static const GTypeInfo my_info = {
280                         sizeof(ModestMailOperationClass),
281                         NULL,           /* base init */
282                         NULL,           /* base finalize */
283                         (GClassInitFunc) modest_mail_operation_class_init,
284                         NULL,           /* class finalize */
285                         NULL,           /* class data */
286                         sizeof(ModestMailOperation),
287                         1,              /* n_preallocs */
288                         (GInstanceInitFunc) modest_mail_operation_init,
289                         NULL
290                 };
291                 my_type = g_type_register_static (G_TYPE_OBJECT,
292                                                   "ModestMailOperation",
293                                                   &my_info, 0);
294         }
295         return my_type;
296 }
297
298 static void
299 modest_mail_operation_class_init (ModestMailOperationClass *klass)
300 {
301         GObjectClass *gobject_class;
302         gobject_class = (GObjectClass*) klass;
303
304         parent_class            = g_type_class_peek_parent (klass);
305         gobject_class->finalize = modest_mail_operation_finalize;
306
307         g_type_class_add_private (gobject_class, sizeof(ModestMailOperationPrivate));
308
309         /**
310          * ModestMailOperation::progress-changed
311          * @self: the #MailOperation that emits the signal
312          * @user_data: user data set when the signal handler was connected
313          *
314          * Emitted when the progress of a mail operation changes
315          */
316         signals[PROGRESS_CHANGED_SIGNAL] = 
317                 g_signal_new ("progress-changed",
318                               G_TYPE_FROM_CLASS (gobject_class),
319                               G_SIGNAL_RUN_FIRST,
320                               G_STRUCT_OFFSET (ModestMailOperationClass, progress_changed),
321                               NULL, NULL,
322                               g_cclosure_marshal_VOID__POINTER,
323                               G_TYPE_NONE, 1, G_TYPE_POINTER);
324         /**
325          * operation-started
326          *
327          * This signal is issued whenever a mail operation starts, and
328          * starts mean when the tinymail operation is issued. This
329          * means that it could happen that something wrong happens and
330          * the tinymail function is never called. In this situation a
331          * operation-finished will be issued without any
332          * operation-started
333          */
334         signals[OPERATION_STARTED_SIGNAL] =
335                 g_signal_new ("operation-started",
336                               G_TYPE_FROM_CLASS (gobject_class),
337                               G_SIGNAL_RUN_FIRST,
338                               G_STRUCT_OFFSET (ModestMailOperationClass, operation_started),
339                               NULL, NULL,
340                               g_cclosure_marshal_VOID__VOID,
341                               G_TYPE_NONE, 0);
342         /**
343          * operation-started
344          *
345          * This signal is issued whenever a mail operation
346          * finishes. Note that this signal could be issued without any
347          * previous "operation-started" signal, because this last one
348          * is only issued when the tinymail operation is successfully
349          * started
350          */
351         signals[OPERATION_FINISHED_SIGNAL] =
352                 g_signal_new ("operation-finished",
353                               G_TYPE_FROM_CLASS (gobject_class),
354                               G_SIGNAL_RUN_FIRST,
355                               G_STRUCT_OFFSET (ModestMailOperationClass, operation_finished),
356                               NULL, NULL,
357                               g_cclosure_marshal_VOID__VOID,
358                               G_TYPE_NONE, 0);
359 }
360
361 static void
362 modest_mail_operation_init (ModestMailOperation *obj)
363 {
364         ModestMailOperationPrivate *priv;
365
366         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
367
368         priv->account        = NULL;
369         priv->status         = MODEST_MAIL_OPERATION_STATUS_INVALID;
370         priv->op_type        = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
371         priv->error          = NULL;
372         priv->done           = 0;
373         priv->total          = 0;
374         priv->source         = NULL;
375         priv->error_checking = NULL;
376         priv->error_checking_user_data = NULL;
377 }
378
379 static void
380 modest_mail_operation_finalize (GObject *obj)
381 {
382         ModestMailOperationPrivate *priv;
383
384         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
385
386         
387         
388         if (priv->error) {
389                 g_error_free (priv->error);
390                 priv->error = NULL;
391         }
392         if (priv->source) {
393                 g_object_unref (priv->source);
394                 priv->source = NULL;
395         }
396         if (priv->account) {
397                 g_object_unref (priv->account);
398                 priv->account = NULL;
399         }
400
401
402         G_OBJECT_CLASS(parent_class)->finalize (obj);
403 }
404
405 ModestMailOperation*
406 modest_mail_operation_new (GObject *source)
407 {
408         ModestMailOperation *obj;
409         ModestMailOperationPrivate *priv;
410                 
411         obj = MODEST_MAIL_OPERATION(g_object_new(MODEST_TYPE_MAIL_OPERATION, NULL));
412         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
413
414         if (source != NULL)
415                 priv->source = g_object_ref(source);
416
417         return obj;
418 }
419
420 ModestMailOperation*
421 modest_mail_operation_new_with_error_handling (GObject *source,
422                                                ErrorCheckingUserCallback error_handler,
423                                                gpointer user_data,
424                                                ErrorCheckingUserDataDestroyer error_handler_destroyer)
425 {
426         ModestMailOperation *obj;
427         ModestMailOperationPrivate *priv;
428                 
429         obj = modest_mail_operation_new (source);
430         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
431         
432         g_return_val_if_fail (error_handler != NULL, obj);
433         priv->error_checking = error_handler;
434         priv->error_checking_user_data = user_data;
435         priv->error_checking_user_data_destroyer = error_handler_destroyer;
436
437         return obj;
438 }
439
440 void
441 modest_mail_operation_execute_error_handler (ModestMailOperation *self)
442 {
443         ModestMailOperationPrivate *priv;
444
445         g_return_if_fail (self && MODEST_IS_MAIL_OPERATION(self));
446         
447         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
448         g_return_if_fail(priv->status != MODEST_MAIL_OPERATION_STATUS_SUCCESS);     
449
450         /* Call the user callback */
451         if (priv->error_checking != NULL)
452                 priv->error_checking (self, priv->error_checking_user_data);
453 }
454
455
456 ModestMailOperationTypeOperation
457 modest_mail_operation_get_type_operation (ModestMailOperation *self)
458 {
459         ModestMailOperationPrivate *priv;
460
461         g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
462                               MODEST_MAIL_OPERATION_TYPE_UNKNOWN);
463         
464         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
465         
466         return priv->op_type;
467 }
468
469 gboolean 
470 modest_mail_operation_is_mine (ModestMailOperation *self, 
471                                GObject *me)
472 {
473         ModestMailOperationPrivate *priv;
474
475         g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
476                               FALSE);
477         
478         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
479         if (priv->source == NULL) return FALSE;
480
481         return priv->source == me;
482 }
483
484 GObject *
485 modest_mail_operation_get_source (ModestMailOperation *self)
486 {
487         ModestMailOperationPrivate *priv;
488
489         g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
490                               NULL);
491         
492         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
493         if (!priv) {
494                 g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
495                 return NULL;
496         }
497         
498         return (priv->source) ? g_object_ref (priv->source) : NULL;
499 }
500
501 ModestMailOperationStatus
502 modest_mail_operation_get_status (ModestMailOperation *self)
503 {
504         ModestMailOperationPrivate *priv;
505
506         g_return_val_if_fail (self, MODEST_MAIL_OPERATION_STATUS_INVALID);
507         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self),
508                               MODEST_MAIL_OPERATION_STATUS_INVALID);
509
510         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
511         if (!priv) {
512                 g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
513                 return MODEST_MAIL_OPERATION_STATUS_INVALID;
514         }
515         
516         return priv->status;
517 }
518
519 const GError *
520 modest_mail_operation_get_error (ModestMailOperation *self)
521 {
522         ModestMailOperationPrivate *priv;
523
524         g_return_val_if_fail (self, NULL);
525         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), NULL);
526
527         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
528
529         if (!priv) {
530                 g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
531                 return NULL;
532         }
533
534         return priv->error;
535 }
536
537 gboolean 
538 modest_mail_operation_cancel (ModestMailOperation *self)
539 {
540         ModestMailOperationPrivate *priv;
541         gboolean canceled = FALSE;
542         
543         g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION (self), FALSE);
544
545         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
546
547         /* Set new status */
548         priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
549         
550         /* Cancel the mail operation */
551         g_return_val_if_fail (priv->account, FALSE);
552         tny_account_cancel (priv->account);
553
554         if (priv->op_type == MODEST_MAIL_OPERATION_TYPE_SEND) {
555                 ModestTnySendQueue *queue;
556                 queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (priv->account),
557                                                        TRUE);
558
559                 /* Cancel the sending of the following next messages */
560                 if (TNY_IS_SEND_QUEUE (queue))
561                         tny_send_queue_cancel (TNY_SEND_QUEUE (queue), TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, NULL);
562         }
563         
564         return canceled;
565 }
566
567 guint 
568 modest_mail_operation_get_task_done (ModestMailOperation *self)
569 {
570         ModestMailOperationPrivate *priv;
571
572         g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
573                               0);
574         
575         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
576         return priv->done;
577 }
578
579 guint 
580 modest_mail_operation_get_task_total (ModestMailOperation *self)
581 {
582         ModestMailOperationPrivate *priv;
583
584         g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
585                               0);
586
587         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
588         return priv->total;
589 }
590
591 gboolean
592 modest_mail_operation_is_finished (ModestMailOperation *self)
593 {
594         ModestMailOperationPrivate *priv;
595         gboolean retval = FALSE;
596
597         g_return_val_if_fail (self && MODEST_IS_MAIL_OPERATION(self),
598                               FALSE);
599         
600         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
601
602         if (priv->status == MODEST_MAIL_OPERATION_STATUS_SUCCESS   ||
603             priv->status == MODEST_MAIL_OPERATION_STATUS_FAILED    ||
604             priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED  ||
605             priv->status == MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS) {
606                 retval = TRUE;
607         } else {
608                 retval = FALSE;
609         }
610
611         return retval;
612 }
613
614 /*
615  * Creates an image of the current state of a mail operation, the
616  * caller must free it
617  */
618 static ModestMailOperationState *
619 modest_mail_operation_clone_state (ModestMailOperation *self)
620 {
621         ModestMailOperationState *state;
622         ModestMailOperationPrivate *priv;
623
624         g_return_val_if_fail (self, NULL);
625         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
626         g_return_val_if_fail (priv, NULL);
627
628         if (!priv)
629                 return NULL;
630
631         state = g_slice_new (ModestMailOperationState);
632
633         state->status = priv->status;
634         state->op_type = priv->op_type;
635         state->done = priv->done;
636         state->total = priv->total;
637         state->finished = modest_mail_operation_is_finished (self);
638         state->bytes_done = 0;
639         state->bytes_total = 0;
640
641         return state;
642 }
643
644 /* ******************************************************************* */
645 /* ************************** SEND   ACTIONS ************************* */
646 /* ******************************************************************* */
647
648 typedef struct 
649 {
650         ModestMailOperation *mail_op;
651         gboolean notify;
652 } SendNewMailHelper;
653
654 static void
655 send_mail_on_sync_async_cb (TnyFolder *folder, 
656                             gboolean cancelled, 
657                             GError *err, 
658                             gpointer user_data)
659 {
660         ModestMailOperationPrivate *priv;
661         ModestMailOperation *self;
662         SendNewMailHelper *helper;
663
664         helper = (SendNewMailHelper *) user_data;
665         self = helper->mail_op;
666         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
667
668         if (cancelled)
669                 goto end;
670
671         if (err) {
672                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
673                              MODEST_MAIL_OPERATION_ERROR_SEND_QUEUE_ADD_ERROR,
674                              "Error adding a msg to the send queue\n");
675                 priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
676         } else {
677                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
678         }
679
680  end:
681         if (helper->notify)
682                 modest_mail_operation_notify_end (self);
683
684         g_object_unref (helper->mail_op);
685         g_slice_free (SendNewMailHelper, helper);
686 }
687
688 static void
689 run_queue_start (TnySendQueue *self,
690                  gpointer user_data)
691 {
692         RunQueueHelper *helper = (RunQueueHelper *) user_data;
693         ModestMailOperation *mail_op;
694                         
695         g_debug ("%s sending queue successfully started", __FUNCTION__);
696
697         /* Wait for the message to be sent */
698         mail_op = modest_mail_operation_new (NULL);
699         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
700                                          mail_op);
701         modest_mail_operation_run_queue (mail_op, helper->queue);
702         g_object_unref (mail_op);
703
704         /* Free the helper and end operation */
705         run_queue_notify_and_destroy (helper, MODEST_MAIL_OPERATION_STATUS_SUCCESS);
706 }
707
708 static void 
709 run_queue_error_happened (TnySendQueue *queue, 
710                           TnyHeader *header, 
711                           TnyMsg *msg, 
712                           GError *error, 
713                           gpointer user_data)
714 {
715         RunQueueHelper *helper = (RunQueueHelper *) user_data;
716         ModestMailOperationPrivate *priv;
717
718         /* If we are here this means that the send queue could not
719            start to send emails. Shouldn't happen as this means that
720            we could not create the thread */
721         g_debug ("%s sending queue failed to create the thread", __FUNCTION__);
722
723         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (helper->self);
724         priv->error = g_error_copy ((const GError *) error);
725
726         if (error->code != TNY_SYSTEM_ERROR_UNKNOWN) {
727                 /* This code is here for safety reasons. It should
728                    never be called, because that would mean that we
729                    are not controlling some error case */
730                 g_warning ("%s Error %s should not happen", 
731                            __FUNCTION__, error->message);
732         }
733
734         /* Free helper and end operation */
735         run_queue_notify_and_destroy (helper, MODEST_MAIL_OPERATION_STATUS_FAILED);
736 }
737
738 static void
739 send_mail_on_added_to_outbox (TnySendQueue *send_queue, 
740                               gboolean cancelled, 
741                               TnyMsg *msg, 
742                               GError *err,
743                               gpointer user_data)
744 {
745         ModestMailOperationPrivate *priv;
746         ModestMailOperation *self;
747         SendNewMailHelper *helper;
748
749         helper = (SendNewMailHelper *) user_data;
750         self = helper->mail_op;
751         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
752
753         if (cancelled)
754                 goto end;
755
756         if (err) {
757                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
758                              MODEST_MAIL_OPERATION_ERROR_SEND_QUEUE_ADD_ERROR,
759                              "Error adding a msg to the send queue\n");
760                 priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
761         } else {
762                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
763         }
764
765  end:
766         if (helper->notify) {
767                 TnyTransportAccount *trans_account;
768                 ModestTnySendQueue *queue;
769
770                 trans_account = (TnyTransportAccount *) modest_mail_operation_get_account (self);
771                 if (trans_account) {
772                         queue = modest_runtime_get_send_queue (trans_account, TRUE);
773                         if (queue) {
774                                 RunQueueHelper *helper;
775
776                                 /* Create the helper */
777                                 helper = g_slice_new0 (RunQueueHelper);
778                                 helper->queue = g_object_ref (queue);
779                                 helper->self = g_object_ref (self);
780
781                                 /* if sending is ongoing wait for the queue to
782                                    stop. Otherwise wait for the queue-start
783                                    signal. It could happen that the queue
784                                    could not start, then check also the error
785                                    happened signal */
786                                 if (modest_tny_send_queue_sending_in_progress (queue)) {
787                                         run_queue_start (TNY_SEND_QUEUE (queue), helper);
788                                 } else {
789                                         helper->start_handler = g_signal_connect (queue, "queue-start", 
790                                                                                   G_CALLBACK (run_queue_start), 
791                                                                                   helper);
792                                         helper->error_handler = g_signal_connect (queue, "error-happened", 
793                                                                                   G_CALLBACK (run_queue_error_happened), 
794                                                                                   helper);
795                                 }
796                         } else {
797                                 /* Finalize this mail operation */
798                                 modest_mail_operation_notify_end (self);
799                         }
800                         g_object_unref (trans_account);
801                 } else {
802                         g_warning ("No transport account for the operation");
803                 }
804         }
805
806         g_object_unref (helper->mail_op);
807         g_slice_free (SendNewMailHelper, helper);
808 }
809
810 static gboolean
811 idle_create_msg_cb (gpointer idle_data)
812 {
813         CreateMsgIdleInfo *info = (CreateMsgIdleInfo *) idle_data;
814
815         /* This is a GDK lock because we are an idle callback and
816          * info->callback can contain Gtk+ code */
817
818         gdk_threads_enter (); /* CHECKED */
819         info->callback (info->mail_op, info->msg, info->userdata);
820
821         g_object_unref (info->mail_op);
822         if (info->msg)
823                 g_object_unref (info->msg);
824         g_slice_free (CreateMsgIdleInfo, info);
825         gdk_threads_leave (); /* CHECKED */
826
827         return FALSE;
828 }
829
830 static gpointer 
831 create_msg_thread (gpointer thread_data)
832 {
833         CreateMsgInfo *info = (CreateMsgInfo *) thread_data;
834         TnyMsg *new_msg = NULL;
835         ModestMailOperationPrivate *priv;
836         gint attached = 0;
837
838         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mail_op);
839         if (info->html_body == NULL) {
840                 new_msg = modest_tny_msg_new (info->to, info->from, info->cc, 
841                                               info->bcc, info->subject, 
842                                               info->references, info->in_reply_to,
843                                               info->plain_body, 
844                                               info->attachments_list, &attached,
845                                               &(priv->error));
846         } else {
847                 new_msg = modest_tny_msg_new_html_plain (info->to, info->from, info->cc,
848                                                          info->bcc, info->subject, 
849                                                          info->references, info->in_reply_to,
850                                                          info->html_body,
851                                                          info->plain_body, info->attachments_list,
852                                                          info->images_list, &attached,
853                                                          &(priv->error));
854         }
855
856         if (new_msg) {
857                 TnyHeader *header;
858
859                 /* Set priority flags in message */
860                 header = tny_msg_get_header (new_msg);
861                 tny_header_set_flag (header, info->priority_flags);
862
863                 /* Set attachment flags in message */
864                 if (info->attachments_list != NULL && attached > 0)
865                         tny_header_set_flag (header, TNY_HEADER_FLAG_ATTACHMENTS);
866
867                 g_object_unref (G_OBJECT(header));
868         } else {
869                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
870                 if (!priv->error)
871                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
872                                      MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
873                                      "modest: failed to create a new msg\n");
874         }
875
876
877         g_free (info->to);
878         g_free (info->from);
879         g_free (info->cc);
880         g_free (info->bcc);
881         g_free (info->plain_body);
882         g_free (info->html_body);
883         g_free (info->subject);
884         g_free (info->references);
885         g_free (info->in_reply_to);
886         g_list_foreach (info->attachments_list, (GFunc) g_object_unref, NULL);
887         g_list_free (info->attachments_list);
888         g_list_foreach (info->images_list, (GFunc) g_object_unref, NULL);
889         g_list_free (info->images_list);
890
891         if (info->callback) {
892                 CreateMsgIdleInfo *idle_info;
893                 idle_info = g_slice_new0 (CreateMsgIdleInfo);
894                 idle_info->mail_op = g_object_ref (info->mail_op);
895                 idle_info->msg = (new_msg) ? g_object_ref (new_msg) : NULL;
896                 idle_info->callback = info->callback;
897                 idle_info->userdata = info->userdata;
898                 g_idle_add (idle_create_msg_cb, idle_info);
899         } else {
900                 g_idle_add (idle_notify_queue, g_object_ref (info->mail_op));
901         }
902
903         g_object_unref (info->mail_op);
904         g_slice_free (CreateMsgInfo, info);
905         if (new_msg) g_object_unref(new_msg);
906         return NULL;
907 }
908
909
910 void
911 modest_mail_operation_create_msg (ModestMailOperation *self,
912                                   const gchar *from, const gchar *to,
913                                   const gchar *cc, const gchar *bcc,
914                                   const gchar *subject, const gchar *plain_body,
915                                   const gchar *html_body,
916                                   const GList *attachments_list,
917                                   const GList *images_list,
918                                   TnyHeaderFlags priority_flags,
919                                   const gchar *references,
920                                   const gchar *in_reply_to,
921                                   ModestMailOperationCreateMsgCallback callback,
922                                   gpointer userdata)
923 {
924         CreateMsgInfo *info = NULL;
925
926         info = g_slice_new0 (CreateMsgInfo);
927         info->mail_op = g_object_ref (self);
928
929         info->from = g_strdup (from);
930         info->to = g_strdup (to);
931         info->cc = g_strdup (cc);
932         info->bcc  = g_strdup (bcc);
933         info->subject = g_strdup (subject);
934         info->plain_body = g_strdup (plain_body);
935         info->html_body = g_strdup (html_body);
936         info->references = g_strdup (references);
937         info->in_reply_to = g_strdup (in_reply_to);
938         info->attachments_list = g_list_copy ((GList *) attachments_list);
939         g_list_foreach (info->attachments_list, (GFunc) g_object_ref, NULL);
940         info->images_list = g_list_copy ((GList *) images_list);
941         g_list_foreach (info->images_list, (GFunc) g_object_ref, NULL);
942         info->priority_flags = priority_flags;
943
944         info->callback = callback;
945         info->userdata = userdata;
946
947         g_thread_create (create_msg_thread, info, FALSE, NULL);
948 }
949
950 typedef struct
951 {
952         TnyTransportAccount *transport_account;
953         TnyMsg *draft_msg;
954 } SendNewMailInfo;
955
956 static void
957 modest_mail_operation_send_new_mail_cb (ModestMailOperation *self,
958                                         TnyMsg *msg,
959                                         gpointer userdata)
960 {
961         TnySendQueue *send_queue = NULL;
962         ModestMailOperationPrivate *priv = NULL;
963         SendNewMailInfo *info = (SendNewMailInfo *) userdata;
964         TnyFolder *draft_folder = NULL;
965         TnyFolder *outbox_folder = NULL;
966         TnyHeader *header = NULL;
967
968         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
969
970         if (!msg) {
971                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
972                 modest_mail_operation_notify_end (self);
973                 goto end;
974         }
975
976         if (priv->error && priv->error->code != MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
977                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
978                 modest_mail_operation_notify_end (self);
979                 goto end;
980         }
981
982         /* Add message to send queue */
983         send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (info->transport_account, TRUE));
984         if (!TNY_IS_SEND_QUEUE(send_queue)) {
985                 if (priv->error) {
986                         g_error_free (priv->error);
987                         priv->error = NULL;
988                 }
989                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
990                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
991                              "modest: could not find send queue for account\n");
992                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
993                 modest_mail_operation_notify_end (self);
994                 goto end;
995         } else {
996                 SendNewMailHelper *helper = g_slice_new (SendNewMailHelper);
997                 helper->mail_op = g_object_ref (self);
998                 helper->notify = (info->draft_msg == NULL);
999
1000                 /* Add the msg to the queue. The callback will free
1001                    the helper */
1002                 modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue), 
1003                                                                   FALSE);
1004                 tny_send_queue_add_async (send_queue, msg, send_mail_on_added_to_outbox, 
1005                                           NULL, helper);
1006         }
1007
1008         if (info->draft_msg != NULL) {
1009                 TnyList *tmp_headers = NULL;
1010                 TnyFolder *folder = NULL;
1011                 TnyFolder *src_folder = NULL;
1012                 TnyFolderType folder_type;              
1013                 TnyTransportAccount *transport_account = NULL;
1014                 SendNewMailHelper *helper = NULL;
1015
1016                 /* To remove the old mail from its source folder, we need to get the
1017                  * transport account of the original draft message (the transport account
1018                  * might have been changed by the user) */
1019                 header = tny_msg_get_header (info->draft_msg);
1020                 transport_account = modest_tny_account_store_get_transport_account_from_outbox_header(
1021                         modest_runtime_get_account_store(), header);
1022                 if (transport_account == NULL)
1023                         transport_account = g_object_ref(info->transport_account);
1024                 draft_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account),
1025                                                                       TNY_FOLDER_TYPE_DRAFTS);
1026                 outbox_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account),
1027                                                                        TNY_FOLDER_TYPE_OUTBOX);
1028                 g_object_unref(transport_account);
1029
1030                 if (!draft_folder) {
1031                         g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL drafts folder",
1032                                    __FUNCTION__);
1033                         modest_mail_operation_notify_end (self);
1034                         goto end;
1035                 }
1036                 if (!outbox_folder) {
1037                         g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL outbox folder",
1038                                    __FUNCTION__);
1039                         modest_mail_operation_notify_end (self);
1040                         goto end;
1041                 }
1042
1043                 folder = tny_msg_get_folder (info->draft_msg);          
1044                 if (folder == NULL) {
1045                         modest_mail_operation_notify_end (self);
1046                         goto end;
1047                 }
1048                 folder_type = modest_tny_folder_guess_folder_type (folder);
1049
1050                 if (folder_type == TNY_FOLDER_TYPE_INVALID)
1051                         g_warning ("%s: BUG: folder of type TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
1052                 
1053                 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) 
1054                         src_folder = outbox_folder;
1055                 else 
1056                         src_folder = draft_folder;
1057
1058                 /* Note: This can fail (with a warning) if the message is not really already in a folder,
1059                  * because this function requires it to have a UID. */
1060                 helper = g_slice_new (SendNewMailHelper);
1061                 helper->mail_op = g_object_ref (self);
1062                 helper->notify = TRUE;
1063
1064                 tmp_headers = tny_simple_list_new ();
1065                 tny_list_append (tmp_headers, (GObject*) header);
1066                 tny_folder_remove_msgs_async (src_folder, tmp_headers, NULL, NULL, NULL);
1067                 g_object_unref (tmp_headers);
1068                 tny_folder_sync_async (src_folder, TRUE, send_mail_on_sync_async_cb, 
1069                                        NULL, helper);
1070                 g_object_unref (folder);
1071         }
1072
1073 end:
1074         if (header)
1075                 g_object_unref (header);
1076         if (info->draft_msg)
1077                 g_object_unref (info->draft_msg);
1078         if (draft_folder)
1079                 g_object_unref (draft_folder);
1080         if (outbox_folder)
1081                 g_object_unref (outbox_folder);
1082         if (info->transport_account)
1083                 g_object_unref (info->transport_account);
1084         g_slice_free (SendNewMailInfo, info);
1085 }
1086
1087 void
1088 modest_mail_operation_send_new_mail (ModestMailOperation *self,
1089                                      TnyTransportAccount *transport_account,
1090                                      TnyMsg *draft_msg,
1091                                      const gchar *from,  const gchar *to,
1092                                      const gchar *cc,  const gchar *bcc,
1093                                      const gchar *subject, const gchar *plain_body,
1094                                      const gchar *html_body,
1095                                      const GList *attachments_list,
1096                                      const GList *images_list,
1097                                      const gchar *references,
1098                                      const gchar *in_reply_to,
1099                                      TnyHeaderFlags priority_flags)
1100 {
1101         ModestMailOperationPrivate *priv = NULL;
1102         SendNewMailInfo *info;
1103
1104         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
1105         g_return_if_fail (TNY_IS_TRANSPORT_ACCOUNT (transport_account));
1106
1107         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1108         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND;
1109         priv->account = TNY_ACCOUNT (g_object_ref (transport_account));
1110         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
1111
1112         modest_mail_operation_notify_start (self);
1113
1114         /* Check parametters */
1115         if (to == NULL) {
1116                 /* Set status failed and set an error */
1117                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1118                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1119                              MODEST_MAIL_OPERATION_ERROR_BAD_PARAMETER,
1120                              _("Error trying to send a mail. You need to set at least one recipient"));
1121                 modest_mail_operation_notify_end (self);
1122                 return;
1123         }
1124         info = g_slice_new0 (SendNewMailInfo);
1125         info->transport_account = transport_account;
1126         if (transport_account)
1127                 g_object_ref (transport_account);
1128         info->draft_msg = draft_msg;
1129         if (draft_msg)
1130                 g_object_ref (draft_msg);
1131
1132
1133         modest_mail_operation_create_msg (self, from, to, cc, bcc, subject, plain_body, html_body,
1134                                           attachments_list, images_list, priority_flags,
1135                                           references, in_reply_to,
1136                                           modest_mail_operation_send_new_mail_cb, info);
1137
1138 }
1139
1140 typedef struct
1141 {
1142         TnyTransportAccount *transport_account;
1143         TnyMsg *draft_msg;
1144         SaveToDraftstCallback callback;
1145         gpointer user_data;
1146         TnyFolder *drafts;
1147         TnyMsg *msg;
1148         ModestMailOperation *mailop;
1149 } SaveToDraftsAddMsgInfo;
1150
1151 static void
1152 modest_mail_operation_save_to_drafts_add_msg_cb(TnyFolder *self,
1153                                                 gboolean canceled,
1154                                                 GError *err,
1155                                                 gpointer userdata)
1156 {
1157         ModestMailOperationPrivate *priv = NULL;
1158         SaveToDraftsAddMsgInfo *info = (SaveToDraftsAddMsgInfo *) userdata;
1159         GError *io_error = NULL;
1160
1161         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mailop);
1162
1163         if (priv->error && priv->error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1164                 io_error = priv->error;
1165                 priv->error = NULL;
1166         }
1167         if (priv->error) {
1168                 g_warning ("%s: priv->error != NULL", __FUNCTION__);
1169                 g_error_free(priv->error);
1170         }
1171
1172         priv->error = (err == NULL) ? NULL : g_error_copy(err);
1173
1174         if ((!priv->error) && (info->draft_msg != NULL)) {
1175                 TnyHeader *header = tny_msg_get_header (info->draft_msg);
1176                 TnyFolder *src_folder = tny_header_get_folder (header);
1177
1178                 g_debug ("--- REMOVE AND SYNC");
1179                 /* Remove the old draft */
1180                 tny_folder_remove_msg (src_folder, header, NULL);
1181
1182                 /* Synchronize to expunge and to update the msg counts */
1183                 tny_folder_sync_async (info->drafts, TRUE, NULL, NULL, NULL);
1184                 tny_folder_sync_async (src_folder, TRUE, NULL, NULL, NULL);
1185                 g_debug ("--- REMOVED - SYNCED");
1186
1187                 g_object_unref (G_OBJECT(header));
1188                 g_object_unref (G_OBJECT(src_folder));
1189         }
1190
1191         if (priv->error) {
1192                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1193                 if (io_error) {
1194                         g_error_free (io_error);
1195                         io_error = NULL;
1196                 }
1197         } else if (io_error) {
1198                 priv->error = io_error;
1199                 priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
1200         } else {
1201                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1202         }
1203
1204         /* Call the user callback */
1205         if (info->callback)
1206                 info->callback (info->mailop, info->msg, info->user_data);
1207
1208         if (info->transport_account)
1209                 g_object_unref (G_OBJECT(info->transport_account));
1210         if (info->draft_msg)
1211                 g_object_unref (G_OBJECT (info->draft_msg));
1212         if (info->drafts)
1213                 g_object_unref (G_OBJECT(info->drafts));
1214         if (info->msg)
1215                 g_object_unref (G_OBJECT (info->msg));
1216
1217         modest_mail_operation_notify_end (info->mailop);
1218         g_object_unref(info->mailop);
1219         g_slice_free (SaveToDraftsAddMsgInfo, info);
1220 }
1221
1222 typedef struct
1223 {
1224         TnyTransportAccount *transport_account;
1225         TnyMsg *draft_msg;
1226         SaveToDraftstCallback callback;
1227         gpointer user_data;
1228 } SaveToDraftsInfo;
1229
1230 static void
1231 modest_mail_operation_save_to_drafts_cb (ModestMailOperation *self,
1232                                          TnyMsg *msg,
1233                                          gpointer userdata)
1234 {
1235         TnyFolder *drafts = NULL;
1236         ModestMailOperationPrivate *priv = NULL;
1237         SaveToDraftsInfo *info = (SaveToDraftsInfo *) userdata;
1238
1239         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1240
1241         if (!msg) {
1242                 if (!(priv->error)) {
1243                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1244                                      MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
1245                                      "modest: failed to create a new msg\n");
1246                 }
1247         } else {
1248                 drafts = modest_tny_account_get_special_folder (TNY_ACCOUNT (info->transport_account),
1249                                                                 TNY_FOLDER_TYPE_DRAFTS);
1250                 if (!drafts && !(priv->error)) {
1251                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1252                                      MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1253                                      "modest: failed to create a new msg\n");
1254                 }
1255         }
1256
1257         if (!priv->error || priv->error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1258                 if (drafts) {
1259                         SaveToDraftsAddMsgInfo *cb_info = g_slice_new(SaveToDraftsAddMsgInfo);
1260                         cb_info->transport_account = g_object_ref(info->transport_account);
1261                         cb_info->draft_msg = info->draft_msg ? g_object_ref(info->draft_msg) : NULL;
1262                         cb_info->callback = info->callback;
1263                         cb_info->user_data = info->user_data;
1264                         cb_info->drafts = g_object_ref(drafts);
1265                         cb_info->msg = g_object_ref(msg);
1266                         cb_info->mailop = g_object_ref(self);
1267                         tny_folder_add_msg_async(drafts, msg, modest_mail_operation_save_to_drafts_add_msg_cb,
1268                                                  NULL, cb_info);
1269                 }
1270         } else {
1271                 /* Call the user callback */
1272                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1273                 if (info->callback)
1274                         info->callback (self, msg, info->user_data);
1275                 modest_mail_operation_notify_end (self);
1276         }
1277
1278         if (drafts)
1279                 g_object_unref (G_OBJECT(drafts));
1280         if (info->draft_msg)
1281                 g_object_unref (G_OBJECT (info->draft_msg));
1282         if (info->transport_account)
1283                 g_object_unref (G_OBJECT(info->transport_account));
1284         g_slice_free (SaveToDraftsInfo, info);
1285 }
1286
1287 void
1288 modest_mail_operation_save_to_drafts (ModestMailOperation *self,
1289                                       TnyTransportAccount *transport_account,
1290                                       TnyMsg *draft_msg,
1291                                       const gchar *from,  const gchar *to,
1292                                       const gchar *cc,  const gchar *bcc,
1293                                       const gchar *subject, const gchar *plain_body,
1294                                       const gchar *html_body,
1295                                       const GList *attachments_list,
1296                                       const GList *images_list,
1297                                       TnyHeaderFlags priority_flags,
1298                                       const gchar *references,
1299                                       const gchar *in_reply_to,
1300                                       SaveToDraftstCallback callback,
1301                                       gpointer user_data)
1302 {
1303         ModestMailOperationPrivate *priv = NULL;
1304         SaveToDraftsInfo *info = NULL;
1305
1306         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
1307         g_return_if_fail (TNY_IS_TRANSPORT_ACCOUNT (transport_account));
1308
1309         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1310
1311         /* Get account and set it into mail_operation */
1312         priv->account = g_object_ref (transport_account);
1313         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
1314
1315         info = g_slice_new0 (SaveToDraftsInfo);
1316         info->transport_account = g_object_ref (transport_account);
1317         info->draft_msg = (draft_msg) ? g_object_ref (draft_msg) : NULL;
1318         info->callback = callback;
1319         info->user_data = user_data;
1320
1321         g_debug ("--- CREATE MESSAGE");
1322         modest_mail_operation_notify_start (self);
1323         modest_mail_operation_create_msg (self, from, to, cc, bcc, subject, plain_body, html_body,
1324                                           attachments_list, images_list, priority_flags,
1325                                           references, in_reply_to,
1326                                           modest_mail_operation_save_to_drafts_cb, info);
1327 }
1328
1329 typedef struct
1330 {
1331         ModestMailOperation *mail_op;
1332         TnyMimePart *mime_part;
1333         gssize size;
1334         GetMimePartSizeCallback callback;
1335         gpointer userdata;
1336 } GetMimePartSizeInfo;
1337
1338 /***** I N T E R N A L    F O L D E R    O B S E R V E R *****/
1339 /* We use this folder observer to track the headers that have been
1340  * added to a folder */
1341 typedef struct {
1342         GObject parent;
1343         TnyList *new_headers;
1344 } InternalFolderObserver;
1345
1346 typedef struct {
1347         GObjectClass parent;
1348 } InternalFolderObserverClass;
1349
1350 static void tny_folder_observer_init (TnyFolderObserverIface *idace);
1351
1352 G_DEFINE_TYPE_WITH_CODE (InternalFolderObserver,
1353                          internal_folder_observer,
1354                          G_TYPE_OBJECT,
1355                          G_IMPLEMENT_INTERFACE(TNY_TYPE_FOLDER_OBSERVER, tny_folder_observer_init));
1356
1357
1358 static void
1359 foreach_add_item (gpointer header, gpointer user_data)
1360 {
1361         tny_list_append (TNY_LIST (user_data), G_OBJECT (header));
1362 }
1363
1364 /* This is the method that looks for new messages in a folder */
1365 static void
1366 internal_folder_observer_update (TnyFolderObserver *self, TnyFolderChange *change)
1367 {
1368         InternalFolderObserver *derived = (InternalFolderObserver *)self;
1369         
1370         TnyFolderChangeChanged changed;
1371
1372         changed = tny_folder_change_get_changed (change);
1373
1374         if (changed & TNY_FOLDER_CHANGE_CHANGED_ADDED_HEADERS) {
1375                 TnyList *list;
1376
1377                 /* Get added headers */
1378                 list = tny_simple_list_new ();
1379                 tny_folder_change_get_added_headers (change, list);
1380
1381                 /* Add them to the folder observer */
1382                 tny_list_foreach (list, foreach_add_item, 
1383                                   derived->new_headers);
1384
1385                 g_object_unref (G_OBJECT (list));
1386         }
1387 }
1388
1389 static void
1390 internal_folder_observer_init (InternalFolderObserver *self) 
1391 {
1392         self->new_headers = tny_simple_list_new ();
1393 }
1394 static void
1395 internal_folder_observer_finalize (GObject *object) 
1396 {
1397         InternalFolderObserver *self;
1398
1399         self = (InternalFolderObserver *) object;
1400         g_object_unref (self->new_headers);
1401
1402         G_OBJECT_CLASS (internal_folder_observer_parent_class)->finalize (object);
1403 }
1404 static void
1405 tny_folder_observer_init (TnyFolderObserverIface *iface) 
1406 {
1407         iface->update = internal_folder_observer_update;
1408 }
1409 static void
1410 internal_folder_observer_class_init (InternalFolderObserverClass *klass) 
1411 {
1412         GObjectClass *object_class;
1413
1414         internal_folder_observer_parent_class = g_type_class_peek_parent (klass);
1415         object_class = (GObjectClass*) klass;
1416         object_class->finalize = internal_folder_observer_finalize;
1417 }
1418
1419 static void
1420 destroy_update_account_info (UpdateAccountInfo *info)
1421 {
1422         g_free (info->account_name);
1423         g_object_unref (info->folders);
1424         g_object_unref (info->mail_op);
1425         g_slice_free (UpdateAccountInfo, info);
1426 }
1427
1428
1429 static void
1430 update_account_send_mail (UpdateAccountInfo *info)
1431 {
1432         TnyTransportAccount *transport_account = NULL;
1433         ModestTnyAccountStore *account_store;
1434
1435         account_store = modest_runtime_get_account_store ();
1436
1437         /* We don't try to send messages while sending mails is blocked */
1438         if (modest_tny_account_store_is_send_mail_blocked (account_store))
1439                 return;
1440
1441         /* Get the transport account */
1442         transport_account = (TnyTransportAccount *) 
1443                 modest_tny_account_store_get_server_account (account_store, info->account_name, 
1444                                                              TNY_ACCOUNT_TYPE_TRANSPORT);
1445
1446         if (transport_account) {
1447                 ModestTnySendQueue *send_queue;
1448                 TnyFolder *outbox;
1449                 guint num_messages;
1450
1451                 send_queue = modest_runtime_get_send_queue (transport_account, TRUE);
1452                 g_object_unref (transport_account);
1453
1454                 if (TNY_IS_SEND_QUEUE (send_queue)) {
1455                         /* Get outbox folder */
1456                         outbox = tny_send_queue_get_outbox (TNY_SEND_QUEUE (send_queue));
1457                         if (outbox) { /* this could fail in some cases */
1458                                 num_messages = tny_folder_get_all_count (outbox);
1459                                 g_object_unref (outbox);
1460                         } else {
1461                                 g_warning ("%s: could not get outbox", __FUNCTION__);
1462                                 num_messages = 0;
1463                         }
1464
1465                         if (num_messages != 0) {
1466                                 ModestMailOperation *mail_op;
1467                                 /* Reenable suspended items */
1468                                 mail_op = modest_mail_operation_new (NULL);
1469                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1470                                                                  mail_op);
1471                                 modest_mail_operation_queue_wakeup (mail_op, MODEST_TNY_SEND_QUEUE (send_queue));
1472
1473                                 /* Try to send */
1474                                 modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue), 
1475                                                                                   info->interactive);
1476                         }
1477                 }
1478         }
1479 }
1480
1481 static void
1482 update_account_get_msg_async_cb (TnyFolder *folder, 
1483                                  gboolean canceled, 
1484                                  TnyMsg *msg, 
1485                                  GError *err, 
1486                                  gpointer user_data)
1487 {
1488         GetMsgInfo *msg_info = (GetMsgInfo *) user_data;
1489         ModestMailOperationPrivate *priv;
1490
1491         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (msg_info->mail_op);
1492         priv->done++;
1493
1494         if (TNY_IS_MSG (msg)) {
1495                 TnyHeader *header = tny_msg_get_header (msg);
1496
1497                 if (header) {
1498                         ModestMailOperationState *state;
1499                         state = modest_mail_operation_clone_state (msg_info->mail_op);
1500                         msg_info->sum_total_bytes += tny_header_get_message_size (header);
1501                         state->bytes_done = msg_info->sum_total_bytes;
1502                         state->bytes_total = msg_info->total_bytes;
1503
1504                         /* Notify the status change. Only notify about changes
1505                            referred to bytes */
1506                         g_signal_emit (G_OBJECT (msg_info->mail_op), 
1507                                        signals[PROGRESS_CHANGED_SIGNAL], 
1508                                        0, state, NULL);
1509
1510                         g_object_unref (header);
1511                         g_slice_free (ModestMailOperationState, state);
1512                 }
1513         }
1514
1515         if (priv->done == priv->total) {
1516                 TnyList *new_headers;
1517                 UpdateAccountInfo *info;
1518
1519                 /* After getting all the messages send the ones in the
1520                    outboxes */
1521                 info = (UpdateAccountInfo *) msg_info->user_data;
1522                 update_account_send_mail (info);
1523
1524                 /* Check if the operation was a success */
1525                 if (!priv->error)
1526                         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1527                 
1528                 /* Call the user callback and free */
1529                 new_headers = tny_iterator_get_list (msg_info->more_msgs);
1530                 update_account_notify_user_and_free (info, new_headers);
1531                 g_object_unref (new_headers);
1532
1533                 /* Delete the helper */
1534                 g_object_unref (msg_info->more_msgs);
1535                 g_object_unref (msg_info->mail_op);
1536                 g_slice_free (GetMsgInfo, msg_info);
1537         }
1538 }
1539
1540 static void
1541 update_account_notify_user_and_free (UpdateAccountInfo *info, 
1542                                      TnyList *new_headers)
1543 {
1544         /* Set the account back to not busy */
1545         modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), 
1546                                              info->account_name, FALSE);
1547         
1548         /* User callback */
1549         if (info->callback)
1550                 info->callback (info->mail_op, new_headers, info->user_data);
1551         
1552         /* Mail operation end */
1553         modest_mail_operation_notify_end (info->mail_op);
1554
1555         /* Frees */
1556         if (new_headers)
1557                 g_object_unref (new_headers);
1558         destroy_update_account_info (info);
1559 }
1560
1561 static void
1562 inbox_refreshed_cb (TnyFolder *inbox, 
1563                     gboolean canceled, 
1564                     GError *err, 
1565                     gpointer user_data)
1566 {       
1567         UpdateAccountInfo *info;
1568         ModestMailOperationPrivate *priv;
1569         TnyIterator *new_headers_iter;
1570         GPtrArray *new_headers_array = NULL;
1571         gint max_size, retrieve_limit, i;
1572         ModestAccountMgr *mgr;
1573         ModestAccountRetrieveType retrieve_type;
1574         TnyList *new_headers = NULL;
1575         gboolean headers_only, ignore_limit;
1576         time_t time_to_store;
1577
1578         info = (UpdateAccountInfo *) user_data;
1579         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
1580         mgr = modest_runtime_get_account_mgr ();
1581
1582         if (canceled || err) {
1583                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1584                 if (err)
1585                         priv->error = g_error_copy (err);
1586                 else
1587                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1588                                      MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
1589                                      "canceled");
1590
1591                 if (inbox)
1592                         tny_folder_remove_observer (inbox, info->inbox_observer);
1593                 g_object_unref (info->inbox_observer);
1594                 info->inbox_observer = NULL;
1595
1596                 /* Notify the user about the error and then exit */
1597                 update_account_notify_user_and_free (info, NULL);
1598                 return;
1599         }
1600
1601         if (!inbox) {
1602                 /* Try to send anyway */
1603                 goto send_mail;
1604         }
1605
1606         /* Set the last updated as the current time */
1607 #ifdef MODEST_USE_LIBTIME
1608         struct tm utc_tm;
1609         time_get_utc (&utc_tm);
1610         time_to_store = time_mktime (&utc_tm, "GMT");
1611 #else
1612         time_to_store = time (NULL);
1613 #endif
1614         modest_account_mgr_set_last_updated (mgr, tny_account_get_id (priv->account), time_to_store);
1615
1616         /* Get the message max size */
1617         max_size  = modest_conf_get_int (modest_runtime_get_conf (),
1618                                          MODEST_CONF_MSG_SIZE_LIMIT, NULL);
1619         if (max_size == 0)
1620                 max_size = G_MAXINT;
1621         else
1622                 max_size = max_size * KB;
1623
1624         /* Create the new headers array. We need it to sort the
1625            new headers by date */
1626         new_headers_array = g_ptr_array_new ();
1627         if (info->inbox_observer) {
1628                 new_headers_iter = tny_list_create_iterator (((InternalFolderObserver *) info->inbox_observer)->new_headers);
1629                 while (!tny_iterator_is_done (new_headers_iter)) {
1630                         TnyHeader *header = NULL;
1631
1632                         header = TNY_HEADER (tny_iterator_get_current (new_headers_iter));
1633                         /* Apply per-message size limits */
1634                         if (tny_header_get_message_size (header) < max_size)
1635                                 g_ptr_array_add (new_headers_array, g_object_ref (header));
1636
1637                         g_object_unref (header);
1638                         tny_iterator_next (new_headers_iter);
1639                 }
1640                 g_object_unref (new_headers_iter);
1641
1642                 tny_folder_remove_observer (inbox, info->inbox_observer);
1643                 g_object_unref (info->inbox_observer);
1644                 info->inbox_observer = NULL;
1645         }
1646
1647         if (new_headers_array->len == 0) {
1648                 g_ptr_array_free (new_headers_array, FALSE);
1649                 goto send_mail;
1650         }
1651
1652         /* Get per-account message amount retrieval limit */
1653         retrieve_limit = modest_account_mgr_get_retrieve_limit (mgr, info->account_name);
1654         if (retrieve_limit == 0)
1655                 retrieve_limit = G_MAXINT;
1656
1657         /* Get per-account retrieval type */
1658         retrieve_type = modest_account_mgr_get_retrieve_type (mgr, info->account_name);
1659         headers_only = (retrieve_type == MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY);
1660
1661         /* Order by date */
1662         g_ptr_array_sort (new_headers_array, (GCompareFunc) compare_headers_by_date);
1663
1664         /* Ask the users if they want to retrieve all the messages
1665            even though the limit was exceeded */
1666         ignore_limit = FALSE;
1667         if (new_headers_array->len > retrieve_limit) {
1668                 /* Ask the user if a callback has been specified and
1669                    if the mail operation has a source (this means that
1670                    was invoked by the user and not automatically by a
1671                    D-Bus method) */
1672                 if (info->retrieve_all_cb && priv->source)
1673                         ignore_limit = info->retrieve_all_cb (priv->source,
1674                                                               new_headers_array->len,
1675                                                               retrieve_limit);
1676         }
1677
1678         /* Copy the headers to a list and free the array */
1679         new_headers = tny_simple_list_new ();
1680         for (i=0; i < new_headers_array->len; i++) {
1681                 TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers_array, i));
1682                 tny_list_append (new_headers, G_OBJECT (header));
1683         }
1684         g_ptr_array_foreach (new_headers_array, (GFunc) g_object_unref, NULL);
1685         g_ptr_array_free (new_headers_array, FALSE);
1686
1687         if (!headers_only && (tny_list_get_length (new_headers) > 0)) {
1688                 gint msg_num = 0;
1689                 TnyIterator *iter;
1690                 GetMsgInfo *msg_info;
1691
1692                 priv->done = 0;
1693                 if (ignore_limit)
1694                         priv->total = tny_list_get_length (new_headers);
1695                 else
1696                         priv->total = MIN (tny_list_get_length (new_headers), retrieve_limit);
1697
1698                 iter = tny_list_create_iterator (new_headers);
1699
1700                 /* Create the message info */
1701                 msg_info = g_slice_new0 (GetMsgInfo);
1702                 msg_info->mail_op = g_object_ref (info->mail_op);
1703                 msg_info->total_bytes = compute_message_list_size (new_headers, priv->total);
1704                 msg_info->more_msgs = g_object_ref (iter);
1705                 msg_info->user_data = info;
1706
1707                 while ((msg_num < priv->total ) && !tny_iterator_is_done (iter)) {
1708                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1709                         TnyFolder *folder = tny_header_get_folder (header);
1710
1711                         /* Get message in an async way */
1712                         tny_folder_get_msg_async (folder, header, update_account_get_msg_async_cb,
1713                                                   NULL, msg_info);
1714
1715                         g_object_unref (folder);
1716
1717                         msg_num++;
1718                         tny_iterator_next (iter);
1719                 }
1720                 g_object_unref (iter);
1721
1722                 /* The mail operation will finish when the last
1723                    message is retrieved */
1724                 return;
1725         }
1726  send_mail:
1727         /* If we don't have to retrieve the new messages then
1728            simply send mail */
1729         update_account_send_mail (info);
1730
1731         /* Check if the operation was a success */
1732         if (!priv->error)
1733                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1734
1735         /* Call the user callback and free */
1736         update_account_notify_user_and_free (info, new_headers);
1737 }
1738
1739 static void
1740 inbox_refresh_status_update (GObject *obj,
1741                              TnyStatus *status,
1742                              gpointer user_data)
1743 {
1744         UpdateAccountInfo *info = NULL;
1745         ModestMailOperation *self = NULL;
1746         ModestMailOperationPrivate *priv = NULL;
1747         ModestMailOperationState *state;
1748
1749         g_return_if_fail (user_data != NULL);
1750         g_return_if_fail (status != NULL);
1751
1752         /* Show only the status information we want */
1753         if (status->code != TNY_FOLDER_STATUS_CODE_REFRESH)
1754                 return;
1755
1756         info = (UpdateAccountInfo *) user_data;
1757         self = info->mail_op;
1758         g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
1759
1760         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1761
1762         priv->done = status->position;
1763         priv->total = status->of_total;
1764
1765         state = modest_mail_operation_clone_state (self);
1766
1767         /* This is not a GDK lock because we are a Tinymail callback and
1768          * Tinymail already acquires the Gdk lock */
1769         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
1770
1771         g_slice_free (ModestMailOperationState, state);
1772 }
1773
1774 static void 
1775 recurse_folders_async_cb (TnyFolderStore *folder_store, 
1776                           gboolean canceled,
1777                           TnyList *list, 
1778                           GError *err, 
1779                           gpointer user_data)
1780 {
1781         UpdateAccountInfo *info;
1782         ModestMailOperationPrivate *priv;
1783     
1784         info = (UpdateAccountInfo *) user_data;
1785         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
1786
1787         if (err || canceled) {
1788                 /* If the error was previosly set by another callback
1789                    don't set it again */
1790                 if (!priv->error) {
1791                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1792                         if (err)
1793                                 priv->error = g_error_copy (err);
1794                         else
1795                                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1796                                              MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
1797                                              "canceled");
1798                 }
1799         } else { 
1800                 /* We're not getting INBOX children if we don't want to poke all */
1801                 TnyIterator *iter = tny_list_create_iterator (list);
1802                 while (!tny_iterator_is_done (iter)) {
1803                         TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter);
1804
1805                         /* Add to the list of all folders */
1806                         tny_list_append (info->folders, (GObject *) folder);
1807                         
1808                         if (info->poke_all) {
1809                                 TnyList *folders = tny_simple_list_new ();
1810                                 /* Add pending call */
1811                                 info->pending_calls++;
1812                                 
1813                                 tny_folder_store_get_folders_async (folder, folders, NULL, FALSE,
1814                                                                     recurse_folders_async_cb, 
1815                                                                     NULL, info);
1816                                 g_object_unref (folders);
1817                         }
1818                         
1819                         g_object_unref (G_OBJECT (folder));
1820                         
1821                         tny_iterator_next (iter);           
1822                 }
1823                 g_object_unref (G_OBJECT (iter));
1824         }
1825
1826         /* Remove my own pending call */
1827         info->pending_calls--;
1828
1829         /* This means that we have all the folders */
1830         if (info->pending_calls == 0) {
1831                 TnyIterator *iter_all_folders;
1832                 TnyFolder *inbox = NULL;
1833
1834                 /* If there was any error do not continue */
1835                 if (priv->error) {
1836                         update_account_notify_user_and_free (info, NULL);
1837                         return;
1838                 }
1839
1840                 iter_all_folders = tny_list_create_iterator (info->folders);
1841
1842                 /* Do a poke status over all folders */
1843                 while (!tny_iterator_is_done (iter_all_folders) &&
1844                        priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
1845                         TnyFolder *folder = NULL;
1846
1847                         folder = TNY_FOLDER (tny_iterator_get_current (iter_all_folders));
1848
1849                         if (tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_INBOX) {
1850                                 /* Get a reference to the INBOX */
1851                                 inbox = g_object_ref (folder);
1852                         } else {
1853                                 /* Issue a poke status over the folder */
1854                                 if (info->poke_all)
1855                                         tny_folder_poke_status (folder);
1856                         }
1857
1858                         /* Free and go to next */
1859                         g_object_unref (folder);
1860                         tny_iterator_next (iter_all_folders);
1861                 }
1862                 g_object_unref (iter_all_folders);
1863
1864                 /* Refresh the INBOX */
1865                 if (inbox) {
1866                         /* Refresh the folder. Our observer receives
1867                          * the new emails during folder refreshes, so
1868                          * we can use observer->new_headers
1869                          */
1870                         info->inbox_observer = g_object_new (internal_folder_observer_get_type (), NULL);
1871                         tny_folder_add_observer (inbox, info->inbox_observer);
1872
1873                         /* Refresh the INBOX */
1874                         tny_folder_refresh_async (inbox, inbox_refreshed_cb, inbox_refresh_status_update, info);
1875                         g_object_unref (inbox);
1876                 } else {
1877                         /* We could not perform the inbox refresh but
1878                            we'll try to send mails anyway */
1879                         inbox_refreshed_cb (inbox, FALSE, NULL, info);
1880                 }
1881         }
1882 }
1883
1884 void
1885 modest_mail_operation_update_account (ModestMailOperation *self,
1886                                       const gchar *account_name,
1887                                       gboolean poke_all,
1888                                       gboolean interactive,
1889                                       RetrieveAllCallback retrieve_all_cb,
1890                                       UpdateAccountCallback callback,
1891                                       gpointer user_data)
1892 {
1893         UpdateAccountInfo *info = NULL;
1894         ModestMailOperationPrivate *priv = NULL;
1895         ModestTnyAccountStore *account_store = NULL;
1896         TnyList *folders;
1897         ModestMailOperationState *state;
1898
1899         /* Init mail operation */
1900         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1901         priv->total = 0;
1902         priv->done  = 0;
1903         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
1904         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND_AND_RECEIVE;
1905
1906         /* Get the store account */
1907         account_store = modest_runtime_get_account_store ();
1908         priv->account =
1909                 modest_tny_account_store_get_server_account (account_store,
1910                                                              account_name,
1911                                                              TNY_ACCOUNT_TYPE_STORE);
1912
1913         /* The above function could return NULL */
1914         if (!priv->account) {
1915                 /* Check if the operation was a success */
1916                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1917                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1918                              "no account");
1919                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1920
1921                 /* Call the user callback */
1922                 if (callback)
1923                         callback (self, NULL, user_data);
1924
1925                 /* Notify about operation end */
1926                 modest_mail_operation_notify_end (self);
1927
1928                 return;
1929         }
1930         
1931         /* We have once seen priv->account getting finalized during this code,
1932          * therefore adding a reference (bug #82296) */
1933         
1934         g_object_ref (priv->account);
1935
1936         /* Create the helper object */
1937         info = g_slice_new0 (UpdateAccountInfo);
1938         info->pending_calls = 1;
1939         info->folders = tny_simple_list_new ();
1940         info->mail_op = g_object_ref (self);
1941         info->poke_all = poke_all;
1942         info->interactive = interactive;
1943         info->account_name = g_strdup (account_name);
1944         info->callback = callback;
1945         info->user_data = user_data;
1946         info->retrieve_all_cb = retrieve_all_cb;
1947
1948         /* Set account busy */
1949         modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), account_name, TRUE);
1950         modest_mail_operation_notify_start (self);
1951
1952         /* notify about the start of the operation */ 
1953         state = modest_mail_operation_clone_state (self);
1954         state->done = 0;
1955         state->total = 0;
1956
1957         /* Start notifying progress */
1958         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
1959         g_slice_free (ModestMailOperationState, state);
1960         
1961         /* Get all folders and continue in the callback */ 
1962         folders = tny_simple_list_new ();
1963         tny_folder_store_get_folders_async (TNY_FOLDER_STORE (priv->account),
1964                                             folders, NULL, FALSE,
1965                                             recurse_folders_async_cb, 
1966                                             NULL, info);
1967         g_object_unref (folders);
1968         
1969         g_object_unref (priv->account);
1970         
1971 }
1972
1973 /*
1974  * Used to notify the queue from the main
1975  * loop. We call it inside an idle call to achieve that
1976  */
1977 static gboolean
1978 idle_notify_queue (gpointer data)
1979 {
1980         ModestMailOperation *mail_op = MODEST_MAIL_OPERATION (data);
1981
1982         gdk_threads_enter ();
1983         modest_mail_operation_notify_end (mail_op);
1984         gdk_threads_leave ();
1985         g_object_unref (mail_op);
1986
1987         return FALSE;
1988 }
1989
1990 static int
1991 compare_headers_by_date (gconstpointer a,
1992                          gconstpointer b)
1993 {
1994         TnyHeader **header1, **header2;
1995         time_t sent1, sent2;
1996
1997         header1 = (TnyHeader **) a;
1998         header2 = (TnyHeader **) b;
1999
2000         sent1 = tny_header_get_date_sent (*header1);
2001         sent2 = tny_header_get_date_sent (*header2);
2002
2003         /* We want the most recent ones (greater time_t) at the
2004            beginning */
2005         if (sent1 < sent2)
2006                 return -1;
2007         else
2008                 return 1;
2009 }
2010
2011
2012 /* ******************************************************************* */
2013 /* ************************** STORE  ACTIONS ************************* */
2014 /* ******************************************************************* */
2015
2016 typedef struct {
2017         ModestMailOperation *mail_op;
2018         CreateFolderUserCallback callback;
2019         gpointer user_data;
2020 } CreateFolderInfo;
2021
2022
2023 static void
2024 create_folder_cb (TnyFolderStore *parent_folder, 
2025                   gboolean canceled, 
2026                   TnyFolder *new_folder, 
2027                   GError *err, 
2028                   gpointer user_data)
2029 {
2030         ModestMailOperationPrivate *priv;
2031         CreateFolderInfo *info;
2032
2033         info = (CreateFolderInfo *) user_data;
2034         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
2035
2036         if (canceled || err) {
2037                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2038                 if (err)
2039                         priv->error = g_error_copy (err);
2040                 else
2041                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2042                                      MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
2043                                      "canceled");               
2044         } else {
2045                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2046         }
2047
2048         /* The user will unref the new_folder */
2049         if (info->callback)
2050                 info->callback (info->mail_op, parent_folder, 
2051                                 new_folder, info->user_data);
2052         
2053         /* Notify about operation end */
2054         modest_mail_operation_notify_end (info->mail_op);
2055
2056         /* Frees */
2057         g_object_unref (info->mail_op);
2058         g_slice_free (CreateFolderInfo, info);
2059 }
2060
2061 void
2062 modest_mail_operation_create_folder (ModestMailOperation *self,
2063                                      TnyFolderStore *parent,
2064                                      const gchar *name,
2065                                      CreateFolderUserCallback callback,
2066                                      gpointer user_data)
2067 {
2068         ModestMailOperationPrivate *priv;
2069
2070         g_return_if_fail (TNY_IS_FOLDER_STORE (parent));
2071         g_return_if_fail (name);
2072         
2073         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2074         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
2075         priv->account = (TNY_IS_ACCOUNT (parent)) ? 
2076                 g_object_ref (parent) : 
2077                 modest_tny_folder_get_account (TNY_FOLDER (parent));
2078
2079         /* Check for already existing folder */
2080         if (modest_tny_folder_has_subfolder_with_name (parent, name, TRUE)) {
2081                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2082                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2083                              MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
2084                              _CS("ckdg_ib_folder_already_exists"));
2085         }
2086
2087         /* Check parent */
2088         if (TNY_IS_FOLDER (parent)) {
2089                 /* Check folder rules */
2090                 ModestTnyFolderRules rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
2091                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
2092                         /* Set status failed and set an error */
2093                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2094                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2095                                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2096                                      _("mail_in_ui_folder_create_error"));
2097                 }
2098         }
2099
2100         if (!priv->error && (!strcmp (name, " ") || strchr (name, '/'))) {
2101                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2102                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2103                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2104                              _("mail_in_ui_folder_create_error"));
2105         }
2106
2107         if (!priv->error) {
2108                 CreateFolderInfo *info;
2109
2110                 info = g_slice_new0 (CreateFolderInfo);
2111                 info->mail_op = g_object_ref (self);
2112                 info->callback = callback;
2113                 info->user_data = user_data;
2114
2115                 modest_mail_operation_notify_start (self);
2116
2117                 /* Create the folder */
2118                 tny_folder_store_create_folder_async (parent, name, create_folder_cb, 
2119                                                       NULL, info);
2120         } else {
2121                 /* Call the user callback anyway */
2122                 if (callback)
2123                         callback (self, parent, NULL, user_data);
2124                 /* Notify about operation end */
2125                 modest_mail_operation_notify_end (self);
2126         }
2127 }
2128
2129 void
2130 modest_mail_operation_remove_folder (ModestMailOperation *self,
2131                                      TnyFolder           *folder,
2132                                      gboolean             remove_to_trash)
2133 {
2134         ModestMailOperationPrivate *priv;
2135         ModestTnyFolderRules rules;
2136
2137         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2138         g_return_if_fail (TNY_IS_FOLDER (folder));
2139         
2140         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2141         
2142         /* Check folder rules */
2143         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2144         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_DELETABLE) {
2145                 /* Set status failed and set an error */
2146                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2147                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2148                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2149                              _("mail_in_ui_folder_delete_error"));
2150                 goto end;
2151         }
2152
2153         /* Get the account */
2154         priv->account = modest_tny_folder_get_account (folder);
2155         priv->op_type = MODEST_MAIL_OPERATION_TYPE_DELETE;
2156
2157         /* Delete folder or move to trash */
2158         if (remove_to_trash) {
2159                 TnyFolder *trash_folder = NULL;
2160                 trash_folder = modest_tny_account_get_special_folder (priv->account,
2161                                                                       TNY_FOLDER_TYPE_TRASH);
2162                 /* TODO: error_handling */
2163                 if (trash_folder) {
2164                         modest_mail_operation_notify_start (self);
2165                         modest_mail_operation_xfer_folder (self, folder,
2166                                                     TNY_FOLDER_STORE (trash_folder), 
2167                                                     TRUE, NULL, NULL);
2168                         g_object_unref (trash_folder);
2169                 } else {
2170                         g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL trash folder", __FUNCTION__);
2171                 }
2172         } else {
2173                 TnyFolderStore *parent = tny_folder_get_folder_store (folder);
2174                 if (parent) {
2175                         modest_mail_operation_notify_start (self);
2176                         tny_folder_store_remove_folder (parent, folder, &(priv->error));
2177                         CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
2178                         
2179                         if (!priv->error)
2180                                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2181
2182                         g_object_unref (parent);
2183                 } else
2184                         g_warning ("%s: could not get parent folder", __FUNCTION__);
2185         }
2186
2187  end:
2188         /* Notify about operation end */
2189         modest_mail_operation_notify_end (self);
2190 }
2191
2192 static void
2193 transfer_folder_status_cb (GObject *obj,
2194                            TnyStatus *status,
2195                            gpointer user_data)
2196 {
2197         ModestMailOperation *self;
2198         ModestMailOperationPrivate *priv;
2199         ModestMailOperationState *state;
2200         XFerFolderAsyncHelper *helper;
2201
2202         g_return_if_fail (status != NULL);
2203
2204         /* Show only the status information we want */
2205         if (status->code != TNY_FOLDER_STATUS_CODE_COPY_FOLDER)
2206                 return;
2207
2208         helper = (XFerFolderAsyncHelper *) user_data;
2209         g_return_if_fail (helper != NULL);
2210
2211         self = helper->mail_op;
2212         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
2213
2214         priv->done = status->position;
2215         priv->total = status->of_total;
2216
2217         state = modest_mail_operation_clone_state (self);
2218
2219         /* This is not a GDK lock because we are a Tinymail callback
2220          * which is already GDK locked by Tinymail */
2221
2222         /* no gdk_threads_enter (), CHECKED */
2223
2224         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); 
2225
2226         /* no gdk_threads_leave (), CHECKED */
2227
2228         g_slice_free (ModestMailOperationState, state);
2229 }
2230
2231 static void
2232 transfer_folder_cb (TnyFolder *folder, 
2233                     gboolean cancelled, 
2234                     TnyFolderStore *into, 
2235                     TnyFolder *new_folder, 
2236                     GError *err, 
2237                     gpointer user_data)
2238 {
2239         XFerFolderAsyncHelper *helper;
2240         ModestMailOperation *self = NULL;
2241         ModestMailOperationPrivate *priv = NULL;
2242
2243         helper = (XFerFolderAsyncHelper *) user_data;
2244         g_return_if_fail (helper != NULL);
2245
2246         self = helper->mail_op;
2247         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
2248
2249         if (err) {
2250                 priv->error = g_error_copy (err);
2251                 priv->done = 0;
2252                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2253         } else if (cancelled) {
2254                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2255                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2256                              MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
2257                              _("Transference of %s was cancelled."),
2258                              tny_folder_get_name (folder));
2259         } else {
2260                 priv->done = 1;
2261                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2262         }
2263
2264         /* Update state of new folder */
2265         if (new_folder) {
2266                 tny_folder_refresh_async (new_folder, NULL, NULL, NULL);
2267                 tny_folder_poke_status (new_folder);
2268         }
2269
2270         /* Notify about operation end */
2271         modest_mail_operation_notify_end (self);
2272
2273         /* If user defined callback function was defined, call it */
2274         if (helper->user_callback) {
2275
2276                 /* This is not a GDK lock because we are a Tinymail callback
2277                  * which is already GDK locked by Tinymail */
2278
2279                 /* no gdk_threads_enter (), CHECKED */
2280                 helper->user_callback (self, new_folder, helper->user_data);
2281                 /* no gdk_threads_leave () , CHECKED */
2282         }
2283
2284         /* Free */
2285         g_object_unref (helper->mail_op);
2286         g_slice_free   (XFerFolderAsyncHelper, helper);
2287 }
2288
2289 /**
2290  *
2291  * This function checks if the new name is a valid name for our local
2292  * folders account. The new name could not be the same than then name
2293  * of any of the mandatory local folders
2294  *
2295  * We can not rely on tinymail because tinymail does not check the
2296  * name of the virtual folders that the account could have in the case
2297  * that we're doing a rename (because it directly calls Camel which
2298  * knows nothing about our virtual folders). 
2299  *
2300  * In the case of an actual copy/move (i.e. move/copy a folder between
2301  * accounts) tinymail uses the tny_folder_store_create_account which
2302  * is reimplemented by our ModestTnyLocalFoldersAccount that indeed
2303  * checks the new name of the folder, so this call in that case
2304  * wouldn't be needed. *But* NOTE that if tinymail changes its
2305  * implementation (if folder transfers within the same account is no
2306  * longer implemented as a rename) this call will allow Modest to work
2307  * perfectly
2308  *
2309  * If the new name is not valid, this function will set the status to
2310  * failed and will set also an error in the mail operation
2311  */
2312 static gboolean
2313 new_name_valid_if_local_account (ModestMailOperationPrivate *priv,
2314                                  TnyFolderStore *into,
2315                                  const gchar *new_name)
2316 {
2317         if (TNY_IS_ACCOUNT (into) && 
2318             modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (into)) &&
2319             modest_tny_local_folders_account_folder_name_in_use (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (into),
2320                                                                  new_name)) {
2321                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2322                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2323                              MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
2324                              _CS("ckdg_ib_folder_already_exists"));
2325                 return FALSE;
2326         } else
2327                 return TRUE;
2328 }
2329
2330 void
2331 modest_mail_operation_xfer_folder (ModestMailOperation *self,
2332                                    TnyFolder *folder,
2333                                    TnyFolderStore *parent,
2334                                    gboolean delete_original,
2335                                    XferFolderAsyncUserCallback user_callback,
2336                                    gpointer user_data)
2337 {
2338         ModestMailOperationPrivate *priv = NULL;
2339         ModestTnyFolderRules parent_rules = 0, rules; 
2340         XFerFolderAsyncHelper *helper = NULL;
2341         const gchar *folder_name = NULL;
2342         const gchar *error_msg;
2343
2344         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2345         g_return_if_fail (TNY_IS_FOLDER (folder));
2346         g_return_if_fail (TNY_IS_FOLDER_STORE (parent));
2347
2348         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2349         folder_name = tny_folder_get_name (folder);
2350
2351         /* Set the error msg */
2352         error_msg = _("mail_in_ui_folder_move_target_error");
2353
2354         /* Get account and set it into mail_operation */
2355         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2356         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2357         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2358
2359         /* Get folder rules */
2360         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2361         if (TNY_IS_FOLDER (parent))
2362                 parent_rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
2363         
2364         /* Apply operation constraints */
2365         if ((gpointer) parent == (gpointer) folder ||
2366             (!TNY_IS_FOLDER_STORE (parent)) || 
2367             (rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE)) {
2368                 /* Folder rules */
2369                 goto error;
2370         } else if (TNY_IS_FOLDER (parent) && 
2371                    (parent_rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE)) {
2372                 /* Folder rules */
2373                 goto error;
2374
2375         } else if (TNY_IS_FOLDER (parent) &&
2376                    TNY_IS_FOLDER_STORE (folder) &&
2377                    modest_tny_folder_is_ancestor (TNY_FOLDER (parent), 
2378                                                   TNY_FOLDER_STORE (folder))) {
2379                 /* Do not move a parent into a child */
2380                 goto error;
2381         } else if (TNY_IS_FOLDER_STORE (parent) &&
2382                    modest_tny_folder_has_subfolder_with_name (parent, folder_name, TRUE)) {
2383                 /* Check that the new folder name is not used by any
2384                    parent subfolder */
2385                 goto error;     
2386         } else if (!(new_name_valid_if_local_account (priv, parent, folder_name))) {
2387                 /* Check that the new folder name is not used by any
2388                    special local folder */
2389                 goto error;
2390         } else {
2391                 /* Create the helper */
2392                 helper = g_slice_new0 (XFerFolderAsyncHelper);
2393                 helper->mail_op = g_object_ref (self);
2394                 helper->user_callback = user_callback;
2395                 helper->user_data = user_data;
2396                 
2397                 /* Move/Copy folder */
2398                 modest_mail_operation_notify_start (self);
2399                 tny_folder_copy_async (folder,
2400                                        parent,
2401                                        tny_folder_get_name (folder),
2402                                        delete_original,
2403                                        transfer_folder_cb,
2404                                        transfer_folder_status_cb,
2405                                        helper);
2406                 return;
2407         }
2408
2409  error:
2410         /* Set status failed and set an error */
2411         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2412         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2413                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2414                      error_msg);
2415
2416         /* Call the user callback if exists */
2417         if (user_callback)
2418                 user_callback (self, NULL, user_data);
2419
2420         /* Notify the queue */
2421         modest_mail_operation_notify_end (self);
2422 }
2423
2424 void
2425 modest_mail_operation_rename_folder (ModestMailOperation *self,
2426                                      TnyFolder *folder,
2427                                      const gchar *name,
2428                                      XferFolderAsyncUserCallback user_callback,
2429                                      gpointer user_data)
2430 {
2431         ModestMailOperationPrivate *priv;
2432         ModestTnyFolderRules rules;
2433         XFerFolderAsyncHelper *helper;
2434
2435         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2436         g_return_if_fail (TNY_IS_FOLDER_STORE (folder));
2437         g_return_if_fail (name);
2438         
2439         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2440
2441         /* Get account and set it into mail_operation */
2442         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2443         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
2444
2445         /* Check folder rules */
2446         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2447         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_RENAMEABLE) {
2448                 goto error;
2449         } else if (!strcmp (name, " ") || strchr (name, '/')) {
2450                 goto error;
2451         } else {
2452                 TnyFolderStore *into;
2453
2454                 into = tny_folder_get_folder_store (folder);    
2455
2456                 /* Check that the new folder name is not used by any
2457                    special local folder */
2458                 if (new_name_valid_if_local_account (priv, into, name)) {
2459                         /* Create the helper */
2460                         helper = g_slice_new0 (XFerFolderAsyncHelper);
2461                         helper->mail_op = g_object_ref(self);
2462                         helper->user_callback = user_callback;
2463                         helper->user_data = user_data;
2464                 
2465                         /* Rename. Camel handles folder subscription/unsubscription */
2466                         modest_mail_operation_notify_start (self);
2467                         tny_folder_copy_async (folder, into, name, TRUE,
2468                                                transfer_folder_cb,
2469                                                transfer_folder_status_cb,
2470                                                helper);
2471                         g_object_unref (into);
2472                 } else {
2473                         g_object_unref (into);
2474                         goto error;
2475                 }
2476
2477                 return;
2478         }
2479  error:
2480         /* Set status failed and set an error */
2481         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2482         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2483                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2484                      _("FIXME: unable to rename"));
2485         
2486         if (user_callback)
2487                 user_callback (self, NULL, user_data);
2488
2489         /* Notify about operation end */
2490         modest_mail_operation_notify_end (self);
2491 }
2492
2493 /* ******************************************************************* */
2494 /* **************************  MSG  ACTIONS  ************************* */
2495 /* ******************************************************************* */
2496
2497 void 
2498 modest_mail_operation_find_msg (ModestMailOperation *self,
2499                                 TnyFolder *folder,
2500                                 const gchar *msg_uid,
2501                                 gboolean progress_feedback,
2502                                 GetMsgAsyncUserCallback user_callback,
2503                                 gpointer user_data)
2504 {
2505         GetMsgInfo *helper = NULL;
2506         ModestMailOperationPrivate *priv;
2507         
2508         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2509         g_return_if_fail (msg_uid != NULL);
2510         
2511         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2512         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2513         priv->total = 1;
2514         priv->done = 0;
2515
2516         /* Check memory low */
2517         if (_check_memory_low (self)) {
2518                 if (user_callback)
2519                         user_callback (self, NULL, FALSE, NULL, priv->error, user_data);
2520                 modest_mail_operation_notify_end (self);
2521                 return;
2522         }
2523
2524         /* Get account and set it into mail_operation */
2525         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2526         
2527         /* Check for cached messages */
2528         if (progress_feedback) {
2529                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2530         } else {
2531                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
2532         }
2533         
2534         /* Create the helper */
2535         helper = g_slice_new0 (GetMsgInfo);
2536         helper->header = NULL;
2537         helper->mail_op = g_object_ref (self);
2538         helper->user_callback = user_callback;
2539         helper->user_data = user_data;
2540         helper->destroy_notify = NULL;
2541         helper->last_total_bytes = 0;
2542         helper->sum_total_bytes = 0;
2543         helper->total_bytes = 0;
2544         helper->more_msgs = NULL;
2545
2546         modest_mail_operation_notify_start (self);
2547         
2548         /* notify about the start of the operation */ 
2549         ModestMailOperationState *state;
2550         state = modest_mail_operation_clone_state (self);
2551         state->done = 0;
2552         state->total = 0;
2553         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
2554                                 0, state, NULL);
2555         g_slice_free (ModestMailOperationState, state);
2556         
2557         tny_folder_find_msg_async (folder, msg_uid, get_msg_async_cb, get_msg_status_cb, helper);
2558 }
2559
2560 void 
2561 modest_mail_operation_get_msg (ModestMailOperation *self,
2562                                TnyHeader *header,
2563                                gboolean progress_feedback,
2564                                GetMsgAsyncUserCallback user_callback,
2565                                gpointer user_data)
2566 {
2567         GetMsgInfo *helper = NULL;
2568         TnyFolder *folder;
2569         ModestMailOperationPrivate *priv;
2570         
2571         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2572         g_return_if_fail (TNY_IS_HEADER (header));
2573         
2574         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2575         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2576         priv->total = 1;
2577         priv->done = 0;
2578
2579         /* Check memory low */
2580         if (_check_memory_low (self)) {
2581                 if (user_callback)
2582                         user_callback (self, header, FALSE, NULL, priv->error, user_data);
2583                 modest_mail_operation_notify_end (self);
2584                 return;
2585         }
2586
2587         /* Get account and set it into mail_operation */
2588         folder = tny_header_get_folder (header);
2589         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2590         
2591         /* Check for cached messages */
2592         if (progress_feedback) {
2593                 if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)
2594                         priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN;
2595                 else 
2596                         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2597         } else {
2598                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
2599         }
2600         
2601         /* Create the helper */
2602         helper = g_slice_new0 (GetMsgInfo);
2603         helper->header = g_object_ref (header);
2604         helper->mail_op = g_object_ref (self);
2605         helper->user_callback = user_callback;
2606         helper->user_data = user_data;
2607         helper->destroy_notify = NULL;
2608         helper->last_total_bytes = 0;
2609         helper->sum_total_bytes = 0;
2610         helper->total_bytes = tny_header_get_message_size (header);
2611         helper->more_msgs = NULL;
2612
2613         modest_mail_operation_notify_start (self);
2614         
2615         /* notify about the start of the operation */ 
2616         ModestMailOperationState *state;
2617         state = modest_mail_operation_clone_state (self);
2618         state->done = 0;
2619         state->total = 0;
2620         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
2621                                 0, state, NULL);
2622         g_slice_free (ModestMailOperationState, state);
2623         
2624         tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, helper);
2625
2626         g_object_unref (G_OBJECT (folder));
2627 }
2628
2629 static void     
2630 get_msg_status_cb (GObject *obj,
2631                    TnyStatus *status,  
2632                    gpointer user_data)
2633 {
2634         GetMsgInfo *helper = NULL;
2635
2636         g_return_if_fail (status != NULL);
2637
2638         /* Show only the status information we want */
2639         if (status->code != TNY_FOLDER_STATUS_CODE_GET_MSG)
2640                 return;
2641
2642         helper = (GetMsgInfo *) user_data;
2643         g_return_if_fail (helper != NULL);       
2644
2645         /* Notify progress */
2646         notify_progress_of_multiple_messages (helper->mail_op, status, &(helper->last_total_bytes), 
2647                                               &(helper->sum_total_bytes), helper->total_bytes, FALSE);
2648 }
2649
2650 static void
2651 get_msg_async_cb (TnyFolder *folder, 
2652                   gboolean canceled, 
2653                   TnyMsg *msg, 
2654                   GError *err, 
2655                   gpointer user_data)
2656 {
2657         GetMsgInfo *info = NULL;
2658         ModestMailOperationPrivate *priv = NULL;
2659         gboolean finished;
2660
2661         info = (GetMsgInfo *) user_data;
2662
2663         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
2664         priv->done++;
2665
2666         if (info->more_msgs) {
2667                 tny_iterator_next (info->more_msgs);
2668                 finished = (tny_iterator_is_done (info->more_msgs));
2669         } else {
2670                 finished = (priv->done == priv->total) ? TRUE : FALSE;
2671         }
2672
2673         /* If canceled by the user, ignore the error given by Tinymail */
2674         if (canceled) {
2675                 canceled = TRUE;
2676                 finished = TRUE;
2677                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2678         } else if (err) {
2679                 priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
2680                 priv->error = g_error_copy ((const GError *) err);
2681                 if (priv->error) {
2682                         priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
2683                 } else {
2684                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2685                                      MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2686                                      err->message);
2687                 }
2688         } else if (finished && priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
2689                 /* Set the success status before calling the user callback */
2690                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2691         }
2692
2693         if (info->header == NULL && msg)
2694                 info->header = tny_msg_get_header (msg);
2695
2696         /* Call the user callback */
2697         if (info->user_callback)
2698                 info->user_callback (info->mail_op, info->header, canceled, 
2699                                      msg, err, info->user_data);
2700
2701         /* Notify about operation end if this is the last callback */
2702         if (finished) {
2703                 /* Free user data */
2704                 if (info->destroy_notify)
2705                         info->destroy_notify (info->user_data);
2706
2707                 /* Notify about operation end */
2708                 modest_mail_operation_notify_end (info->mail_op);
2709
2710                 /* Clean */
2711                 if (info->more_msgs)
2712                         g_object_unref (info->more_msgs);
2713                 if (info->header)
2714                         g_object_unref (info->header);
2715                 g_object_unref (info->mail_op);
2716                 g_slice_free (GetMsgInfo, info);
2717         } else if (info->more_msgs) {
2718                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (info->more_msgs));
2719                 TnyFolder *folder = tny_header_get_folder (header);
2720
2721                 g_object_unref (info->header);
2722                 info->header = g_object_ref (header);
2723
2724                 /* Retrieve the next message */
2725                 tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, info);
2726
2727                 g_object_unref (header);
2728                 g_object_unref (folder);
2729         } else {
2730                 g_warning ("%s: finished != TRUE but no messages left", __FUNCTION__);
2731         }
2732 }
2733
2734 void 
2735 modest_mail_operation_get_msgs_full (ModestMailOperation *self,
2736                                      TnyList *header_list, 
2737                                      GetMsgAsyncUserCallback user_callback,
2738                                      gpointer user_data,
2739                                      GDestroyNotify notify)
2740 {
2741         ModestMailOperationPrivate *priv = NULL;
2742         gint msg_list_size;
2743         TnyIterator *iter = NULL;
2744         gboolean has_uncached_messages;
2745         
2746         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2747
2748         /* Init mail operation */
2749         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2750         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2751         priv->done = 0;
2752         priv->total = tny_list_get_length(header_list);
2753
2754         /* Check memory low */
2755         if (_check_memory_low (self)) {
2756                 if (user_callback) {
2757                         TnyHeader *header = NULL;
2758                         TnyIterator *iter;
2759
2760                         if (tny_list_get_length (header_list) > 0) {
2761                                 iter = tny_list_create_iterator (header_list);
2762                                 header = (TnyHeader *) tny_iterator_get_current (iter);
2763                                 g_object_unref (iter);
2764                         }
2765                         user_callback (self, header, FALSE, NULL, priv->error, user_data);
2766                         if (header)
2767                                 g_object_unref (header);
2768                 }
2769                 if (notify)
2770                         notify (user_data);
2771                 /* Notify about operation end */
2772                 modest_mail_operation_notify_end (self);
2773                 return;
2774         }
2775
2776         /* Check uncached messages */
2777         for (iter = tny_list_create_iterator (header_list), has_uncached_messages = FALSE;
2778              !has_uncached_messages && !tny_iterator_is_done (iter); 
2779              tny_iterator_next (iter)) {
2780                 TnyHeader *header;
2781
2782                 header = (TnyHeader *) tny_iterator_get_current (iter);
2783                 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
2784                         has_uncached_messages = TRUE;
2785                 g_object_unref (header);
2786         }       
2787         g_object_unref (iter);
2788         priv->op_type = has_uncached_messages?MODEST_MAIL_OPERATION_TYPE_RECEIVE:MODEST_MAIL_OPERATION_TYPE_OPEN;
2789
2790         /* Get account and set it into mail_operation */
2791         if (tny_list_get_length (header_list) >= 1) {
2792                 TnyIterator *iterator = tny_list_create_iterator (header_list);
2793                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iterator));
2794                 if (header) {
2795                         TnyFolder *folder = tny_header_get_folder (header);
2796                         if (folder) {           
2797                                 priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2798                                 g_object_unref (folder);
2799                         }
2800                         g_object_unref (header);
2801                 }
2802                 g_object_unref (iterator);
2803         }
2804
2805         msg_list_size = compute_message_list_size (header_list, 0);
2806
2807         modest_mail_operation_notify_start (self);
2808         iter = tny_list_create_iterator (header_list);
2809         if (!tny_iterator_is_done (iter)) {
2810                 /* notify about the start of the operation */
2811                 ModestMailOperationState *state;
2812                 state = modest_mail_operation_clone_state (self);
2813                 state->done = 0;
2814                 state->total = 0;
2815                 g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
2816                                0, state, NULL);
2817
2818                 GetMsgInfo *msg_info = NULL;
2819                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2820                 TnyFolder *folder = tny_header_get_folder (header);
2821
2822                 /* Create the message info */
2823                 msg_info = g_slice_new0 (GetMsgInfo);
2824                 msg_info->mail_op = g_object_ref (self);
2825                 msg_info->header = g_object_ref (header);
2826                 msg_info->more_msgs = g_object_ref (iter);
2827                 msg_info->user_callback = user_callback;
2828                 msg_info->user_data = user_data;
2829                 msg_info->destroy_notify = notify;
2830                 msg_info->last_total_bytes = 0;
2831                 msg_info->sum_total_bytes = 0;
2832                 msg_info->total_bytes = msg_list_size;
2833
2834                 /* The callback will call it per each header */
2835                 tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, msg_info);
2836
2837                 /* Free and go on */
2838                 g_object_unref (header);
2839                 g_object_unref (folder);
2840                 g_slice_free (ModestMailOperationState, state);
2841         }
2842         g_object_unref (iter);
2843 }
2844
2845
2846 static void
2847 remove_msgs_async_cb (TnyFolder *folder, 
2848                       gboolean canceled, 
2849                       GError *err, 
2850                       gpointer user_data)
2851 {
2852         gboolean expunge, leave_on_server;
2853         const gchar *account_name;
2854         TnyAccount *account;
2855         ModestProtocolType account_proto = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
2856         ModestMailOperation *self;
2857         ModestMailOperationPrivate *priv;
2858         ModestProtocolRegistry *protocol_registry;
2859
2860         self = (ModestMailOperation *) user_data;
2861         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2862         protocol_registry = modest_runtime_get_protocol_registry ();
2863
2864         if (canceled || err) {
2865                 /* If canceled by the user, ignore the error given by Tinymail */
2866                 if (canceled) {
2867                         priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2868                 } else if (err) {
2869                         priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
2870                         priv->error = g_error_copy ((const GError *) err);
2871                         priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
2872                 }
2873                 /* Exit */
2874                 modest_mail_operation_notify_end (self);
2875                 g_object_unref (self);
2876                 return;
2877         }
2878
2879         account = modest_tny_folder_get_account (folder);
2880         account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
2881         leave_on_server =
2882                 modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
2883                                                         account_name);  
2884         account_proto = modest_tny_account_get_protocol_type (account);
2885         g_object_unref (account);
2886
2887         if ((modest_protocol_registry_protocol_type_has_leave_on_server (protocol_registry, account_proto) && 
2888              !leave_on_server) ||
2889             !modest_tny_folder_is_remote_folder (folder))
2890                 expunge = TRUE;
2891         else
2892                 expunge = FALSE;
2893
2894         /* Sync folder */
2895         tny_folder_sync_async(folder, expunge, sync_folder_finish_callback, 
2896                               NULL, self);
2897 }
2898
2899 void 
2900 modest_mail_operation_remove_msgs (ModestMailOperation *self,  
2901                                    TnyList *headers,
2902                                    gboolean remove_to_trash /*ignored*/)
2903 {
2904         TnyFolder *folder = NULL;
2905         ModestMailOperationPrivate *priv;
2906         TnyIterator *iter = NULL;
2907         TnyHeader *header = NULL;
2908         TnyList *remove_headers = NULL;
2909         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
2910         ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
2911
2912         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2913         g_return_if_fail (TNY_IS_LIST (headers));
2914
2915         if (remove_to_trash)
2916                 g_warning ("remove to trash is not implemented");
2917
2918         if (tny_list_get_length(headers) == 0) {
2919                 g_warning ("%s: list of headers is empty\n", __FUNCTION__);
2920                 goto cleanup; /* nothing to do */
2921         }
2922
2923         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2924
2925         /* Get folder from first header and sync it */
2926         iter = tny_list_create_iterator (headers);
2927         header = TNY_HEADER (tny_iterator_get_current (iter));
2928         g_object_unref (iter);
2929
2930         folder = tny_header_get_folder (header);
2931         if (!TNY_IS_FOLDER(folder)) {
2932                 g_warning ("%s: could not get folder for header\n", __FUNCTION__);
2933                 goto cleanup;
2934         }
2935
2936         /* Use the merged folder if we're removing messages from outbox */
2937         if (modest_tny_folder_is_local_folder (folder)) {
2938                 ModestTnyLocalFoldersAccount *local_account;
2939
2940                 local_account = (ModestTnyLocalFoldersAccount *)
2941                         modest_tny_account_store_get_local_folders_account (accstore);
2942                 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
2943                 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
2944                         g_object_unref (folder);
2945                         folder = modest_tny_local_folders_account_get_merged_outbox (local_account);
2946                 }
2947                 g_object_unref (local_account);
2948         }
2949
2950         if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
2951                 TnyIterator *headers_iter = tny_list_create_iterator (headers);
2952
2953                 while (!tny_iterator_is_done (headers_iter)) {
2954                         TnyTransportAccount *traccount = NULL;
2955                         TnyHeader *hdr = NULL;
2956
2957                         hdr = TNY_HEADER (tny_iterator_get_current (headers_iter));
2958                         traccount = modest_tny_account_store_get_transport_account_from_outbox_header (accstore,
2959                                                                                                        header);
2960                         if (traccount) {
2961                                 ModestTnySendQueueStatus status;
2962                                 ModestTnySendQueue *send_queue;
2963
2964                                 send_queue = modest_runtime_get_send_queue(traccount, TRUE);
2965                                 if (TNY_IS_SEND_QUEUE (send_queue)) {
2966                                         char *msg_id;
2967
2968                                         msg_id = modest_tny_send_queue_get_msg_id (hdr);
2969                                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
2970                                         if (status != MODEST_TNY_SEND_QUEUE_SENDING) {
2971                                                 if (G_UNLIKELY (remove_headers == NULL))
2972                                                         remove_headers = tny_simple_list_new ();
2973                                                 tny_list_append(remove_headers, G_OBJECT(hdr));
2974                                         }
2975                                         g_free(msg_id);
2976                                 }
2977                                 g_object_unref(traccount);
2978                         }
2979                         g_object_unref(hdr);
2980                         tny_iterator_next (headers_iter);
2981                 }
2982                 g_object_unref(headers_iter);
2983         }
2984
2985         /* Get account and set it into mail_operation */
2986         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2987         priv->op_type = MODEST_MAIL_OPERATION_TYPE_DELETE;
2988         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2989
2990         if (!remove_headers)
2991                 remove_headers = g_object_ref (headers);
2992
2993         /* remove message from folder */
2994         modest_mail_operation_notify_start (self);
2995         tny_folder_remove_msgs_async (folder, remove_headers, remove_msgs_async_cb, 
2996                                       NULL, g_object_ref (self));
2997
2998 cleanup:
2999         if (remove_headers)
3000                 g_object_unref (remove_headers);
3001         if (header)
3002                 g_object_unref (header);
3003         if (folder)
3004                 g_object_unref (folder);
3005 }
3006
3007 static void
3008 notify_progress_of_multiple_messages (ModestMailOperation *self,
3009                                       TnyStatus *status,
3010                                       gint *last_total_bytes,
3011                                       gint *sum_total_bytes,
3012                                       gint total_bytes, 
3013                                       gboolean increment_done)
3014 {
3015         ModestMailOperationPrivate *priv;
3016         ModestMailOperationState *state;
3017         gboolean is_num_bytes = FALSE;
3018
3019         priv =  MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3020
3021         /* We know that tinymail sends us information about
3022          *  transferred bytes with this particular message
3023          */
3024         if (status->message)
3025                 is_num_bytes = (g_ascii_strcasecmp (status->message, "Retrieving message") == 0);
3026
3027         state = modest_mail_operation_clone_state (self);
3028         if (is_num_bytes && !((status->position == 1) && (status->of_total == 100))) {
3029                 /* We know that we're in a different message when the
3030                    total number of bytes to transfer is different. Of
3031                    course it could fail if we're transferring messages
3032                    of the same size, but this is a workarround */
3033                 if (status->of_total != *last_total_bytes) {
3034                         /* We need to increment the done when there is
3035                            no information about each individual
3036                            message, we need to do this in message
3037                            transfers, and we don't do it for getting
3038                            messages */
3039                         if (increment_done)
3040                                 priv->done++;
3041                         *sum_total_bytes += *last_total_bytes;
3042                         *last_total_bytes = status->of_total;
3043                 }
3044                 state->bytes_done += status->position + *sum_total_bytes;
3045                 state->bytes_total = total_bytes;
3046
3047                 /* Notify the status change. Only notify about changes
3048                    referred to bytes */
3049                 g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
3050                                0, state, NULL);
3051         }
3052
3053         g_slice_free (ModestMailOperationState, state);
3054 }
3055
3056 static void
3057 transfer_msgs_status_cb (GObject *obj,
3058                          TnyStatus *status,  
3059                          gpointer user_data)
3060 {
3061         XFerMsgsAsyncHelper *helper;
3062
3063         g_return_if_fail (status != NULL);
3064
3065         /* Show only the status information we want */
3066         if (status->code != TNY_FOLDER_STATUS_CODE_XFER_MSGS)
3067                 return;
3068
3069         helper = (XFerMsgsAsyncHelper *) user_data;
3070         g_return_if_fail (helper != NULL);       
3071
3072         /* Notify progress */
3073         notify_progress_of_multiple_messages (helper->mail_op, status, &(helper->last_total_bytes), 
3074                                               &(helper->sum_total_bytes), helper->total_bytes, TRUE);
3075 }
3076
3077 static void
3078 transfer_msgs_sync_folder_cb (TnyFolder *self, 
3079                               gboolean cancelled, 
3080                               GError *err, 
3081                               gpointer user_data)
3082 {
3083         XFerMsgsAsyncHelper *helper;
3084         /* We don't care here about the results of the
3085            synchronization */
3086         helper = (XFerMsgsAsyncHelper *) user_data;
3087
3088         /* Notify about operation end */
3089         modest_mail_operation_notify_end (helper->mail_op);
3090
3091         /* If user defined callback function was defined, call it */
3092         if (helper->user_callback)
3093                 helper->user_callback (helper->mail_op, helper->user_data);
3094         
3095         /* Free */
3096         if (helper->more_msgs)
3097                 g_object_unref (helper->more_msgs);
3098         if (helper->headers)
3099                 g_object_unref (helper->headers);
3100         if (helper->dest_folder)
3101                 g_object_unref (helper->dest_folder);
3102         if (helper->mail_op)
3103                 g_object_unref (helper->mail_op);
3104         g_slice_free (XFerMsgsAsyncHelper, helper);
3105 }
3106
3107 static void
3108 transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError *err, gpointer user_data)
3109 {
3110         XFerMsgsAsyncHelper *helper;
3111         ModestMailOperation *self;
3112         ModestMailOperationPrivate *priv;
3113         gboolean finished = TRUE;
3114
3115         helper = (XFerMsgsAsyncHelper *) user_data;
3116         self = helper->mail_op;
3117
3118         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3119
3120         if (cancelled) {
3121                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
3122         } else if (err) {
3123                 priv->error = g_error_copy (err);
3124                 priv->done = 0;
3125                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;     
3126         } else if (priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
3127                 if (helper->more_msgs) {
3128                         /* We'll transfer the next message in the list */
3129                         tny_iterator_next (helper->more_msgs);
3130                         if (!tny_iterator_is_done (helper->more_msgs)) {
3131                                 GObject *next_header;
3132                                 g_object_unref (helper->headers);
3133                                 helper->headers = tny_simple_list_new ();
3134                                 next_header = tny_iterator_get_current (helper->more_msgs);
3135                                 tny_list_append (helper->headers, next_header);
3136                                 g_object_unref (next_header);
3137                                 finished = FALSE;
3138                         }
3139                 }
3140                 if (finished) {
3141                         priv->done = 1;
3142                         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3143                 }
3144         }
3145
3146         if (finished) {
3147                 /* Synchronize the source folder contents. This should
3148                    be done by tinymail but the camel_folder_sync it's
3149                    actually disabled in transfer_msgs_thread_clean
3150                    because it's supposed to cause hangs */
3151                 tny_folder_sync_async (folder, helper->delete, 
3152                                        transfer_msgs_sync_folder_cb, 
3153                                        NULL, helper);
3154         } else {
3155                 /* Transfer more messages */
3156                 tny_folder_transfer_msgs_async (folder,
3157                                                 helper->headers,
3158                                                 helper->dest_folder,
3159                                                 helper->delete,
3160                                                 transfer_msgs_cb,
3161                                                 transfer_msgs_status_cb,
3162                                                 helper);
3163         }
3164 }
3165
3166 /* Computes the size of the messages the headers in the list belongs
3167    to. If num_elements is different from 0 then it only takes into
3168    account the first num_elements for the calculation */
3169 static guint
3170 compute_message_list_size (TnyList *headers, 
3171                            guint num_elements)
3172 {
3173         TnyIterator *iter;
3174         guint size = 0, element = 0;
3175
3176         /* If num_elements is not valid then take all into account */
3177         if ((num_elements <= 0) || (num_elements > tny_list_get_length (headers)))
3178                 num_elements = tny_list_get_length (headers);
3179
3180         iter = tny_list_create_iterator (headers);
3181         while (!tny_iterator_is_done (iter) && element < num_elements) {
3182                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
3183                 size += tny_header_get_message_size (header);
3184                 g_object_unref (header);
3185                 tny_iterator_next (iter);
3186                 element++;
3187         }
3188         g_object_unref (iter);
3189
3190         return size;
3191 }
3192
3193 void
3194 modest_mail_operation_xfer_msgs (ModestMailOperation *self,
3195                                  TnyList *headers, 
3196                                  TnyFolder *folder, 
3197                                  gboolean delete_original,
3198                                  XferMsgsAsyncUserCallback user_callback,
3199                                  gpointer user_data)
3200 {
3201         ModestMailOperationPrivate *priv = NULL;
3202         TnyIterator *iter = NULL;
3203         TnyFolder *src_folder = NULL;
3204         XFerMsgsAsyncHelper *helper = NULL;
3205         TnyHeader *header = NULL;
3206         ModestTnyFolderRules rules = 0;
3207         TnyAccount *dst_account = NULL;
3208         gboolean leave_on_server;
3209         ModestMailOperationState *state;
3210         ModestProtocolRegistry *protocol_registry;
3211         ModestProtocolType account_protocol;
3212
3213         g_return_if_fail (self && MODEST_IS_MAIL_OPERATION (self));
3214         g_return_if_fail (headers && TNY_IS_LIST (headers));
3215         g_return_if_fail (folder && TNY_IS_FOLDER (folder));
3216
3217         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3218         protocol_registry = modest_runtime_get_protocol_registry ();
3219
3220         priv->total = tny_list_get_length (headers);
3221         priv->done = 0;
3222         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3223         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
3224
3225         /* Apply folder rules */
3226         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
3227         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
3228                 /* Set status failed and set an error */
3229                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3230                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
3231                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,