3b12158e5ddd7c1ff3453be13e30fc34f156b44c
[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 #include "modest-account-protocol.h"
70
71 #define KB 1024
72
73 /* 
74  * Remove all these #ifdef stuff when the tinymail's idle calls become
75  * locked
76  */
77 #define TINYMAIL_IDLES_NOT_LOCKED_YET 1
78
79 /* 'private'/'protected' functions */
80 static void modest_mail_operation_class_init (ModestMailOperationClass *klass);
81 static void modest_mail_operation_init       (ModestMailOperation *obj);
82 static void modest_mail_operation_finalize   (GObject *obj);
83
84 static void     get_msg_async_cb (TnyFolder *folder, 
85                                   gboolean cancelled, 
86                                   TnyMsg *msg, 
87                                   GError *rr, 
88                                   gpointer user_data);
89
90 static void     get_msg_status_cb (GObject *obj,
91                                    TnyStatus *status,  
92                                    gpointer user_data);
93
94 static void     modest_mail_operation_notify_start (ModestMailOperation *self);
95 static void     modest_mail_operation_notify_end (ModestMailOperation *self);
96
97 static void     notify_progress_of_multiple_messages (ModestMailOperation *self,
98                                                       TnyStatus *status,
99                                                       gint *last_total_bytes,
100                                                       gint *sum_total_bytes,
101                                                       gint total_bytes,
102                                                       gboolean increment_done);
103
104 static guint    compute_message_list_size (TnyList *headers, guint num_elements);
105
106 static int      compare_headers_by_date   (gconstpointer a,
107                                            gconstpointer b);
108
109 static void     sync_folder_finish_callback (TnyFolder *self, 
110                                              gboolean cancelled, 
111                                              GError *err, 
112                                              gpointer user_data);
113
114 static gboolean _check_memory_low         (ModestMailOperation *mail_op);
115
116
117 typedef struct {
118         ModestTnySendQueue *queue;
119         ModestMailOperation *self;
120         guint error_handler;
121         guint start_handler;
122         guint stop_handler;
123 } RunQueueHelper;
124
125 static void run_queue_notify_and_destroy (RunQueueHelper *helper,
126                                           ModestMailOperationStatus status);
127
128 /* Helpers for the update account operation (send & receive)*/
129 typedef struct 
130 {
131         ModestMailOperation *mail_op;
132         gchar *account_name;
133         UpdateAccountCallback callback;
134         gpointer user_data;
135         TnyList *folders;
136         gint pending_calls;
137         gboolean poke_all;
138         TnyFolderObserver *inbox_observer;
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         ModestMailOperation *mailop;
1143         TnyMsg *msg;
1144         SaveToDraftstCallback callback;
1145         gpointer userdata;
1146 } FinishSaveRemoteDraftInfo;
1147
1148 static void
1149 finish_save_remote_draft (ModestAccountProtocol *protocol,
1150                           GError *err,
1151                           const gchar *account_id,
1152                           TnyMsg *new_remote_msg,
1153                           TnyMsg *new_msg,
1154                           TnyMsg *old_msg,
1155                           gpointer userdata)
1156 {
1157         FinishSaveRemoteDraftInfo *info = (FinishSaveRemoteDraftInfo *) userdata;
1158         ModestMailOperationPrivate *priv = NULL;
1159
1160         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mailop);
1161
1162         if (!priv->error && err != NULL) {
1163                 /* Priority for errors in save to local stage */
1164                 priv->error = g_error_copy (err);
1165                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1166         }
1167
1168         if (info->callback)
1169                 info->callback (info->mailop, info->msg, info->userdata);
1170
1171         if (info->msg)
1172                 g_object_unref (info->msg);
1173
1174         modest_mail_operation_notify_end (info->mailop);
1175         g_object_unref (info->mailop);
1176
1177         g_slice_free (FinishSaveRemoteDraftInfo, info);
1178 }
1179
1180 typedef struct
1181 {
1182         TnyTransportAccount *transport_account;
1183         TnyMsg *draft_msg;
1184         SaveToDraftstCallback callback;
1185         gpointer user_data;
1186         TnyFolder *drafts;
1187         TnyMsg *msg;
1188         ModestMailOperation *mailop;
1189 } SaveToDraftsAddMsgInfo;
1190
1191 static void
1192 modest_mail_operation_save_to_drafts_add_msg_cb(TnyFolder *self,
1193                                                 gboolean canceled,
1194                                                 GError *err,
1195                                                 gpointer userdata)
1196 {
1197         ModestMailOperationPrivate *priv = NULL;
1198         SaveToDraftsAddMsgInfo *info = (SaveToDraftsAddMsgInfo *) userdata;
1199         GError *io_error = NULL;
1200         gboolean callback_called = FALSE;
1201
1202         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mailop);
1203
1204         if (priv->error && priv->error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1205                 io_error = priv->error;
1206                 priv->error = NULL;
1207         }
1208         if (priv->error) {
1209                 g_warning ("%s: priv->error != NULL", __FUNCTION__);
1210                 g_error_free(priv->error);
1211         }
1212
1213         priv->error = (err == NULL) ? NULL : g_error_copy(err);
1214
1215         if ((!priv->error) && (info->draft_msg != NULL)) {
1216                 TnyHeader *header = tny_msg_get_header (info->draft_msg);
1217                 TnyFolder *src_folder = tny_header_get_folder (header);
1218
1219                 g_debug ("--- REMOVE AND SYNC");
1220                 /* Remove the old draft */
1221                 tny_folder_remove_msg (src_folder, header, NULL);
1222
1223                 /* Synchronize to expunge and to update the msg counts */
1224                 tny_folder_sync_async (info->drafts, TRUE, NULL, NULL, NULL);
1225                 tny_folder_sync_async (src_folder, TRUE, NULL, NULL, NULL);
1226                 g_debug ("--- REMOVED - SYNCED");
1227
1228                 g_object_unref (G_OBJECT(header));
1229                 g_object_unref (G_OBJECT(src_folder));
1230         }
1231
1232         if (priv->error) {
1233                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1234                 if (io_error) {
1235                         g_error_free (io_error);
1236                         io_error = NULL;
1237                 }
1238         } else if (io_error) {
1239                 priv->error = io_error;
1240                 priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
1241         } else {
1242                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1243         }
1244
1245         if (info->transport_account) {
1246                 ModestProtocolType transport_protocol_type;
1247                 ModestProtocol *transport_protocol;
1248
1249                 transport_protocol_type = modest_tny_account_get_protocol_type (TNY_ACCOUNT (info->transport_account));
1250
1251                 transport_protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
1252                                                                                     transport_protocol_type);
1253                 if (transport_protocol && MODEST_IS_ACCOUNT_PROTOCOL (transport_protocol)) {
1254                         FinishSaveRemoteDraftInfo *srd_info = g_slice_new (FinishSaveRemoteDraftInfo);
1255                         srd_info->mailop = info->mailop?g_object_ref (info->mailop):NULL;
1256                         srd_info->msg = info->msg?g_object_ref (info->msg):NULL;
1257                         srd_info->callback = info->callback;
1258                         srd_info->userdata = info->user_data;
1259                         modest_account_protocol_save_remote_draft (MODEST_ACCOUNT_PROTOCOL (transport_protocol), 
1260                                                                    tny_account_get_id (TNY_ACCOUNT (info->transport_account)),
1261                                                                    info->msg, info->draft_msg,
1262                                                                    finish_save_remote_draft,
1263                                                                    srd_info);
1264                                                                    
1265                         callback_called = TRUE;
1266                 }
1267         }
1268
1269         /* Call the user callback */
1270         if (!callback_called && info->callback)
1271                 info->callback (info->mailop, info->msg, info->user_data);
1272
1273         if (info->transport_account)
1274                 g_object_unref (G_OBJECT(info->transport_account));
1275         if (info->draft_msg)
1276                 g_object_unref (G_OBJECT (info->draft_msg));
1277         if (info->drafts)
1278                 g_object_unref (G_OBJECT(info->drafts));
1279         if (info->msg)
1280                 g_object_unref (G_OBJECT (info->msg));
1281
1282         if (!callback_called)
1283                 modest_mail_operation_notify_end (info->mailop);
1284         if (info->mailop)
1285                 g_object_unref(info->mailop);
1286         g_slice_free (SaveToDraftsAddMsgInfo, info);
1287 }
1288
1289 typedef struct
1290 {
1291         TnyTransportAccount *transport_account;
1292         TnyMsg *draft_msg;
1293         SaveToDraftstCallback callback;
1294         gpointer user_data;
1295 } SaveToDraftsInfo;
1296
1297 static void
1298 modest_mail_operation_save_to_drafts_cb (ModestMailOperation *self,
1299                                          TnyMsg *msg,
1300                                          gpointer userdata)
1301 {
1302         TnyFolder *drafts = NULL;
1303         ModestMailOperationPrivate *priv = NULL;
1304         SaveToDraftsInfo *info = (SaveToDraftsInfo *) userdata;
1305
1306         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1307
1308         if (!msg) {
1309                 if (!(priv->error)) {
1310                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1311                                      MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
1312                                      "modest: failed to create a new msg\n");
1313                 }
1314         } else {
1315                 drafts = modest_tny_account_get_special_folder (TNY_ACCOUNT (info->transport_account),
1316                                                                 TNY_FOLDER_TYPE_DRAFTS);
1317                 if (!drafts && !(priv->error)) {
1318                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1319                                      MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1320                                      "modest: failed to create a new msg\n");
1321                 }
1322         }
1323
1324         if (!priv->error || priv->error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1325                 if (drafts) {
1326                         SaveToDraftsAddMsgInfo *cb_info = g_slice_new(SaveToDraftsAddMsgInfo);
1327                         cb_info->transport_account = g_object_ref(info->transport_account);
1328                         cb_info->draft_msg = info->draft_msg ? g_object_ref(info->draft_msg) : NULL;
1329                         cb_info->callback = info->callback;
1330                         cb_info->user_data = info->user_data;
1331                         cb_info->drafts = g_object_ref(drafts);
1332                         cb_info->msg = g_object_ref(msg);
1333                         cb_info->mailop = g_object_ref(self);
1334                         tny_folder_add_msg_async(drafts, msg, modest_mail_operation_save_to_drafts_add_msg_cb,
1335                                                  NULL, cb_info);
1336                 }
1337         } else {
1338                 /* Call the user callback */
1339                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1340                 if (info->callback)
1341                         info->callback (self, msg, info->user_data);
1342                 modest_mail_operation_notify_end (self);
1343         }
1344
1345         if (drafts)
1346                 g_object_unref (G_OBJECT(drafts));
1347         if (info->draft_msg)
1348                 g_object_unref (G_OBJECT (info->draft_msg));
1349         if (info->transport_account)
1350                 g_object_unref (G_OBJECT(info->transport_account));
1351         g_slice_free (SaveToDraftsInfo, info);
1352 }
1353
1354 void
1355 modest_mail_operation_save_to_drafts (ModestMailOperation *self,
1356                                       TnyTransportAccount *transport_account,
1357                                       TnyMsg *draft_msg,
1358                                       const gchar *from,  const gchar *to,
1359                                       const gchar *cc,  const gchar *bcc,
1360                                       const gchar *subject, const gchar *plain_body,
1361                                       const gchar *html_body,
1362                                       const GList *attachments_list,
1363                                       const GList *images_list,
1364                                       TnyHeaderFlags priority_flags,
1365                                       const gchar *references,
1366                                       const gchar *in_reply_to,
1367                                       SaveToDraftstCallback callback,
1368                                       gpointer user_data)
1369 {
1370         ModestMailOperationPrivate *priv = NULL;
1371         SaveToDraftsInfo *info = NULL;
1372
1373         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
1374         g_return_if_fail (TNY_IS_TRANSPORT_ACCOUNT (transport_account));
1375
1376         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1377
1378         /* Get account and set it into mail_operation */
1379         priv->account = g_object_ref (transport_account);
1380         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
1381
1382         info = g_slice_new0 (SaveToDraftsInfo);
1383         info->transport_account = g_object_ref (transport_account);
1384         info->draft_msg = (draft_msg) ? g_object_ref (draft_msg) : NULL;
1385         info->callback = callback;
1386         info->user_data = user_data;
1387
1388         g_debug ("--- CREATE MESSAGE");
1389         modest_mail_operation_notify_start (self);
1390         modest_mail_operation_create_msg (self, from, to, cc, bcc, subject, plain_body, html_body,
1391                                           attachments_list, images_list, priority_flags,
1392                                           references, in_reply_to,
1393                                           modest_mail_operation_save_to_drafts_cb, info);
1394 }
1395
1396 typedef struct
1397 {
1398         ModestMailOperation *mail_op;
1399         TnyMimePart *mime_part;
1400         gssize size;
1401         GetMimePartSizeCallback callback;
1402         gpointer userdata;
1403 } GetMimePartSizeInfo;
1404
1405 /***** I N T E R N A L    F O L D E R    O B S E R V E R *****/
1406 /* We use this folder observer to track the headers that have been
1407  * added to a folder */
1408 typedef struct {
1409         GObject parent;
1410         TnyList *new_headers;
1411 } InternalFolderObserver;
1412
1413 typedef struct {
1414         GObjectClass parent;
1415 } InternalFolderObserverClass;
1416
1417 static void tny_folder_observer_init (TnyFolderObserverIface *idace);
1418
1419 G_DEFINE_TYPE_WITH_CODE (InternalFolderObserver,
1420                          internal_folder_observer,
1421                          G_TYPE_OBJECT,
1422                          G_IMPLEMENT_INTERFACE(TNY_TYPE_FOLDER_OBSERVER, tny_folder_observer_init));
1423
1424
1425 static void
1426 foreach_add_item (gpointer header, gpointer user_data)
1427 {
1428         tny_list_append (TNY_LIST (user_data), G_OBJECT (header));
1429 }
1430
1431 /* This is the method that looks for new messages in a folder */
1432 static void
1433 internal_folder_observer_update (TnyFolderObserver *self, TnyFolderChange *change)
1434 {
1435         InternalFolderObserver *derived = (InternalFolderObserver *)self;
1436         
1437         TnyFolderChangeChanged changed;
1438
1439         changed = tny_folder_change_get_changed (change);
1440
1441         if (changed & TNY_FOLDER_CHANGE_CHANGED_ADDED_HEADERS) {
1442                 TnyList *list;
1443
1444                 /* Get added headers */
1445                 list = tny_simple_list_new ();
1446                 tny_folder_change_get_added_headers (change, list);
1447
1448                 /* Add them to the folder observer */
1449                 tny_list_foreach (list, foreach_add_item, 
1450                                   derived->new_headers);
1451
1452                 g_object_unref (G_OBJECT (list));
1453         }
1454 }
1455
1456 static void
1457 internal_folder_observer_init (InternalFolderObserver *self) 
1458 {
1459         self->new_headers = tny_simple_list_new ();
1460 }
1461 static void
1462 internal_folder_observer_finalize (GObject *object) 
1463 {
1464         InternalFolderObserver *self;
1465
1466         self = (InternalFolderObserver *) object;
1467         g_object_unref (self->new_headers);
1468
1469         G_OBJECT_CLASS (internal_folder_observer_parent_class)->finalize (object);
1470 }
1471 static void
1472 tny_folder_observer_init (TnyFolderObserverIface *iface) 
1473 {
1474         iface->update = internal_folder_observer_update;
1475 }
1476 static void
1477 internal_folder_observer_class_init (InternalFolderObserverClass *klass) 
1478 {
1479         GObjectClass *object_class;
1480
1481         internal_folder_observer_parent_class = g_type_class_peek_parent (klass);
1482         object_class = (GObjectClass*) klass;
1483         object_class->finalize = internal_folder_observer_finalize;
1484 }
1485
1486 static void
1487 destroy_update_account_info (UpdateAccountInfo *info)
1488 {
1489         g_free (info->account_name);
1490         g_object_unref (info->folders);
1491         g_object_unref (info->mail_op);
1492         g_slice_free (UpdateAccountInfo, info);
1493 }
1494
1495
1496 static void
1497 update_account_send_mail (UpdateAccountInfo *info)
1498 {
1499         TnyTransportAccount *transport_account = NULL;
1500         ModestTnyAccountStore *account_store;
1501
1502         account_store = modest_runtime_get_account_store ();
1503
1504         /* We don't try to send messages while sending mails is blocked */
1505         if (modest_tny_account_store_is_send_mail_blocked (account_store))
1506                 return;
1507
1508         /* Get the transport account */
1509         transport_account = (TnyTransportAccount *) 
1510                 modest_tny_account_store_get_server_account (account_store, info->account_name, 
1511                                                              TNY_ACCOUNT_TYPE_TRANSPORT);
1512
1513         if (transport_account) {
1514                 ModestTnySendQueue *send_queue;
1515                 TnyFolder *outbox;
1516                 guint num_messages;
1517
1518                 send_queue = modest_runtime_get_send_queue (transport_account, TRUE);
1519                 g_object_unref (transport_account);
1520
1521                 if (TNY_IS_SEND_QUEUE (send_queue)) {
1522                         /* Get outbox folder */
1523                         outbox = tny_send_queue_get_outbox (TNY_SEND_QUEUE (send_queue));
1524                         if (outbox) { /* this could fail in some cases */
1525                                 num_messages = tny_folder_get_all_count (outbox);
1526                                 g_object_unref (outbox);
1527                         } else {
1528                                 g_warning ("%s: could not get outbox", __FUNCTION__);
1529                                 num_messages = 0;
1530                         }
1531
1532                         if (num_messages != 0) {
1533                                 ModestMailOperation *mail_op;
1534                                 /* Reenable suspended items */
1535                                 mail_op = modest_mail_operation_new (NULL);
1536                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1537                                                                  mail_op);
1538                                 modest_mail_operation_queue_wakeup (mail_op, MODEST_TNY_SEND_QUEUE (send_queue));
1539
1540                                 /* Try to send */
1541                                 modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue), 
1542                                                                                   info->interactive);
1543                         }
1544                 }
1545         }
1546 }
1547
1548 static void
1549 update_account_get_msg_async_cb (TnyFolder *folder, 
1550                                  gboolean canceled, 
1551                                  TnyMsg *msg, 
1552                                  GError *err, 
1553                                  gpointer user_data)
1554 {
1555         GetMsgInfo *msg_info = (GetMsgInfo *) user_data;
1556         ModestMailOperationPrivate *priv;
1557
1558         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (msg_info->mail_op);
1559         priv->done++;
1560
1561         if (TNY_IS_MSG (msg)) {
1562                 TnyHeader *header = tny_msg_get_header (msg);
1563
1564                 if (header) {
1565                         ModestMailOperationState *state;
1566                         state = modest_mail_operation_clone_state (msg_info->mail_op);
1567                         msg_info->sum_total_bytes += tny_header_get_message_size (header);
1568                         state->bytes_done = msg_info->sum_total_bytes;
1569                         state->bytes_total = msg_info->total_bytes;
1570
1571                         /* Notify the status change. Only notify about changes
1572                            referred to bytes */
1573                         g_signal_emit (G_OBJECT (msg_info->mail_op), 
1574                                        signals[PROGRESS_CHANGED_SIGNAL], 
1575                                        0, state, NULL);
1576
1577                         g_object_unref (header);
1578                         g_slice_free (ModestMailOperationState, state);
1579                 }
1580         }
1581
1582         if (priv->done == priv->total) {
1583                 TnyList *new_headers;
1584                 UpdateAccountInfo *info;
1585
1586                 /* After getting all the messages send the ones in the
1587                    outboxes */
1588                 info = (UpdateAccountInfo *) msg_info->user_data;
1589                 update_account_send_mail (info);
1590
1591                 /* Check if the operation was a success */
1592                 if (!priv->error)
1593                         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1594                 
1595                 /* Call the user callback and free */
1596                 new_headers = tny_iterator_get_list (msg_info->more_msgs);
1597                 update_account_notify_user_and_free (info, new_headers);
1598                 g_object_unref (new_headers);
1599
1600                 /* Delete the helper */
1601                 g_object_unref (msg_info->more_msgs);
1602                 g_object_unref (msg_info->mail_op);
1603                 g_slice_free (GetMsgInfo, msg_info);
1604         }
1605 }
1606
1607 static void
1608 update_account_notify_user_and_free (UpdateAccountInfo *info, 
1609                                      TnyList *new_headers)
1610 {
1611         /* Set the account back to not busy */
1612         modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), 
1613                                              info->account_name, FALSE);
1614         
1615         /* User callback */
1616         if (info->callback)
1617                 info->callback (info->mail_op, new_headers, info->user_data);
1618         
1619         /* Mail operation end */
1620         modest_mail_operation_notify_end (info->mail_op);
1621
1622         /* Frees */
1623         if (new_headers)
1624                 g_object_unref (new_headers);
1625         destroy_update_account_info (info);
1626 }
1627
1628 static void
1629 inbox_refreshed_cb (TnyFolder *inbox, 
1630                     gboolean canceled, 
1631                     GError *err, 
1632                     gpointer user_data)
1633 {       
1634         UpdateAccountInfo *info;
1635         ModestMailOperationPrivate *priv;
1636         TnyIterator *new_headers_iter;
1637         GPtrArray *new_headers_array = NULL;
1638         gint max_size, retrieve_limit, i;
1639         ModestAccountMgr *mgr;
1640         ModestAccountRetrieveType retrieve_type;
1641         TnyList *new_headers = NULL;
1642         gboolean headers_only;
1643         time_t time_to_store;
1644
1645         info = (UpdateAccountInfo *) user_data;
1646         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
1647         mgr = modest_runtime_get_account_mgr ();
1648
1649         if (canceled || err) {
1650                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1651                 if (err)
1652                         priv->error = g_error_copy (err);
1653                 else
1654                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1655                                      MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
1656                                      "canceled");
1657
1658                 if (inbox)
1659                         tny_folder_remove_observer (inbox, info->inbox_observer);
1660                 g_object_unref (info->inbox_observer);
1661                 info->inbox_observer = NULL;
1662
1663                 /* Notify the user about the error and then exit */
1664                 update_account_notify_user_and_free (info, NULL);
1665                 return;
1666         }
1667
1668         if (!inbox) {
1669                 /* Try to send anyway */
1670                 goto send_mail;
1671         }
1672
1673         /* Set the last updated as the current time */
1674 #ifdef MODEST_USE_LIBTIME
1675         struct tm utc_tm;
1676         time_get_utc (&utc_tm);
1677         time_to_store = time_mktime (&utc_tm, "GMT");
1678 #else
1679         time_to_store = time (NULL);
1680 #endif
1681         modest_account_mgr_set_last_updated (mgr, tny_account_get_id (priv->account), time_to_store);
1682
1683         /* Get the message max size */
1684         max_size  = modest_conf_get_int (modest_runtime_get_conf (),
1685                                          MODEST_CONF_MSG_SIZE_LIMIT, NULL);
1686         if (max_size == 0)
1687                 max_size = G_MAXINT;
1688         else
1689                 max_size = max_size * KB;
1690
1691         /* Create the new headers array. We need it to sort the
1692            new headers by date */
1693         new_headers_array = g_ptr_array_new ();
1694         if (info->inbox_observer) {
1695                 new_headers_iter = tny_list_create_iterator (((InternalFolderObserver *) info->inbox_observer)->new_headers);
1696                 while (!tny_iterator_is_done (new_headers_iter)) {
1697                         TnyHeader *header = NULL;
1698
1699                         header = TNY_HEADER (tny_iterator_get_current (new_headers_iter));
1700                         /* Apply per-message size limits */
1701                         if (tny_header_get_message_size (header) < max_size)
1702                                 g_ptr_array_add (new_headers_array, g_object_ref (header));
1703
1704                         g_object_unref (header);
1705                         tny_iterator_next (new_headers_iter);
1706                 }
1707                 g_object_unref (new_headers_iter);
1708
1709                 tny_folder_remove_observer (inbox, info->inbox_observer);
1710                 g_object_unref (info->inbox_observer);
1711                 info->inbox_observer = NULL;
1712         }
1713
1714         if (new_headers_array->len == 0) {
1715                 g_ptr_array_free (new_headers_array, FALSE);
1716                 goto send_mail;
1717         }
1718
1719         /* Get per-account message amount retrieval limit */
1720         retrieve_limit = modest_account_mgr_get_retrieve_limit (mgr, info->account_name);
1721         if (retrieve_limit == 0)
1722                 retrieve_limit = G_MAXINT;
1723
1724         /* Get per-account retrieval type */
1725         retrieve_type = modest_account_mgr_get_retrieve_type (mgr, info->account_name);
1726         headers_only = (retrieve_type == MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY);
1727
1728         /* Order by date */
1729         g_ptr_array_sort (new_headers_array, (GCompareFunc) compare_headers_by_date);
1730
1731         /* Copy the headers to a list and free the array */
1732         new_headers = tny_simple_list_new ();
1733         for (i=0; i < new_headers_array->len; i++) {
1734                 TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers_array, i));
1735                 /* We want the first element to be the most recent
1736                    one, that's why we reverse the list */
1737                 tny_list_prepend (new_headers, G_OBJECT (header));
1738         }
1739         g_ptr_array_foreach (new_headers_array, (GFunc) g_object_unref, NULL);
1740         g_ptr_array_free (new_headers_array, FALSE);
1741
1742         if (!headers_only && (tny_list_get_length (new_headers) > 0)) {
1743                 gint msg_num = 0;
1744                 TnyIterator *iter;
1745                 GetMsgInfo *msg_info;
1746
1747                 priv->done = 0;
1748                 priv->total = MIN (tny_list_get_length (new_headers), retrieve_limit);
1749
1750                 iter = tny_list_create_iterator (new_headers);
1751
1752                 /* Create the message info */
1753                 msg_info = g_slice_new0 (GetMsgInfo);
1754                 msg_info->mail_op = g_object_ref (info->mail_op);
1755                 msg_info->total_bytes = compute_message_list_size (new_headers, priv->total);
1756                 msg_info->more_msgs = g_object_ref (iter);
1757                 msg_info->user_data = info;
1758
1759                 while ((msg_num < priv->total ) && !tny_iterator_is_done (iter)) {
1760                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1761                         TnyFolder *folder = tny_header_get_folder (header);
1762
1763                         /* Get message in an async way */
1764                         tny_folder_get_msg_async (folder, header, update_account_get_msg_async_cb,
1765                                                   NULL, msg_info);
1766
1767                         g_object_unref (folder);
1768
1769                         msg_num++;
1770                         tny_iterator_next (iter);
1771                 }
1772                 g_object_unref (iter);
1773
1774                 /* The mail operation will finish when the last
1775                    message is retrieved */
1776                 return;
1777         }
1778  send_mail:
1779         /* If we don't have to retrieve the new messages then
1780            simply send mail */
1781         update_account_send_mail (info);
1782
1783         /* Check if the operation was a success */
1784         if (!priv->error)
1785                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1786
1787         /* Call the user callback and free */
1788         update_account_notify_user_and_free (info, new_headers);
1789 }
1790
1791 static void
1792 inbox_refresh_status_update (GObject *obj,
1793                              TnyStatus *status,
1794                              gpointer user_data)
1795 {
1796         UpdateAccountInfo *info = NULL;
1797         ModestMailOperation *self = NULL;
1798         ModestMailOperationPrivate *priv = NULL;
1799         ModestMailOperationState *state;
1800
1801         g_return_if_fail (user_data != NULL);
1802         g_return_if_fail (status != NULL);
1803
1804         /* Show only the status information we want */
1805         if (status->code != TNY_FOLDER_STATUS_CODE_REFRESH)
1806                 return;
1807
1808         info = (UpdateAccountInfo *) user_data;
1809         self = info->mail_op;
1810         g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
1811
1812         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1813
1814         priv->done = status->position;
1815         priv->total = status->of_total;
1816
1817         state = modest_mail_operation_clone_state (self);
1818
1819         /* This is not a GDK lock because we are a Tinymail callback and
1820          * Tinymail already acquires the Gdk lock */
1821         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
1822
1823         g_slice_free (ModestMailOperationState, state);
1824 }
1825
1826 static void 
1827 recurse_folders_async_cb (TnyFolderStore *folder_store, 
1828                           gboolean canceled,
1829                           TnyList *list, 
1830                           GError *err, 
1831                           gpointer user_data)
1832 {
1833         UpdateAccountInfo *info;
1834         ModestMailOperationPrivate *priv;
1835     
1836         info = (UpdateAccountInfo *) user_data;
1837         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
1838
1839         if (err || canceled) {
1840                 /* If the error was previosly set by another callback
1841                    don't set it again */
1842                 if (!priv->error) {
1843                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1844                         if (err)
1845                                 priv->error = g_error_copy (err);
1846                         else
1847                                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1848                                              MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
1849                                              "canceled");
1850                 }
1851         } else { 
1852                 /* We're not getting INBOX children if we don't want to poke all */
1853                 TnyIterator *iter = tny_list_create_iterator (list);
1854                 while (!tny_iterator_is_done (iter)) {
1855                         TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter);
1856
1857                         /* Add to the list of all folders */
1858                         tny_list_append (info->folders, (GObject *) folder);
1859                         
1860                         if (info->poke_all) {
1861                                 TnyList *folders = tny_simple_list_new ();
1862                                 /* Add pending call */
1863                                 info->pending_calls++;
1864                                 
1865                                 tny_folder_store_get_folders_async (folder, folders, NULL, FALSE,
1866                                                                     recurse_folders_async_cb, 
1867                                                                     NULL, info);
1868                                 g_object_unref (folders);
1869                         }
1870                         
1871                         g_object_unref (G_OBJECT (folder));
1872                         
1873                         tny_iterator_next (iter);           
1874                 }
1875                 g_object_unref (G_OBJECT (iter));
1876         }
1877
1878         /* Remove my own pending call */
1879         info->pending_calls--;
1880
1881         /* This means that we have all the folders */
1882         if (info->pending_calls == 0) {
1883                 TnyIterator *iter_all_folders;
1884                 TnyFolder *inbox = NULL;
1885
1886                 /* If there was any error do not continue */
1887                 if (priv->error) {
1888                         update_account_notify_user_and_free (info, NULL);
1889                         return;
1890                 }
1891
1892                 iter_all_folders = tny_list_create_iterator (info->folders);
1893
1894                 /* Do a poke status over all folders */
1895                 while (!tny_iterator_is_done (iter_all_folders) &&
1896                        priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
1897                         TnyFolder *folder = NULL;
1898
1899                         folder = TNY_FOLDER (tny_iterator_get_current (iter_all_folders));
1900
1901                         if (tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_INBOX) {
1902                                 /* Get a reference to the INBOX */
1903                                 inbox = g_object_ref (folder);
1904                         } else {
1905                                 /* Issue a poke status over the folder */
1906                                 if (info->poke_all)
1907                                         tny_folder_poke_status (folder);
1908                         }
1909
1910                         /* Free and go to next */
1911                         g_object_unref (folder);
1912                         tny_iterator_next (iter_all_folders);
1913                 }
1914                 g_object_unref (iter_all_folders);
1915
1916                 /* Refresh the INBOX */
1917                 if (inbox) {
1918                         /* Refresh the folder. Our observer receives
1919                          * the new emails during folder refreshes, so
1920                          * we can use observer->new_headers
1921                          */
1922                         info->inbox_observer = g_object_new (internal_folder_observer_get_type (), NULL);
1923                         tny_folder_add_observer (inbox, info->inbox_observer);
1924
1925                         /* Refresh the INBOX */
1926                         tny_folder_refresh_async (inbox, inbox_refreshed_cb, inbox_refresh_status_update, info);
1927                         g_object_unref (inbox);
1928                 } else {
1929                         /* We could not perform the inbox refresh but
1930                            we'll try to send mails anyway */
1931                         inbox_refreshed_cb (inbox, FALSE, NULL, info);
1932                 }
1933         }
1934 }
1935
1936 void
1937 modest_mail_operation_update_account (ModestMailOperation *self,
1938                                       const gchar *account_name,
1939                                       gboolean poke_all,
1940                                       gboolean interactive,
1941                                       UpdateAccountCallback callback,
1942                                       gpointer user_data)
1943 {
1944         UpdateAccountInfo *info = NULL;
1945         ModestMailOperationPrivate *priv = NULL;
1946         ModestTnyAccountStore *account_store = NULL;
1947         TnyList *folders;
1948         ModestMailOperationState *state;
1949
1950         /* Init mail operation */
1951         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1952         priv->total = 0;
1953         priv->done  = 0;
1954         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
1955         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND_AND_RECEIVE;
1956
1957         /* Get the store account */
1958         account_store = modest_runtime_get_account_store ();
1959         priv->account =
1960                 modest_tny_account_store_get_server_account (account_store,
1961                                                              account_name,
1962                                                              TNY_ACCOUNT_TYPE_STORE);
1963
1964         /* The above function could return NULL */
1965         if (!priv->account) {
1966                 /* Check if the operation was a success */
1967                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1968                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1969                              "no account");
1970                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1971
1972                 /* Call the user callback */
1973                 if (callback)
1974                         callback (self, NULL, user_data);
1975
1976                 /* Notify about operation end */
1977                 modest_mail_operation_notify_end (self);
1978
1979                 return;
1980         }
1981         
1982         /* We have once seen priv->account getting finalized during this code,
1983          * therefore adding a reference (bug #82296) */
1984         
1985         g_object_ref (priv->account);
1986
1987         /* Create the helper object */
1988         info = g_slice_new0 (UpdateAccountInfo);
1989         info->pending_calls = 1;
1990         info->folders = tny_simple_list_new ();
1991         info->mail_op = g_object_ref (self);
1992         info->poke_all = poke_all;
1993         info->interactive = interactive;
1994         info->account_name = g_strdup (account_name);
1995         info->callback = callback;
1996         info->user_data = user_data;
1997
1998         /* Set account busy */
1999         modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), account_name, TRUE);
2000         modest_mail_operation_notify_start (self);
2001
2002         /* notify about the start of the operation */ 
2003         state = modest_mail_operation_clone_state (self);
2004         state->done = 0;
2005         state->total = 0;
2006
2007         /* Start notifying progress */
2008         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
2009         g_slice_free (ModestMailOperationState, state);
2010         
2011         /* Get all folders and continue in the callback */ 
2012         folders = tny_simple_list_new ();
2013         tny_folder_store_get_folders_async (TNY_FOLDER_STORE (priv->account),
2014                                             folders, NULL, FALSE,
2015                                             recurse_folders_async_cb, 
2016                                             NULL, info);
2017         g_object_unref (folders);
2018         
2019         g_object_unref (priv->account);
2020         
2021 }
2022
2023 /*
2024  * Used to notify the queue from the main
2025  * loop. We call it inside an idle call to achieve that
2026  */
2027 static gboolean
2028 idle_notify_queue (gpointer data)
2029 {
2030         ModestMailOperation *mail_op = MODEST_MAIL_OPERATION (data);
2031
2032         gdk_threads_enter ();
2033         modest_mail_operation_notify_end (mail_op);
2034         gdk_threads_leave ();
2035         g_object_unref (mail_op);
2036
2037         return FALSE;
2038 }
2039
2040 static int
2041 compare_headers_by_date (gconstpointer a,
2042                          gconstpointer b)
2043 {
2044         TnyHeader **header1, **header2;
2045         time_t sent1, sent2;
2046
2047         header1 = (TnyHeader **) a;
2048         header2 = (TnyHeader **) b;
2049
2050         sent1 = tny_header_get_date_sent (*header1);
2051         sent2 = tny_header_get_date_sent (*header2);
2052
2053         /* We want the most recent ones (greater time_t) at the
2054            beginning */
2055         if (sent1 < sent2)
2056                 return -1;
2057         else
2058                 return 1;
2059 }
2060
2061
2062 /* ******************************************************************* */
2063 /* ************************** STORE  ACTIONS ************************* */
2064 /* ******************************************************************* */
2065
2066 typedef struct {
2067         ModestMailOperation *mail_op;
2068         CreateFolderUserCallback callback;
2069         gpointer user_data;
2070 } CreateFolderInfo;
2071
2072
2073 static void
2074 create_folder_cb (TnyFolderStore *parent_folder, 
2075                   gboolean canceled, 
2076                   TnyFolder *new_folder, 
2077                   GError *err, 
2078                   gpointer user_data)
2079 {
2080         ModestMailOperationPrivate *priv;
2081         CreateFolderInfo *info;
2082
2083         info = (CreateFolderInfo *) user_data;
2084         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
2085
2086         if (canceled || err) {
2087                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2088                 if (err)
2089                         priv->error = g_error_copy (err);
2090                 else
2091                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2092                                      MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
2093                                      "canceled");               
2094         } else {
2095                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2096         }
2097
2098         /* The user will unref the new_folder */
2099         if (info->callback)
2100                 info->callback (info->mail_op, parent_folder, 
2101                                 new_folder, info->user_data);
2102         
2103         /* Notify about operation end */
2104         modest_mail_operation_notify_end (info->mail_op);
2105
2106         /* Frees */
2107         g_object_unref (info->mail_op);
2108         g_slice_free (CreateFolderInfo, info);
2109 }
2110
2111 void
2112 modest_mail_operation_create_folder (ModestMailOperation *self,
2113                                      TnyFolderStore *parent,
2114                                      const gchar *name,
2115                                      CreateFolderUserCallback callback,
2116                                      gpointer user_data)
2117 {
2118         ModestMailOperationPrivate *priv;
2119
2120         g_return_if_fail (TNY_IS_FOLDER_STORE (parent));
2121         g_return_if_fail (name);
2122         
2123         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2124         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
2125         priv->account = (TNY_IS_ACCOUNT (parent)) ? 
2126                 g_object_ref (parent) : 
2127                 modest_tny_folder_get_account (TNY_FOLDER (parent));
2128
2129         /* Check for already existing folder */
2130         if (modest_tny_folder_has_subfolder_with_name (parent, name, TRUE)) {
2131                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2132                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2133                              MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
2134                              _CS("ckdg_ib_folder_already_exists"));
2135         }
2136
2137         /* Check parent */
2138         if (TNY_IS_FOLDER (parent)) {
2139                 /* Check folder rules */
2140                 ModestTnyFolderRules rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
2141                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
2142                         /* Set status failed and set an error */
2143                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2144                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2145                                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2146                                      _("mail_in_ui_folder_create_error"));
2147                 }
2148         }
2149
2150         if (!priv->error && (!strcmp (name, " ") || strchr (name, '/'))) {
2151                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2152                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2153                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2154                              _("mail_in_ui_folder_create_error"));
2155         }
2156
2157         if (!priv->error) {
2158                 CreateFolderInfo *info;
2159
2160                 info = g_slice_new0 (CreateFolderInfo);
2161                 info->mail_op = g_object_ref (self);
2162                 info->callback = callback;
2163                 info->user_data = user_data;
2164
2165                 modest_mail_operation_notify_start (self);
2166
2167                 /* Create the folder */
2168                 tny_folder_store_create_folder_async (parent, name, create_folder_cb, 
2169                                                       NULL, info);
2170         } else {
2171                 /* Call the user callback anyway */
2172                 if (callback)
2173                         callback (self, parent, NULL, user_data);
2174                 /* Notify about operation end */
2175                 modest_mail_operation_notify_end (self);
2176         }
2177 }
2178
2179 void
2180 modest_mail_operation_remove_folder (ModestMailOperation *self,
2181                                      TnyFolder           *folder,
2182                                      gboolean             remove_to_trash)
2183 {
2184         ModestMailOperationPrivate *priv;
2185         ModestTnyFolderRules rules;
2186
2187         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2188         g_return_if_fail (TNY_IS_FOLDER (folder));
2189         
2190         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2191         
2192         /* Check folder rules */
2193         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2194         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_DELETABLE) {
2195                 /* Set status failed and set an error */
2196                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2197                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2198                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2199                              _("mail_in_ui_folder_delete_error"));
2200                 goto end;
2201         }
2202
2203         /* Get the account */
2204         priv->account = modest_tny_folder_get_account (folder);
2205         priv->op_type = MODEST_MAIL_OPERATION_TYPE_DELETE;
2206
2207         /* Delete folder or move to trash */
2208         if (remove_to_trash) {
2209                 TnyFolder *trash_folder = NULL;
2210                 trash_folder = modest_tny_account_get_special_folder (priv->account,
2211                                                                       TNY_FOLDER_TYPE_TRASH);
2212                 /* TODO: error_handling */
2213                 if (trash_folder) {
2214                         modest_mail_operation_notify_start (self);
2215                         modest_mail_operation_xfer_folder (self, folder,
2216                                                     TNY_FOLDER_STORE (trash_folder), 
2217                                                     TRUE, NULL, NULL);
2218                         g_object_unref (trash_folder);
2219                 } else {
2220                         g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL trash folder", __FUNCTION__);
2221                 }
2222         } else {
2223                 TnyFolderStore *parent = tny_folder_get_folder_store (folder);
2224                 if (parent) {
2225                         modest_mail_operation_notify_start (self);
2226                         tny_folder_store_remove_folder (parent, folder, &(priv->error));
2227                         CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
2228                         
2229                         if (!priv->error)
2230                                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2231
2232                         g_object_unref (parent);
2233                 } else
2234                         g_warning ("%s: could not get parent folder", __FUNCTION__);
2235         }
2236
2237  end:
2238         /* Notify about operation end */
2239         modest_mail_operation_notify_end (self);
2240 }
2241
2242 static void
2243 transfer_folder_status_cb (GObject *obj,
2244                            TnyStatus *status,
2245                            gpointer user_data)
2246 {
2247         ModestMailOperation *self;
2248         ModestMailOperationPrivate *priv;
2249         ModestMailOperationState *state;
2250         XFerFolderAsyncHelper *helper;
2251
2252         g_return_if_fail (status != NULL);
2253
2254         /* Show only the status information we want */
2255         if (status->code != TNY_FOLDER_STATUS_CODE_COPY_FOLDER)
2256                 return;
2257
2258         helper = (XFerFolderAsyncHelper *) user_data;
2259         g_return_if_fail (helper != NULL);
2260
2261         self = helper->mail_op;
2262         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
2263
2264         priv->done = status->position;
2265         priv->total = status->of_total;
2266
2267         state = modest_mail_operation_clone_state (self);
2268
2269         /* This is not a GDK lock because we are a Tinymail callback
2270          * which is already GDK locked by Tinymail */
2271
2272         /* no gdk_threads_enter (), CHECKED */
2273
2274         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL); 
2275
2276         /* no gdk_threads_leave (), CHECKED */
2277
2278         g_slice_free (ModestMailOperationState, state);
2279 }
2280
2281 static void
2282 transfer_folder_cb (TnyFolder *folder, 
2283                     gboolean cancelled, 
2284                     TnyFolderStore *into, 
2285                     TnyFolder *new_folder, 
2286                     GError *err, 
2287                     gpointer user_data)
2288 {
2289         XFerFolderAsyncHelper *helper;
2290         ModestMailOperation *self = NULL;
2291         ModestMailOperationPrivate *priv = NULL;
2292
2293         helper = (XFerFolderAsyncHelper *) user_data;
2294         g_return_if_fail (helper != NULL);
2295
2296         self = helper->mail_op;
2297         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
2298
2299         if (err) {
2300                 priv->error = g_error_copy (err);
2301                 priv->done = 0;
2302                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2303         } else if (cancelled) {
2304                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2305                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2306                              MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
2307                              _("Transference of %s was cancelled."),
2308                              tny_folder_get_name (folder));
2309         } else {
2310                 priv->done = 1;
2311                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2312         }
2313
2314         /* Update state of new folder */
2315         if (new_folder) {
2316                 tny_folder_refresh_async (new_folder, NULL, NULL, NULL);
2317                 tny_folder_poke_status (new_folder);
2318         }
2319
2320         /* Notify about operation end */
2321         modest_mail_operation_notify_end (self);
2322
2323         /* If user defined callback function was defined, call it */
2324         if (helper->user_callback) {
2325
2326                 /* This is not a GDK lock because we are a Tinymail callback
2327                  * which is already GDK locked by Tinymail */
2328
2329                 /* no gdk_threads_enter (), CHECKED */
2330                 helper->user_callback (self, new_folder, helper->user_data);
2331                 /* no gdk_threads_leave () , CHECKED */
2332         }
2333
2334         /* Free */
2335         g_object_unref (helper->mail_op);
2336         g_slice_free   (XFerFolderAsyncHelper, helper);
2337 }
2338
2339 /**
2340  *
2341  * This function checks if the new name is a valid name for our local
2342  * folders account. The new name could not be the same than then name
2343  * of any of the mandatory local folders
2344  *
2345  * We can not rely on tinymail because tinymail does not check the
2346  * name of the virtual folders that the account could have in the case
2347  * that we're doing a rename (because it directly calls Camel which
2348  * knows nothing about our virtual folders). 
2349  *
2350  * In the case of an actual copy/move (i.e. move/copy a folder between
2351  * accounts) tinymail uses the tny_folder_store_create_account which
2352  * is reimplemented by our ModestTnyLocalFoldersAccount that indeed
2353  * checks the new name of the folder, so this call in that case
2354  * wouldn't be needed. *But* NOTE that if tinymail changes its
2355  * implementation (if folder transfers within the same account is no
2356  * longer implemented as a rename) this call will allow Modest to work
2357  * perfectly
2358  *
2359  * If the new name is not valid, this function will set the status to
2360  * failed and will set also an error in the mail operation
2361  */
2362 static gboolean
2363 new_name_valid_if_local_account (ModestMailOperationPrivate *priv,
2364                                  TnyFolderStore *into,
2365                                  const gchar *new_name)
2366 {
2367         if (TNY_IS_ACCOUNT (into) && 
2368             modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (into)) &&
2369             modest_tny_local_folders_account_folder_name_in_use (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (into),
2370                                                                  new_name)) {
2371                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2372                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2373                              MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
2374                              _CS("ckdg_ib_folder_already_exists"));
2375                 return FALSE;
2376         } else
2377                 return TRUE;
2378 }
2379
2380 void
2381 modest_mail_operation_xfer_folder (ModestMailOperation *self,
2382                                    TnyFolder *folder,
2383                                    TnyFolderStore *parent,
2384                                    gboolean delete_original,
2385                                    XferFolderAsyncUserCallback user_callback,
2386                                    gpointer user_data)
2387 {
2388         ModestMailOperationPrivate *priv = NULL;
2389         ModestTnyFolderRules parent_rules = 0, rules; 
2390         XFerFolderAsyncHelper *helper = NULL;
2391         const gchar *folder_name = NULL;
2392         const gchar *error_msg;
2393
2394         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2395         g_return_if_fail (TNY_IS_FOLDER (folder));
2396         g_return_if_fail (TNY_IS_FOLDER_STORE (parent));
2397
2398         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2399         folder_name = tny_folder_get_name (folder);
2400
2401         /* Set the error msg */
2402         error_msg = _("mail_in_ui_folder_move_target_error");
2403
2404         /* Get account and set it into mail_operation */
2405         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2406         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2407         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2408
2409         /* Get folder rules */
2410         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2411         if (TNY_IS_FOLDER (parent))
2412                 parent_rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
2413         
2414         /* Apply operation constraints */
2415         if ((gpointer) parent == (gpointer) folder ||
2416             (!TNY_IS_FOLDER_STORE (parent)) || 
2417             (rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE)) {
2418                 /* Folder rules */
2419                 goto error;
2420         } else if (TNY_IS_FOLDER (parent) && 
2421                    (parent_rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE)) {
2422                 /* Folder rules */
2423                 goto error;
2424
2425         } else if (TNY_IS_FOLDER (parent) &&
2426                    TNY_IS_FOLDER_STORE (folder) &&
2427                    modest_tny_folder_is_ancestor (TNY_FOLDER (parent), 
2428                                                   TNY_FOLDER_STORE (folder))) {
2429                 /* Do not move a parent into a child */
2430                 goto error;
2431         } else if (TNY_IS_FOLDER_STORE (parent) &&
2432                    modest_tny_folder_has_subfolder_with_name (parent, folder_name, TRUE)) {
2433                 /* Check that the new folder name is not used by any
2434                    parent subfolder */
2435                 goto error;     
2436         } else if (!(new_name_valid_if_local_account (priv, parent, folder_name))) {
2437                 /* Check that the new folder name is not used by any
2438                    special local folder */
2439                 goto error;
2440         } else {
2441                 /* Create the helper */
2442                 helper = g_slice_new0 (XFerFolderAsyncHelper);
2443                 helper->mail_op = g_object_ref (self);
2444                 helper->user_callback = user_callback;
2445                 helper->user_data = user_data;
2446                 
2447                 /* Move/Copy folder */
2448                 modest_mail_operation_notify_start (self);
2449                 tny_folder_copy_async (folder,
2450                                        parent,
2451                                        tny_folder_get_name (folder),
2452                                        delete_original,
2453                                        transfer_folder_cb,
2454                                        transfer_folder_status_cb,
2455                                        helper);
2456                 return;
2457         }
2458
2459  error:
2460         /* Set status failed and set an error */
2461         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2462         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2463                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2464                      error_msg);
2465
2466         /* Call the user callback if exists */
2467         if (user_callback)
2468                 user_callback (self, NULL, user_data);
2469
2470         /* Notify the queue */
2471         modest_mail_operation_notify_end (self);
2472 }
2473
2474 void
2475 modest_mail_operation_rename_folder (ModestMailOperation *self,
2476                                      TnyFolder *folder,
2477                                      const gchar *name,
2478                                      XferFolderAsyncUserCallback user_callback,
2479                                      gpointer user_data)
2480 {
2481         ModestMailOperationPrivate *priv;
2482         ModestTnyFolderRules rules;
2483         XFerFolderAsyncHelper *helper;
2484
2485         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2486         g_return_if_fail (TNY_IS_FOLDER_STORE (folder));
2487         g_return_if_fail (name);
2488         
2489         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2490
2491         /* Get account and set it into mail_operation */
2492         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2493         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
2494
2495         /* Check folder rules */
2496         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2497         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_RENAMEABLE) {
2498                 goto error;
2499         } else if (!strcmp (name, " ") || strchr (name, '/')) {
2500                 goto error;
2501         } else {
2502                 TnyFolderStore *into;
2503
2504                 into = tny_folder_get_folder_store (folder);    
2505
2506                 /* Check that the new folder name is not used by any
2507                    special local folder */
2508                 if (new_name_valid_if_local_account (priv, into, name)) {
2509                         /* Create the helper */
2510                         helper = g_slice_new0 (XFerFolderAsyncHelper);
2511                         helper->mail_op = g_object_ref(self);
2512                         helper->user_callback = user_callback;
2513                         helper->user_data = user_data;
2514                 
2515                         /* Rename. Camel handles folder subscription/unsubscription */
2516                         modest_mail_operation_notify_start (self);
2517                         tny_folder_copy_async (folder, into, name, TRUE,
2518                                                transfer_folder_cb,
2519                                                transfer_folder_status_cb,
2520                                                helper);
2521                         g_object_unref (into);
2522                 } else {
2523                         g_object_unref (into);
2524                         goto error;
2525                 }
2526
2527                 return;
2528         }
2529  error:
2530         /* Set status failed and set an error */
2531         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2532         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2533                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2534                      _("FIXME: unable to rename"));
2535         
2536         if (user_callback)
2537                 user_callback (self, NULL, user_data);
2538
2539         /* Notify about operation end */
2540         modest_mail_operation_notify_end (self);
2541 }
2542
2543 /* ******************************************************************* */
2544 /* **************************  MSG  ACTIONS  ************************* */
2545 /* ******************************************************************* */
2546
2547 void 
2548 modest_mail_operation_find_msg (ModestMailOperation *self,
2549                                 TnyFolder *folder,
2550                                 const gchar *msg_uid,
2551                                 gboolean progress_feedback,
2552                                 GetMsgAsyncUserCallback user_callback,
2553                                 gpointer user_data)
2554 {
2555         GetMsgInfo *helper = NULL;
2556         ModestMailOperationPrivate *priv;
2557         
2558         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2559         g_return_if_fail (msg_uid != NULL);
2560         
2561         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2562         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2563         priv->total = 1;
2564         priv->done = 0;
2565
2566         /* Check memory low */
2567         if (_check_memory_low (self)) {
2568                 if (user_callback)
2569                         user_callback (self, NULL, FALSE, NULL, priv->error, user_data);
2570                 modest_mail_operation_notify_end (self);
2571                 return;
2572         }
2573
2574         /* Get account and set it into mail_operation */
2575         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2576         
2577         /* Check for cached messages */
2578         if (progress_feedback) {
2579                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2580         } else {
2581                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
2582         }
2583         
2584         /* Create the helper */
2585         helper = g_slice_new0 (GetMsgInfo);
2586         helper->header = NULL;
2587         helper->mail_op = g_object_ref (self);
2588         helper->user_callback = user_callback;
2589         helper->user_data = user_data;
2590         helper->destroy_notify = NULL;
2591         helper->last_total_bytes = 0;
2592         helper->sum_total_bytes = 0;
2593         helper->total_bytes = 0;
2594         helper->more_msgs = NULL;
2595
2596         modest_mail_operation_notify_start (self);
2597         
2598         /* notify about the start of the operation */ 
2599         ModestMailOperationState *state;
2600         state = modest_mail_operation_clone_state (self);
2601         state->done = 0;
2602         state->total = 0;
2603         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
2604                                 0, state, NULL);
2605         g_slice_free (ModestMailOperationState, state);
2606         
2607         tny_folder_find_msg_async (folder, msg_uid, get_msg_async_cb, get_msg_status_cb, helper);
2608 }
2609
2610 void 
2611 modest_mail_operation_get_msg (ModestMailOperation *self,
2612                                TnyHeader *header,
2613                                gboolean progress_feedback,
2614                                GetMsgAsyncUserCallback user_callback,
2615                                gpointer user_data)
2616 {
2617         GetMsgInfo *helper = NULL;
2618         TnyFolder *folder;
2619         ModestMailOperationPrivate *priv;
2620         
2621         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2622         g_return_if_fail (TNY_IS_HEADER (header));
2623         
2624         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2625         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2626         priv->total = 1;
2627         priv->done = 0;
2628
2629         /* Check memory low */
2630         if (_check_memory_low (self)) {
2631                 if (user_callback)
2632                         user_callback (self, header, FALSE, NULL, priv->error, user_data);
2633                 modest_mail_operation_notify_end (self);
2634                 return;
2635         }
2636
2637         /* Get account and set it into mail_operation */
2638         folder = tny_header_get_folder (header);
2639         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2640         
2641         /* Check for cached messages */
2642         if (progress_feedback) {
2643                 if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)
2644                         priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN;
2645                 else 
2646                         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2647         } else {
2648                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
2649         }
2650         
2651         /* Create the helper */
2652         helper = g_slice_new0 (GetMsgInfo);
2653         helper->header = g_object_ref (header);
2654         helper->mail_op = g_object_ref (self);
2655         helper->user_callback = user_callback;
2656         helper->user_data = user_data;
2657         helper->destroy_notify = NULL;
2658         helper->last_total_bytes = 0;
2659         helper->sum_total_bytes = 0;
2660         helper->total_bytes = tny_header_get_message_size (header);
2661         helper->more_msgs = NULL;
2662
2663         modest_mail_operation_notify_start (self);
2664         
2665         /* notify about the start of the operation */ 
2666         ModestMailOperationState *state;
2667         state = modest_mail_operation_clone_state (self);
2668         state->done = 0;
2669         state->total = 0;
2670         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
2671                                 0, state, NULL);
2672         g_slice_free (ModestMailOperationState, state);
2673         
2674         tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, helper);
2675
2676         g_object_unref (G_OBJECT (folder));
2677 }
2678
2679 static void     
2680 get_msg_status_cb (GObject *obj,
2681                    TnyStatus *status,  
2682                    gpointer user_data)
2683 {
2684         GetMsgInfo *helper = NULL;
2685
2686         g_return_if_fail (status != NULL);
2687
2688         /* Show only the status information we want */
2689         if (status->code != TNY_FOLDER_STATUS_CODE_GET_MSG)
2690                 return;
2691
2692         helper = (GetMsgInfo *) user_data;
2693         g_return_if_fail (helper != NULL);       
2694
2695         /* Notify progress */
2696         notify_progress_of_multiple_messages (helper->mail_op, status, &(helper->last_total_bytes), 
2697                                               &(helper->sum_total_bytes), helper->total_bytes, FALSE);
2698 }
2699
2700 static void
2701 get_msg_async_cb (TnyFolder *folder, 
2702                   gboolean canceled, 
2703                   TnyMsg *msg, 
2704                   GError *err, 
2705                   gpointer user_data)
2706 {
2707         GetMsgInfo *info = NULL;
2708         ModestMailOperationPrivate *priv = NULL;
2709         gboolean finished;
2710
2711         info = (GetMsgInfo *) user_data;
2712
2713         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
2714         priv->done++;
2715
2716         if (info->more_msgs) {
2717                 tny_iterator_next (info->more_msgs);
2718                 finished = (tny_iterator_is_done (info->more_msgs));
2719         } else {
2720                 finished = (priv->done == priv->total) ? TRUE : FALSE;
2721         }
2722
2723         /* If canceled by the user, ignore the error given by Tinymail */
2724         if (canceled) {
2725                 canceled = TRUE;
2726                 finished = TRUE;
2727                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2728         } else if (err) {
2729                 priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
2730                 priv->error = g_error_copy ((const GError *) err);
2731                 if (priv->error) {
2732                         priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
2733                 } else {
2734                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2735                                      MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2736                                      err->message);
2737                 }
2738         } else if (finished && priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
2739                 /* Set the success status before calling the user callback */
2740                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2741         }
2742
2743         if (info->header == NULL && msg)
2744                 info->header = tny_msg_get_header (msg);
2745
2746         /* Call the user callback */
2747         if (info->user_callback)
2748                 info->user_callback (info->mail_op, info->header, canceled, 
2749                                      msg, err, info->user_data);
2750
2751         /* Notify about operation end if this is the last callback */
2752         if (finished) {
2753                 /* Free user data */
2754                 if (info->destroy_notify)
2755                         info->destroy_notify (info->user_data);
2756
2757                 /* Notify about operation end */
2758                 modest_mail_operation_notify_end (info->mail_op);
2759
2760                 /* Clean */
2761                 if (info->more_msgs)
2762                         g_object_unref (info->more_msgs);
2763                 if (info->header)
2764                         g_object_unref (info->header);
2765                 g_object_unref (info->mail_op);
2766                 g_slice_free (GetMsgInfo, info);
2767         } else if (info->more_msgs) {
2768                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (info->more_msgs));
2769                 TnyFolder *folder = tny_header_get_folder (header);
2770
2771                 g_object_unref (info->header);
2772                 info->header = g_object_ref (header);
2773
2774                 /* Retrieve the next message */
2775                 tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, info);
2776
2777                 g_object_unref (header);
2778                 g_object_unref (folder);
2779         } else {
2780                 g_warning ("%s: finished != TRUE but no messages left", __FUNCTION__);
2781         }
2782 }
2783
2784 void 
2785 modest_mail_operation_get_msgs_full (ModestMailOperation *self,
2786                                      TnyList *header_list, 
2787                                      GetMsgAsyncUserCallback user_callback,
2788                                      gpointer user_data,
2789                                      GDestroyNotify notify)
2790 {
2791         ModestMailOperationPrivate *priv = NULL;
2792         gint msg_list_size;
2793         TnyIterator *iter = NULL;
2794         gboolean has_uncached_messages;
2795         
2796         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2797
2798         /* Init mail operation */
2799         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2800         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2801         priv->done = 0;
2802         priv->total = tny_list_get_length(header_list);
2803
2804         /* Check memory low */
2805         if (_check_memory_low (self)) {
2806                 if (user_callback) {
2807                         TnyHeader *header = NULL;
2808                         TnyIterator *iter;
2809
2810                         if (tny_list_get_length (header_list) > 0) {
2811                                 iter = tny_list_create_iterator (header_list);
2812                                 header = (TnyHeader *) tny_iterator_get_current (iter);
2813                                 g_object_unref (iter);
2814                         }
2815                         user_callback (self, header, FALSE, NULL, priv->error, user_data);
2816                         if (header)
2817                                 g_object_unref (header);
2818                 }
2819                 if (notify)
2820                         notify (user_data);
2821                 /* Notify about operation end */
2822                 modest_mail_operation_notify_end (self);
2823                 return;
2824         }
2825
2826         /* Check uncached messages */
2827         for (iter = tny_list_create_iterator (header_list), has_uncached_messages = FALSE;
2828              !has_uncached_messages && !tny_iterator_is_done (iter); 
2829              tny_iterator_next (iter)) {
2830                 TnyHeader *header;
2831
2832                 header = (TnyHeader *) tny_iterator_get_current (iter);
2833                 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
2834                         has_uncached_messages = TRUE;
2835                 g_object_unref (header);
2836         }       
2837         g_object_unref (iter);
2838         priv->op_type = has_uncached_messages?MODEST_MAIL_OPERATION_TYPE_RECEIVE:MODEST_MAIL_OPERATION_TYPE_OPEN;
2839
2840         /* Get account and set it into mail_operation */
2841         if (tny_list_get_length (header_list) >= 1) {
2842                 TnyIterator *iterator = tny_list_create_iterator (header_list);
2843                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iterator));
2844                 if (header) {
2845                         TnyFolder *folder = tny_header_get_folder (header);
2846                         if (folder) {           
2847                                 priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2848                                 g_object_unref (folder);
2849                         }
2850                         g_object_unref (header);
2851                 }
2852                 g_object_unref (iterator);
2853         }
2854
2855         msg_list_size = compute_message_list_size (header_list, 0);
2856
2857         modest_mail_operation_notify_start (self);
2858         iter = tny_list_create_iterator (header_list);
2859         if (!tny_iterator_is_done (iter)) {
2860                 /* notify about the start of the operation */
2861                 ModestMailOperationState *state;
2862                 state = modest_mail_operation_clone_state (self);
2863                 state->done = 0;
2864                 state->total = 0;
2865                 g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
2866                                0, state, NULL);
2867
2868                 GetMsgInfo *msg_info = NULL;
2869                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2870                 TnyFolder *folder = tny_header_get_folder (header);
2871
2872                 /* Create the message info */
2873                 msg_info = g_slice_new0 (GetMsgInfo);
2874                 msg_info->mail_op = g_object_ref (self);
2875                 msg_info->header = g_object_ref (header);
2876                 msg_info->more_msgs = g_object_ref (iter);
2877                 msg_info->user_callback = user_callback;
2878                 msg_info->user_data = user_data;
2879                 msg_info->destroy_notify = notify;
2880                 msg_info->last_total_bytes = 0;
2881                 msg_info->sum_total_bytes = 0;
2882                 msg_info->total_bytes = msg_list_size;
2883
2884                 /* The callback will call it per each header */
2885                 tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, msg_info);
2886
2887                 /* Free and go on */
2888                 g_object_unref (header);
2889                 g_object_unref (folder);
2890                 g_slice_free (ModestMailOperationState, state);
2891         }
2892         g_object_unref (iter);
2893 }
2894
2895
2896 static void
2897 remove_msgs_async_cb (TnyFolder *folder, 
2898                       gboolean canceled, 
2899                       GError *err, 
2900                       gpointer user_data)
2901 {
2902         gboolean expunge, leave_on_server;
2903         const gchar *account_name;
2904         TnyAccount *account;
2905         ModestProtocolType account_proto = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
2906         ModestMailOperation *self;
2907         ModestMailOperationPrivate *priv;
2908         ModestProtocolRegistry *protocol_registry;
2909
2910         self = (ModestMailOperation *) user_data;
2911         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2912         protocol_registry = modest_runtime_get_protocol_registry ();
2913
2914         if (canceled || err) {
2915                 /* If canceled by the user, ignore the error given by Tinymail */
2916                 if (canceled) {
2917                         priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2918                 } else if (err) {
2919                         priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
2920                         priv->error = g_error_copy ((const GError *) err);
2921                         priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
2922                 }
2923                 /* Exit */
2924                 modest_mail_operation_notify_end (self);
2925                 g_object_unref (self);
2926                 return;
2927         }
2928
2929         account = modest_tny_folder_get_account (folder);
2930         account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
2931         leave_on_server =
2932                 modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
2933                                                         account_name);  
2934         account_proto = modest_tny_account_get_protocol_type (account);
2935         g_object_unref (account);
2936
2937         if ((modest_protocol_registry_protocol_type_has_leave_on_server (protocol_registry, account_proto) && 
2938              !leave_on_server) ||
2939             !modest_tny_folder_is_remote_folder (folder))
2940                 expunge = TRUE;
2941         else
2942                 expunge = FALSE;
2943
2944         /* Sync folder */
2945         tny_folder_sync_async(folder, expunge, sync_folder_finish_callback, 
2946                               NULL, self);
2947 }
2948
2949 void 
2950 modest_mail_operation_remove_msgs (ModestMailOperation *self,  
2951                                    TnyList *headers,
2952                                    gboolean remove_to_trash /*ignored*/)
2953 {
2954         TnyFolder *folder = NULL;
2955         ModestMailOperationPrivate *priv;
2956         TnyIterator *iter = NULL;
2957         TnyHeader *header = NULL;
2958         TnyList *remove_headers = NULL;
2959         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
2960         ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
2961
2962         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2963         g_return_if_fail (TNY_IS_LIST (headers));
2964
2965         if (remove_to_trash)
2966                 g_warning ("remove to trash is not implemented");
2967
2968         if (tny_list_get_length(headers) == 0) {
2969                 g_warning ("%s: list of headers is empty\n", __FUNCTION__);
2970                 goto cleanup; /* nothing to do */
2971         }
2972
2973         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2974
2975         /* Get folder from first header and sync it */
2976         iter = tny_list_create_iterator (headers);
2977         header = TNY_HEADER (tny_iterator_get_current (iter));
2978         g_object_unref (iter);
2979
2980         folder = tny_header_get_folder (header);
2981         if (!TNY_IS_FOLDER(folder)) {
2982                 g_warning ("%s: could not get folder for header\n", __FUNCTION__);
2983                 goto cleanup;
2984         }
2985
2986         /* Use the merged folder if we're removing messages from outbox */
2987         if (modest_tny_folder_is_local_folder (folder)) {
2988                 ModestTnyLocalFoldersAccount *local_account;
2989
2990                 local_account = (ModestTnyLocalFoldersAccount *)
2991                         modest_tny_account_store_get_local_folders_account (accstore);
2992                 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
2993                 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
2994                         g_object_unref (folder);
2995                         folder = modest_tny_local_folders_account_get_merged_outbox (local_account);
2996                 }
2997                 g_object_unref (local_account);
2998         }
2999
3000         if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
3001                 TnyIterator *headers_iter = tny_list_create_iterator (headers);
3002
3003                 while (!tny_iterator_is_done (headers_iter)) {
3004                         TnyTransportAccount *traccount = NULL;
3005                         TnyHeader *hdr = NULL;
3006
3007                         hdr = TNY_HEADER (tny_iterator_get_current (headers_iter));
3008                         traccount = modest_tny_account_store_get_transport_account_from_outbox_header (accstore,
3009                                                                                                        header);
3010                         if (traccount) {
3011                                 ModestTnySendQueueStatus status;
3012                                 ModestTnySendQueue *send_queue;
3013
3014                                 send_queue = modest_runtime_get_send_queue(traccount, TRUE);
3015                                 if (TNY_IS_SEND_QUEUE (send_queue)) {
3016                                         char *msg_id;
3017
3018                                         msg_id = modest_tny_send_queue_get_msg_id (hdr);
3019                                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
3020                                         if (status != MODEST_TNY_SEND_QUEUE_SENDING) {
3021                                                 if (G_UNLIKELY (remove_headers == NULL))
3022                                                         remove_headers = tny_simple_list_new ();
3023                                                 tny_list_append(remove_headers, G_OBJECT(hdr));
3024                                         }
3025                                         g_free(msg_id);
3026                                 }
3027                                 g_object_unref(traccount);
3028                         }
3029                         g_object_unref(hdr);
3030                         tny_iterator_next (headers_iter);
3031                 }
3032                 g_object_unref(headers_iter);
3033         }
3034
3035         /* Get account and set it into mail_operation */
3036         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
3037         priv->op_type = MODEST_MAIL_OPERATION_TYPE_DELETE;
3038         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3039
3040         if (!remove_headers)
3041                 remove_headers = g_object_ref (headers);
3042
3043         /* remove message from folder */
3044         modest_mail_operation_notify_start (self);
3045         tny_folder_remove_msgs_async (folder, remove_headers, remove_msgs_async_cb, 
3046                                       NULL, g_object_ref (self));
3047
3048 cleanup:
3049         if (remove_headers)
3050                 g_object_unref (remove_headers);
3051         if (header)
3052                 g_object_unref (header);
3053         if (folder)
3054                 g_object_unref (folder);
3055 }
3056
3057 static void
3058 notify_progress_of_multiple_messages (ModestMailOperation *self,
3059                                       TnyStatus *status,
3060                                       gint *last_total_bytes,
3061                                       gint *sum_total_bytes,
3062                                       gint total_bytes, 
3063                                       gboolean increment_done)
3064 {
3065         ModestMailOperationPrivate *priv;
3066         ModestMailOperationState *state;
3067         gboolean is_num_bytes = FALSE;
3068
3069         priv =  MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3070
3071         /* We know that tinymail sends us information about
3072          *  transferred bytes with this particular message
3073          */
3074         if (status->message)
3075                 is_num_bytes = (g_ascii_strcasecmp (status->message, "Retrieving message") == 0);
3076
3077         state = modest_mail_operation_clone_state (self);
3078         if (is_num_bytes && !((status->position == 1) && (status->of_total == 100))) {
3079                 /* We know that we're in a different message when the
3080                    total number of bytes to transfer is different. Of
3081                    course it could fail if we're transferring messages
3082                    of the same size, but this is a workarround */
3083                 if (status->of_total != *last_total_bytes) {
3084                         /* We need to increment the done when there is
3085                            no information about each individual
3086                            message, we need to do this in message
3087                            transfers, and we don't do it for getting
3088                            messages */
3089                         if (increment_done)
3090                                 priv->done++;
3091                         *sum_total_bytes += *last_total_bytes;
3092                         *last_total_bytes = status->of_total;
3093                 }
3094                 state->bytes_done += status->position + *sum_total_bytes;
3095                 state->bytes_total = total_bytes;
3096
3097                 /* Notify the status change. Only notify about changes
3098                    referred to bytes */
3099                 g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
3100                                0, state, NULL);
3101         }
3102
3103         g_slice_free (ModestMailOperationState, state);
3104 }
3105
3106 static void
3107 transfer_msgs_status_cb (GObject *obj,
3108                          TnyStatus *status,  
3109                          gpointer user_data)
3110 {
3111         XFerMsgsAsyncHelper *helper;
3112
3113         g_return_if_fail (status != NULL);
3114
3115         /* Show only the status information we want */
3116         if (status->code != TNY_FOLDER_STATUS_CODE_XFER_MSGS)
3117                 return;
3118
3119         helper = (XFerMsgsAsyncHelper *) user_data;
3120         g_return_if_fail (helper != NULL);       
3121
3122         /* Notify progress */
3123         notify_progress_of_multiple_messages (helper->mail_op, status, &(helper->last_total_bytes), 
3124                                               &(helper->sum_total_bytes), helper->total_bytes, TRUE);
3125 }
3126
3127 static void
3128 transfer_msgs_sync_folder_cb (TnyFolder *self, 
3129                               gboolean cancelled, 
3130                               GError *err, 
3131                               gpointer user_data)
3132 {
3133         XFerMsgsAsyncHelper *helper;
3134         /* We don't care here about the results of the
3135            synchronization */
3136         helper = (XFerMsgsAsyncHelper *) user_data;
3137
3138         /* Notify about operation end */
3139         modest_mail_operation_notify_end (helper->mail_op);
3140
3141         /* If user defined callback function was defined, call it */
3142         if (helper->user_callback)
3143                 helper->user_callback (helper->mail_op, helper->user_data);
3144         
3145         /* Free */
3146         if (helper->more_msgs)
3147                 g_object_unref (helper->more_msgs);
3148         if (helper->headers)
3149                 g_object_unref (helper->headers);
3150         if (helper->dest_folder)
3151                 g_object_unref (helper->dest_folder);
3152         if (helper->mail_op)
3153                 g_object_unref (helper->mail_op);
3154         g_slice_free (XFerMsgsAsyncHelper, helper);
3155 }
3156
3157 static void
3158 transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError *err, gpointer user_data)
3159 {
3160         XFerMsgsAsyncHelper *helper;
3161         ModestMailOperation *self;
3162         ModestMailOperationPrivate *priv;
3163         gboolean finished = TRUE;
3164
3165         helper = (XFerMsgsAsyncHelper *) user_data;
3166         self = helper->mail_op;
3167
3168         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3169
3170         if (cancelled) {
3171                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
3172         } else if (err) {
3173                 priv->error = g_error_copy (err);
3174                 priv->done = 0;
3175                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;     
3176         } else if (priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
3177                 if (helper->more_msgs) {
3178                         /* We'll transfer the next message in the list */
3179                         tny_iterator_next (helper->more_msgs);
3180                         if (!tny_iterator_is_done (helper->more_msgs)) {
3181                                 GObject *next_header;
3182                                 g_object_unref (helper->headers);
3183                                 helper->headers = tny_simple_list_new ();
3184                                 next_header = tny_iterator_get_current (helper->more_msgs);
3185                                 tny_list_append (helper->headers, next_header);
3186                                 g_object_unref (next_header);
3187                                 finished = FALSE;
3188                         }
3189                 }
3190                 if (finished) {
3191                         priv->done = 1;
3192                         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3193                 }
3194         }
3195
3196         if (finished) {
3197                 /* Synchronize the source folder contents. This should
3198                    be done by tinymail but the camel_folder_sync it's
3199                    actually disabled in transfer_msgs_thread_clean
3200                    because it's supposed to cause hangs */
3201                 tny_folder_sync_async (folder, helper->delete, 
3202                                        transfer_msgs_sync_folder_cb, 
3203                                        NULL, helper);
3204         } else {
3205                 /* Transfer more messages */
3206                 tny_folder_transfer_msgs_async (folder,
3207                                                 helper->headers,
3208                                                 helper->dest_folder,
3209                                                 helper->delete,
3210                                                 transfer_msgs_cb,
3211                                                 transfer_msgs_status_cb,
3212                                                 helper);
3213         }
3214 }
3215
3216 /* Computes the size of the messages the headers in the list belongs
3217    to. If num_elements is different from 0 then it only takes into
3218    account the first num_elements for the calculation */
3219 static guint
3220 compute_message_list_size (TnyList *headers, 
3221                            guint num_elements)
3222 {
3223         TnyIterator *iter;
3224         guint size = 0, element = 0;
3225
3226         /* If num_elements is not valid then take all into account */
3227         if ((num_elements <= 0) || (num_elements > tny_list_get_length (headers)))
3228                 num_elements = tny_list_get_length (headers);
3229
3230         iter = tny_list_create_iterator (headers);
3231         while (!tny_iterator_is_done (iter) && element < num_elements) {
3232                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
3233                 size += tny_header_get_message_size (header);
3234                 g_object_unref (header);
3235                 tny_iterator_next (iter);
3236                 element++;
3237         }
3238         g_object_unref (iter);
3239
3240         return size;
3241 }
3242
3243 void
3244 modest_mail_operation_xfer_msgs (ModestMailOperation *self,
3245                                  TnyList *headers, 
3246                                  TnyFolder *folder, 
3247                                  gboolean delete_original,
3248                                  XferMsgsAsyncUserCallback user_callback,
3249                                  gpointer user_data)
3250 {
3251         ModestMailOperationPrivate *priv = NULL;
3252         TnyIterator *iter = NULL;
3253         TnyFolder *src_folder = NULL;
3254         XFerMsgsAsyncHelper *helper = NULL;
3255         TnyHeader *header = NULL;
3256         ModestTnyFolderRules rules = 0;
3257         TnyAccount *dst_account = NULL;
3258         gboolean leave_on_server;
3259         ModestMailOperationState *state;
3260         ModestProtocolRegistry *protocol_registry;
3261         ModestProtocolType account_protocol;
3262
3263         g_return_if_fail (self && MODEST_IS_MAIL_OPERATION (self));
3264         g_return_if_fail (headers && TNY_IS_LIST (headers));
3265         g_return_if_fail (folder && TNY_IS_FOLDER (folder));
3266
3267         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3268         protocol_registry = modest_runtime_get_protocol_registry ();
3269
3270         priv->total = tny_list_get_length (headers);
3271         priv->done = 0;
3272         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3273         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
3274
3275         /* Apply folder rules */
3276         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
3277         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
3278                 /* Set status failed and set an error */
3279                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3280                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
3281                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
3282                              _CS("ckct_ib_unable_to_paste_here"));
3283                 /* Notify the queue */
3284                 modest_mail_operation_notify_end (self);
3285                 return;
3286         }
3287                 
3288         /* Get source folder */
3289         iter = tny_list_create_iterator (headers);
3290         header = TNY_HEADER (tny_iterator_get_current (iter));
3291         if (header) {
3292                 src_folder = tny_header_get_folder (header);
3293                 g_object_unref (header);
3294         }
3295         g_object_unref (iter);
3296
3297         if (src_folder == NULL) {
3298                 /* Notify the queue */
3299                 modest_mail_operation_notify_end (self);
3300
3301                 g_warning ("%s: cannot find folder from header", __FUNCTION__);
3302                 return;
3303         }
3304
3305         
3306         /* Check folder source and destination */
3307         if (src_folder == folder) {
3308                 /* Set status failed and set an error */
3309                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3310                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
3311                              MODEST_MAIL_OPERATION_ERROR_BAD_PARAMETER,
3312                              _("mail_in_ui_folder_copy_target_error"));
3313                 
3314                 /* Notify the queue */
3315                 modest_mail_operation_notify_end (self);
3316                 
3317                 /* Free */
3318                 g_object_unref (src_folder);            
3319                 return;
3320         }
3321
3322         /* Create the helper */
3323         helper = g_slice_new0 (XFerMsgsAsyncHelper);
3324         helper->mail_op = g_object_ref(self);
3325         helper->dest_folder = g_object_ref(folder);
3326         helper->user_callback = user_callback;
3327         helper->user_data = user_data;
3328         helper->last_total_bytes = 0;
3329         helper->sum_total_bytes = 0;
3330         helper->total_bytes = compute_message_list_size (headers, 0);
3331
3332         /* Get account and set it into mail_operation */
3333         priv->account = modest_tny_folder_get_account (src_folder);
3334         dst_account = modest_tny_folder_get_account (folder);
3335
3336         if (priv->account == dst_account) {
3337                 /* Transfer all messages at once using the fast
3338                  * method. Note that depending on the server this
3339                  * might not be that fast, and might not be
3340                  * user-cancellable either */
3341                 helper->headers = g_object_ref (headers);
3342                 helper->more_msgs = NULL;
3343         } else {
3344                 /* Transfer messages one by one so the user can cancel
3345                  * the operation */
3346                 GObject *hdr;
3347                 helper->headers = tny_simple_list_new ();
3348                 helper->more_msgs = tny_list_create_iterator (headers);
3349                 hdr = tny_iterator_get_current (helper->more_msgs);
3350                 tny_list_append (helper->headers, hdr);
3351                 g_object_unref (hdr);
3352         }
3353
3354         /* If leave_on_server is set to TRUE then don't use
3355            delete_original, we always pass FALSE. This is because
3356            otherwise tinymail will try to sync the source folder and
3357            this could cause an error if we're offline while
3358            transferring an already downloaded message from a POP
3359            account */
3360         account_protocol = modest_tny_account_get_protocol_type (priv->account);
3361         if (modest_protocol_registry_protocol_type_has_leave_on_server (protocol_registry, account_protocol)) {
3362                 const gchar *account_name;
3363
3364                 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (priv->account);
3365                 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
3366                                                                           account_name);
3367         } else {
3368                 leave_on_server = FALSE;
3369         }
3370
3371         /* Do not delete messages if leave on server is TRUE */
3372         helper->delete = (leave_on_server) ? FALSE : delete_original;
3373
3374         modest_mail_operation_notify_start (self);
3375
3376         /* Start notifying progress */
3377         state = modest_mail_operation_clone_state (self);
3378         state->done = 0;
3379         state->total = 0;
3380         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
3381         g_slice_free (ModestMailOperationState, state);
3382
3383         tny_folder_transfer_msgs_async (src_folder, 
3384                                         helper->headers, 
3385                                         folder, 
3386                                         helper->delete, 
3387                                         transfer_msgs_cb, 
3388                                         transfer_msgs_status_cb,
3389                                         helper);
3390         g_object_unref (src_folder);
3391         g_object_unref (dst_account);
3392 }
3393
3394
3395 static void
3396 on_refresh_folder (TnyFolder   *folder, 
3397                    gboolean     cancelled, 
3398                    GError     *error,
3399                    gpointer     user_data)
3400 {
3401         RefreshAsyncHelper *helper = NULL;
3402         ModestMailOperation *self = NULL;
3403         ModestMailOperationPrivate *priv = NULL;
3404
3405         helper = (RefreshAsyncHelper *) user_data;
3406         self = helper->mail_op;
3407         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3408
3409         g_return_if_fail(priv!=NULL);
3410
3411         if (error) {
3412                 priv->error = g_error_copy (error);
3413                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3414                 goto out;
3415         }
3416
3417         if (cancelled) {
3418                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
3419                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
3420                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
3421                              _("Error trying to refresh the contents of %s"),
3422                              tny_folder_get_name (folder));
3423                 goto out;
3424         }
3425
3426         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3427  out:
3428
3429         /* Call user defined callback, if it exists */
3430         if (helper->user_callback) {
3431
3432                 /* This is not a GDK lock because we are a Tinymail callback and
3433                  * Tinymail already acquires the Gdk lock */
3434                 helper->user_callback (self, folder, helper->user_data);
3435         }
3436
3437         /* Free */
3438         g_slice_free (RefreshAsyncHelper, helper);
3439
3440         /* Notify about operation end */
3441         modest_mail_operation_notify_end (self);
3442         g_object_unref(self);
3443 }
3444
3445 static void
3446 on_refresh_folder_status_update (GObject *obj,
3447                                  TnyStatus *status,
3448                                  gpointer user_data)
3449 {
3450         RefreshAsyncHelper *helper = NULL;
3451         ModestMailOperation *self = NULL;
3452         ModestMailOperationPrivate *priv = NULL;
3453         ModestMailOperationState *state;
3454
3455         g_return_if_fail (user_data != NULL);
3456         g_return_if_fail (status != NULL);
3457
3458         /* Show only the status information we want */
3459         if (status->code != TNY_FOLDER_STATUS_CODE_REFRESH)
3460                 return;
3461
3462         helper = (RefreshAsyncHelper *) user_data;
3463         self = helper->mail_op;
3464         g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
3465
3466         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3467
3468         priv->done = status->position;
3469         priv->total = status->of_total;
3470
3471         state = modest_mail_operation_clone_state (self);
3472
3473         /* This is not a GDK lock because we are a Tinymail callback and
3474          * Tinymail already acquires the Gdk lock */
3475         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
3476
3477         g_slice_free (ModestMailOperationState, state);
3478 }
3479
3480 void 
3481 modest_mail_operation_refresh_folder  (ModestMailOperation *self,
3482                                        TnyFolder *folder,
3483                                        RefreshAsyncUserCallback user_callback,
3484                                        gpointer user_data)
3485 {
3486         ModestMailOperationPrivate *priv = NULL;
3487         RefreshAsyncHelper *helper = NULL;
3488
3489         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3490
3491         /* Check memory low */
3492         if (_check_memory_low (self)) {
3493                 if (user_callback)
3494                         user_callback (self, folder, user_data);
3495                 /* Notify about operation end */
3496                 modest_mail_operation_notify_end (self);
3497                 return;
3498         }
3499
3500         /* Get account and set it into mail_operation */
3501         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3502         priv->account = modest_tny_folder_get_account  (folder);
3503         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
3504
3505         /* Create the helper */
3506         helper = g_slice_new0 (RefreshAsyncHelper);
3507         helper->mail_op = g_object_ref(self);
3508         helper->user_callback = user_callback;
3509         helper->user_data = user_data;
3510
3511         modest_mail_operation_notify_start (self);
3512         
3513         /* notify that the operation was started */
3514         ModestMailOperationState *state;
3515         state = modest_mail_operation_clone_state (self);
3516         state->done = 0;
3517         state->total = 0;
3518         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 
3519                         0, state, NULL);
3520         g_slice_free (ModestMailOperationState, state);
3521         
3522         tny_folder_refresh_async (folder,
3523                                   on_refresh_folder,
3524                                   on_refresh_folder_status_update,
3525                                   helper);
3526 }
3527
3528 static void
3529 run_queue_notify_and_destroy (RunQueueHelper *helper,
3530                               ModestMailOperationStatus status)
3531 {
3532         ModestMailOperationPrivate *priv;
3533
3534         /* Disconnect */
3535         if (helper->error_handler &&
3536             g_signal_handler_is_connected (helper->queue, helper->error_handler))
3537                 g_signal_handler_disconnect (helper->queue, helper->error_handler);
3538         if (helper->start_handler &&
3539             g_signal_handler_is_connected (helper->queue, helper->start_handler))
3540                 g_signal_handler_disconnect (helper->queue, helper->start_handler);
3541         if (helper->stop_handler &&
3542             g_signal_handler_is_connected (helper->queue, helper->stop_handler))
3543                 g_signal_handler_disconnect (helper->queue, helper->stop_handler);
3544
3545         /* Set status */
3546         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (helper->self);
3547         priv->status = status;
3548
3549         /* Notify end */
3550         modest_mail_operation_notify_end (helper->self);
3551
3552         /* Free data */
3553         g_object_unref (helper->queue);
3554         g_object_unref (helper->self);
3555         g_slice_free (RunQueueHelper, helper);
3556 }
3557
3558 static void
3559 run_queue_stop (ModestTnySendQueue *queue,
3560                 gpointer user_data)
3561 {
3562         RunQueueHelper *helper;
3563
3564         g_debug ("%s sending queue stopped", __FUNCTION__);
3565
3566         helper = (RunQueueHelper *) user_data;
3567         run_queue_notify_and_destroy (helper, MODEST_MAIL_OPERATION_STATUS_SUCCESS);
3568 }
3569
3570 void
3571 modest_mail_operation_run_queue (ModestMailOperation *self,
3572                                  ModestTnySendQueue *queue)
3573 {
3574         ModestMailOperationPrivate *priv;
3575         RunQueueHelper *helper;
3576
3577         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3578         g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (queue));
3579         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3580
3581         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3582         priv->account = TNY_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (queue)));
3583         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RUN_QUEUE;
3584
3585         /* Create the helper */
3586         helper = g_slice_new0 (RunQueueHelper);
3587         helper->queue = g_object_ref (queue);
3588         helper->self = g_object_ref (self);
3589         helper->stop_handler = g_signal_connect (queue, "queue-stop", 
3590                                                  G_CALLBACK (run_queue_stop), 
3591                                                  helper);
3592
3593         /* Notify operation has started */
3594         modest_mail_operation_notify_start (self);
3595         g_debug ("%s, run queue started", __FUNCTION__);
3596 }
3597
3598 static void
3599 queue_wakeup_callback (ModestTnySendQueue *queue,
3600                        gboolean cancelled,
3601                        GError *error,
3602                        gpointer userdata)
3603 {
3604         ModestMailOperation *mail_op;
3605         ModestMailOperationPrivate *priv;
3606
3607         mail_op = (ModestMailOperation *) userdata;
3608         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
3609
3610         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3611         tny_camel_send_queue_flush (TNY_CAMEL_SEND_QUEUE (queue));
3612
3613         /* Notify end */
3614         modest_mail_operation_notify_end (mail_op);
3615         g_object_unref (mail_op);
3616 }
3617
3618 void
3619 modest_mail_operation_queue_wakeup (ModestMailOperation *self,
3620                                     ModestTnySendQueue *queue)
3621 {
3622         ModestMailOperationPrivate *priv;
3623
3624         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3625         g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (queue));
3626         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3627
3628         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3629         priv->account = TNY_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (queue)));
3630         priv->op_type = MODEST_MAIL_OPERATION_TYPE_QUEUE_WAKEUP;
3631
3632         g_object_ref (self);
3633
3634         modest_tny_send_queue_wakeup (queue, queue_wakeup_callback, self);
3635         modest_mail_operation_notify_start (self);
3636 }
3637
3638 static void
3639 shutdown_callback (ModestTnyAccountStore *account_store, gpointer userdata)
3640 {
3641         ModestMailOperation *self = (ModestMailOperation *) userdata;
3642         ModestMailOperationPrivate *priv;
3643
3644         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3645         g_return_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (account_store));
3646         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3647
3648         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3649
3650         modest_mail_operation_notify_end (self);
3651         g_object_unref (self);
3652 }
3653
3654 void
3655 modest_mail_operation_shutdown (ModestMailOperation *self, ModestTnyAccountStore *account_store)
3656 {
3657         ModestMailOperationPrivate *priv;
3658
3659         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3660         g_return_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (account_store));
3661         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3662
3663         modest_mail_operation_queue_set_running_shutdown (modest_runtime_get_mail_operation_queue ());
3664
3665         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3666         priv->account = NULL;
3667         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SHUTDOWN;
3668
3669         modest_mail_operation_notify_start (self);
3670         g_object_ref (self);
3671         modest_tny_account_store_shutdown (account_store, shutdown_callback, self);
3672 }
3673
3674 static void
3675 sync_folder_finish_callback (TnyFolder *self, 
3676                              gboolean cancelled, 
3677                              GError *err, 
3678                              gpointer user_data)
3679
3680 {
3681         ModestMailOperation *mail_op;
3682         ModestMailOperationPrivate *priv;
3683
3684         mail_op = (ModestMailOperation *) user_data;
3685         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
3686
3687         /* If canceled by the user, ignore the error given by Tinymail */
3688         if (cancelled) {
3689                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
3690         } else if (err) {
3691                 /* If the operation was a sync then the status is
3692                    failed, but if it's part of another operation then
3693                    just set it as finished with errors */
3694                 if (priv->op_type == MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER)
3695                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3696                 else
3697                         priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
3698                 priv->error = g_error_copy ((const GError *) err);
3699                 priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
3700         } else {
3701                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3702         }
3703
3704         modest_mail_operation_notify_end (mail_op);
3705         g_object_unref (mail_op);
3706 }
3707
3708 void
3709 modest_mail_operation_sync_folder (ModestMailOperation *self,
3710                                    TnyFolder *folder, gboolean expunge)
3711 {
3712         ModestMailOperationPrivate *priv;
3713
3714         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3715         g_return_if_fail (TNY_IS_FOLDER (folder));
3716         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3717
3718         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3719         priv->account = modest_tny_folder_get_account (folder);
3720         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER;
3721
3722         modest_mail_operation_notify_start (self);
3723         g_object_ref (self);
3724         tny_folder_sync_async (folder, expunge, 
3725                                (TnyFolderCallback) sync_folder_finish_callback, 
3726                                NULL, self);
3727 }
3728
3729 static void
3730 modest_mail_operation_notify_start (ModestMailOperation *self)
3731 {
3732         ModestMailOperationPrivate *priv = NULL;
3733
3734         g_return_if_fail (self);
3735
3736         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3737
3738         /* Ensure that all the fields are filled correctly */
3739         g_return_if_fail (priv->op_type != MODEST_MAIL_OPERATION_TYPE_UNKNOWN);
3740
3741         /* Notify the observers about the mail operation. We do not
3742            wrapp this emission because we assume that this function is
3743            always called from within the main lock */
3744         g_signal_emit (G_OBJECT (self), signals[OPERATION_STARTED_SIGNAL], 0, NULL);
3745 }
3746
3747 /**
3748  *
3749  * It's used by the mail operation queue to notify the observers
3750  * attached to that signal that the operation finished. We need to use
3751  * that because tinymail does not give us the progress of a given
3752  * operation when it finishes (it directly calls the operation
3753  * callback).
3754  */
3755 static void
3756 modest_mail_operation_notify_end (ModestMailOperation *self)
3757 {
3758         ModestMailOperationPrivate *priv = NULL;
3759
3760         g_return_if_fail (self);
3761
3762         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3763
3764         /* Notify the observers about the mail operation end. We do
3765            not wrapp this emission because we assume that this
3766            function is always called from within the main lock */
3767         g_signal_emit (G_OBJECT (self), signals[OPERATION_FINISHED_SIGNAL], 0, NULL);
3768
3769         /* Remove the error user data */
3770         if (priv->error_checking_user_data && priv->error_checking_user_data_destroyer)
3771                 priv->error_checking_user_data_destroyer (priv->error_checking_user_data);
3772 }
3773
3774 TnyAccount *
3775 modest_mail_operation_get_account (ModestMailOperation *self)