git.maemo.org Git - modest/blob - 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                         g_object_unref (header);
1769
1770                         msg_num++;
1771                         tny_iterator_next (iter);
1772                 }
1773                 g_object_unref (iter);
1774                 g_object_unref (new_headers);
1775
1776                 /* The mail operation will finish when the last
1777                    message is retrieved */
1778                 return;
1779         }
1780  send_mail:
1781         /* If we don't have to retrieve the new messages then
1782            simply send mail */
1783         update_account_send_mail (info);
1784
1785         /* Check if the operation was a success */
1786         if (!priv->error)
1787                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1788
1789         /* Call the user callback and free */
1790         update_account_notify_user_and_free (info, new_headers);
1791 }
1792
1793 static void
1794 inbox_refresh_status_update (GObject *obj,
1795                              TnyStatus *status,
1796                              gpointer user_data)
1797 {
1798         UpdateAccountInfo *info = NULL;
1799         ModestMailOperation *self = NULL;
1800         ModestMailOperationPrivate *priv = NULL;
1801         ModestMailOperationState *state;
1802
1803         g_return_if_fail (user_data != NULL);
1804         g_return_if_fail (status != NULL);
1805
1806         /* Show only the status information we want */
1807         if (status->code != TNY_FOLDER_STATUS_CODE_REFRESH)
1808                 return;
1809
1810         info = (UpdateAccountInfo *) user_data;
1811         self = info->mail_op;
1812         g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
1813
1814         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1815
1816         priv->done = status->position;
1817         priv->total = status->of_total;
1818
1819         state = modest_mail_operation_clone_state (self);
1820
1821         /* This is not a GDK lock because we are a Tinymail callback and
1822          * Tinymail already acquires the Gdk lock */
1823         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
1824
1825         g_slice_free (ModestMailOperationState, state);
1826 }
1827
1828 static void
1829 recurse_folders_async_cb (TnyFolderStore *folder_store,
1830                           gboolean canceled,
1831                           TnyList *list,
1832                           GError *err,
1833                           gpointer user_data)
1834 {
1835         UpdateAccountInfo *info;
1836         ModestMailOperationPrivate *priv;
1837
1838         info = (UpdateAccountInfo *) user_data;
1839         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
1840
1841         if (err || canceled) {
1842                 /* If the error was previosly set by another callback
1843                    don't set it again */
1844                 if (!priv->error) {
1845                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1846                         if (err)
1847                                 priv->error = g_error_copy (err);
1848                         else
1849                                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1850                                              MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
1851                                              "canceled");
1852                 }
1853         } else {
1854                 /* We're not getting INBOX children if we don't want to poke all */
1855                 TnyIterator *iter = tny_list_create_iterator (list);
1856                 while (!tny_iterator_is_done (iter)) {
1857                         TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter);
1858
1859                         /* Add to the list of all folders */
1860                         tny_list_append (info->folders, (GObject *) folder);
1861
1862                         if (info->poke_all) {
1863                                 TnyList *folders = tny_simple_list_new ();
1864                                 /* Add pending call */
1865                                 info->pending_calls++;
1866
1867                                 tny_folder_store_get_folders_async (folder, folders, NULL, FALSE,
1868                                                                     recurse_folders_async_cb,
1869                                                                     NULL, info);
1870                                 g_object_unref (folders);
1871                         }
1872
1873                         g_object_unref (G_OBJECT (folder));
1874
1875                         tny_iterator_next (iter);
1876                 }
1877                 g_object_unref (G_OBJECT (iter));
1878         }
1879
1880         /* Remove my own pending call */
1881         info->pending_calls--;
1882
1883         /* This means that we have all the folders */
1884         if (info->pending_calls == 0) {
1885                 TnyIterator *iter_all_folders;
1886                 TnyFolder *inbox = NULL;
1887
1888                 /* If there was any error do not continue */
1889                 if (priv->error) {
1890                         update_account_notify_user_and_free (info, NULL);
1891                         return;
1892                 }
1893
1894                 iter_all_folders = tny_list_create_iterator (info->folders);
1895
1896                 /* Do a poke status over all folders */
1897                 while (!tny_iterator_is_done (iter_all_folders) &&
1898                        priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
1899                         TnyFolder *folder = NULL;
1900
1901                         folder = TNY_FOLDER (tny_iterator_get_current (iter_all_folders));
1902
1903                         if (tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_INBOX) {
1904                                 /* Get a reference to the INBOX */
1905                                 inbox = g_object_ref (folder);
1906                         } else {
1907                                 /* Issue a poke status over the folder */
1908                                 if (info->poke_all)
1909                                         tny_folder_poke_status (folder);
1910                         }
1911
1912                         /* Free and go to next */
1913                         g_object_unref (folder);
1914                         tny_iterator_next (iter_all_folders);
1915                 }
1916                 g_object_unref (iter_all_folders);
1917
1918                 /* Refresh the INBOX */
1919                 if (inbox) {
1920                         /* Refresh the folder. Our observer receives
1921                          * the new emails during folder refreshes, so
1922                          * we can use observer->new_headers
1923                          */
1924                         info->inbox_observer = g_object_new (internal_folder_observer_get_type (), NULL);
1925                         tny_folder_add_observer (inbox, info->inbox_observer);
1926
1927                         /* Refresh the INBOX */
1928                         tny_folder_refresh_async (inbox, inbox_refreshed_cb, inbox_refresh_status_update, info);
1929                         g_object_unref (inbox);
1930                 } else {
1931                         /* We could not perform the inbox refresh but
1932                            we'll try to send mails anyway */
1933                         inbox_refreshed_cb (inbox, FALSE, NULL, info);
1934                 }
1935         }
1936 }
1937
1938 void
1939 modest_mail_operation_update_account (ModestMailOperation *self,
1940                                       const gchar *account_name,
1941                                       gboolean poke_all,
1942                                       gboolean interactive,
1943                                       UpdateAccountCallback callback,
1944                                       gpointer user_data)
1945 {
1946         UpdateAccountInfo *info = NULL;
1947         ModestMailOperationPrivate *priv = NULL;
1948         ModestTnyAccountStore *account_store = NULL;
1949         TnyList *folders;
1950         ModestMailOperationState *state;
1951
1952         /* Init mail operation */
1953         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1954         priv->total = 0;
1955         priv->done  = 0;
1956         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
1957         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND_AND_RECEIVE;
1958
1959         /* Get the store account */
1960         account_store = modest_runtime_get_account_store ();
1961         priv->account =
1962                 modest_tny_account_store_get_server_account (account_store,
1963                                                              account_name,
1964                                                              TNY_ACCOUNT_TYPE_STORE);
1965
1966         /* The above function could return NULL */
1967         if (!priv->account) {
1968                 /* Check if the operation was a success */
1969                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1970                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1971                              "no account");
1972                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1973
1974                 /* Call the user callback */
1975                 if (callback)
1976                         callback (self, NULL, user_data);
1977
1978                 /* Notify about operation end */
1979                 modest_mail_operation_notify_end (self);
1980
1981                 return;
1982         }
1983
1984         /* We have once seen priv->account getting finalized during this code,
1985          * therefore adding a reference (bug #82296) */
1986
1987         g_object_ref (priv->account);
1988
1989         /* Create the helper object */
1990         info = g_slice_new0 (UpdateAccountInfo);
1991         info->pending_calls = 1;
1992         info->folders = tny_simple_list_new ();
1993         info->mail_op = g_object_ref (self);
1994         info->poke_all = poke_all;
1995         info->interactive = interactive;
1996         info->account_name = g_strdup (account_name);
1997         info->callback = callback;
1998         info->user_data = user_data;
1999
2000         /* Set account busy */
2001         modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), account_name, TRUE);
2002         modest_mail_operation_notify_start (self);
2003
2004         /* notify about the start of the operation */
2005         state = modest_mail_operation_clone_state (self);
2006         state->done = 0;
2007         state->total = 0;
2008
2009         /* Start notifying progress */
2010         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
2011         g_slice_free (ModestMailOperationState, state);
2012
2013         /* Get all folders and continue in the callback */
2014         folders = tny_simple_list_new ();
2015         tny_folder_store_get_folders_async (TNY_FOLDER_STORE (priv->account),
2016                                             folders, NULL, FALSE,
2017                                             recurse_folders_async_cb,
2018                                             NULL, info);
2019         g_object_unref (folders);
2020
2021         g_object_unref (priv->account);
2022
2023 }
2024
2025 /*
2026  * Used to notify the queue from the main
2027  * loop. We call it inside an idle call to achieve that
2028  */
2029 static gboolean
2030 idle_notify_queue (gpointer data)
2031 {
2032         ModestMailOperation *mail_op = MODEST_MAIL_OPERATION (data);
2033
2034         gdk_threads_enter ();
2035         modest_mail_operation_notify_end (mail_op);
2036         gdk_threads_leave ();
2037         g_object_unref (mail_op);
2038
2039         return FALSE;
2040 }
2041
2042 static int
2043 compare_headers_by_date (gconstpointer a,
2044                          gconstpointer b)
2045 {
2046         TnyHeader **header1, **header2;
2047         time_t sent1, sent2;
2048
2049         header1 = (TnyHeader **) a;
2050         header2 = (TnyHeader **) b;
2051
2052         sent1 = tny_header_get_date_sent (*header1);
2053         sent2 = tny_header_get_date_sent (*header2);
2054
2055         /* We want the most recent ones (greater time_t) at the
2056            beginning */
2057         if (sent1 < sent2)
2058                 return -1;
2059         else
2060                 return 1;
2061 }
2062
2063
2064 /* ******************************************************************* */
2065 /* ************************** STORE  ACTIONS ************************* */
2066 /* ******************************************************************* */
2067
2068 typedef struct {
2069         ModestMailOperation *mail_op;
2070         CreateFolderUserCallback callback;
2071         gpointer user_data;
2072 } CreateFolderInfo;
2073
2074
2075 static void
2076 create_folder_cb (TnyFolderStore *parent_folder,
2077                   gboolean canceled,
2078                   TnyFolder *new_folder,
2079                   GError *err,
2080                   gpointer user_data)
2081 {
2082         ModestMailOperationPrivate *priv;
2083         CreateFolderInfo *info;
2084
2085         info = (CreateFolderInfo *) user_data;
2086         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
2087
2088         if (canceled || err) {
2089                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2090                 if (err)
2091                         priv->error = g_error_copy (err);
2092                 else
2093                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2094                                      MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
2095                                      "canceled");
2096         } else {
2097                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2098         }
2099
2100         /* The user will unref the new_folder */
2101         if (info->callback)
2102                 info->callback (info->mail_op, parent_folder,
2103                                 new_folder, info->user_data);
2104
2105         /* Notify about operation end */
2106         modest_mail_operation_notify_end (info->mail_op);
2107
2108         /* Frees */
2109         g_object_unref (info->mail_op);
2110         g_slice_free (CreateFolderInfo, info);
2111 }
2112
2113 void
2114 modest_mail_operation_create_folder (ModestMailOperation *self,
2115                                      TnyFolderStore *parent,
2116                                      const gchar *name,
2117                                      CreateFolderUserCallback callback,
2118                                      gpointer user_data)
2119 {
2120         ModestMailOperationPrivate *priv;
2121
2122         g_return_if_fail (TNY_IS_FOLDER_STORE (parent));
2123         g_return_if_fail (name);
2124
2125         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2126         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
2127         priv->account = (TNY_IS_ACCOUNT (parent)) ?
2128                 g_object_ref (parent) :
2129                 modest_tny_folder_get_account (TNY_FOLDER (parent));
2130
2131         /* Check for already existing folder */
2132         if (modest_tny_folder_has_subfolder_with_name (parent, name, TRUE)) {
2133                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2134                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2135                              MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
2136                              _CS("ckdg_ib_folder_already_exists"));
2137         }
2138
2139         /* Check parent */
2140         if (TNY_IS_FOLDER (parent)) {
2141                 /* Check folder rules */
2142                 ModestTnyFolderRules rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
2143                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
2144                         /* Set status failed and set an error */
2145                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2146                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2147                                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2148                                      _("mail_in_ui_folder_create_error"));
2149                 }
2150         }
2151
2152         if (!priv->error && (!strcmp (name, " ") || strchr (name, '/'))) {
2153                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2154                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2155                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2156                              _("mail_in_ui_folder_create_error"));
2157         }
2158
2159         if (!priv->error) {
2160                 CreateFolderInfo *info;
2161
2162                 info = g_slice_new0 (CreateFolderInfo);
2163                 info->mail_op = g_object_ref (self);
2164                 info->callback = callback;
2165                 info->user_data = user_data;
2166
2167                 modest_mail_operation_notify_start (self);
2168
2169                 /* Create the folder */
2170                 tny_folder_store_create_folder_async (parent, name, create_folder_cb,
2171                                                       NULL, info);
2172         } else {
2173                 /* Call the user callback anyway */
2174                 if (callback)
2175                         callback (self, parent, NULL, user_data);
2176                 /* Notify about operation end */
2177                 modest_mail_operation_notify_end (self);
2178         }
2179 }
2180
2181 void
2182 modest_mail_operation_remove_folder (ModestMailOperation *self,
2183                                      TnyFolder           *folder,
2184                                      gboolean             remove_to_trash)
2185 {
2186         ModestMailOperationPrivate *priv;
2187         ModestTnyFolderRules rules;
2188
2189         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2190         g_return_if_fail (TNY_IS_FOLDER (folder));
2191
2192         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2193
2194         /* Check folder rules */
2195         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2196         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_DELETABLE) {
2197                 /* Set status failed and set an error */
2198                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2199                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2200                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2201                              _("mail_in_ui_folder_delete_error"));
2202                 goto end;
2203         }
2204
2205         /* Get the account */
2206         priv->account = modest_tny_folder_get_account (folder);
2207         priv->op_type = MODEST_MAIL_OPERATION_TYPE_DELETE;
2208
2209         /* Delete folder or move to trash */
2210         if (remove_to_trash) {
2211                 TnyFolder *trash_folder = NULL;
2212                 trash_folder = modest_tny_account_get_special_folder (priv->account,
2213                                                                       TNY_FOLDER_TYPE_TRASH);
2214                 /* TODO: error_handling */
2215                 if (trash_folder) {
2216                         modest_mail_operation_notify_start (self);
2217                         modest_mail_operation_xfer_folder (self, folder,
2218                                                     TNY_FOLDER_STORE (trash_folder),
2219                                                     TRUE, NULL, NULL);
2220                         g_object_unref (trash_folder);
2221                 } else {
2222                         g_warning ("%s: modest_tny_account_get_special_folder(..) returned a NULL trash folder", __FUNCTION__);
2223                 }
2224         } else {
2225                 TnyFolderStore *parent = tny_folder_get_folder_store (folder);
2226                 if (parent) {
2227                         modest_mail_operation_notify_start (self);
2228                         tny_folder_store_remove_folder (parent, folder, &(priv->error));
2229                         CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
2230
2231                         if (!priv->error)
2232                                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2233
2234                         g_object_unref (parent);
2235                 } else
2236                         g_warning ("%s: could not get parent folder", __FUNCTION__);
2237         }
2238
2239  end:
2240         /* Notify about operation end */
2241         modest_mail_operation_notify_end (self);
2242 }
2243
2244 static void
2245 transfer_folder_status_cb (GObject *obj,
2246                            TnyStatus *status,
2247                            gpointer user_data)
2248 {
2249         ModestMailOperation *self;
2250         ModestMailOperationPrivate *priv;
2251         ModestMailOperationState *state;
2252         XFerFolderAsyncHelper *helper;
2253
2254         g_return_if_fail (status != NULL);
2255
2256         /* Show only the status information we want */
2257         if (status->code != TNY_FOLDER_STATUS_CODE_COPY_FOLDER)
2258                 return;
2259
2260         helper = (XFerFolderAsyncHelper *) user_data;
2261         g_return_if_fail (helper != NULL);
2262
2263         self = helper->mail_op;
2264         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
2265
2266         priv->done = status->position;
2267         priv->total = status->of_total;
2268
2269         state = modest_mail_operation_clone_state (self);
2270
2271         /* This is not a GDK lock because we are a Tinymail callback
2272          * which is already GDK locked by Tinymail */
2273
2274         /* no gdk_threads_enter (), CHECKED */
2275
2276         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
2277
2278         /* no gdk_threads_leave (), CHECKED */
2279
2280         g_slice_free (ModestMailOperationState, state);
2281 }
2282
2283 static void
2284 transfer_folder_cb (TnyFolder *folder,
2285                     gboolean cancelled,
2286                     TnyFolderStore *into,
2287                     TnyFolder *new_folder,
2288                     GError *err,
2289                     gpointer user_data)
2290 {
2291         XFerFolderAsyncHelper *helper;
2292         ModestMailOperation *self = NULL;
2293         ModestMailOperationPrivate *priv = NULL;
2294
2295         helper = (XFerFolderAsyncHelper *) user_data;
2296         g_return_if_fail (helper != NULL);
2297
2298         self = helper->mail_op;
2299         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
2300
2301         if (err) {
2302                 priv->error = g_error_copy (err);
2303                 priv->done = 0;
2304                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2305         } else if (cancelled) {
2306                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2307                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2308                              MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
2309                              _("Transference of %s was cancelled."),
2310                              tny_folder_get_name (folder));
2311         } else {
2312                 priv->done = 1;
2313                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2314         }
2315
2316         /* Update state of new folder */
2317         if (new_folder) {
2318                 tny_folder_refresh_async (new_folder, NULL, NULL, NULL);
2319                 tny_folder_poke_status (new_folder);
2320         }
2321
2322         /* Notify about operation end */
2323         modest_mail_operation_notify_end (self);
2324
2325         /* If user defined callback function was defined, call it */
2326         if (helper->user_callback) {
2327
2328                 /* This is not a GDK lock because we are a Tinymail callback
2329                  * which is already GDK locked by Tinymail */
2330
2331                 /* no gdk_threads_enter (), CHECKED */
2332                 helper->user_callback (self, new_folder, helper->user_data);
2333                 /* no gdk_threads_leave () , CHECKED */
2334         }
2335
2336         /* Free */
2337         g_object_unref (helper->mail_op);
2338         g_slice_free   (XFerFolderAsyncHelper, helper);
2339 }
2340
2341 /**
2342  *
2343  * This function checks if the new name is a valid name for our local
2344  * folders account. The new name could not be the same than then name
2345  * of any of the mandatory local folders
2346  *
2347  * We can not rely on tinymail because tinymail does not check the
2348  * name of the virtual folders that the account could have in the case
2349  * that we're doing a rename (because it directly calls Camel which
2350  * knows nothing about our virtual folders).
2351  *
2352  * In the case of an actual copy/move (i.e. move/copy a folder between
2353  * accounts) tinymail uses the tny_folder_store_create_account which
2354  * is reimplemented by our ModestTnyLocalFoldersAccount that indeed
2355  * checks the new name of the folder, so this call in that case
2356  * wouldn't be needed. *But* NOTE that if tinymail changes its
2357  * implementation (if folder transfers within the same account is no
2358  * longer implemented as a rename) this call will allow Modest to work
2359  * perfectly
2360  *
2361  * If the new name is not valid, this function will set the status to
2362  * failed and will set also an error in the mail operation
2363  */
2364 static gboolean
2365 new_name_valid_if_local_account (ModestMailOperationPrivate *priv,
2366                                  TnyFolderStore *into,
2367                                  const gchar *new_name)
2368 {
2369         if (TNY_IS_ACCOUNT (into) &&
2370             modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (into)) &&
2371             modest_tny_local_folders_account_folder_name_in_use (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (into),
2372                                                                  new_name)) {
2373                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2374                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2375                              MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
2376                              _CS("ckdg_ib_folder_already_exists"));
2377                 return FALSE;
2378         } else
2379                 return TRUE;
2380 }
2381
2382 void
2383 modest_mail_operation_xfer_folder (ModestMailOperation *self,
2384                                    TnyFolder *folder,
2385                                    TnyFolderStore *parent,
2386                                    gboolean delete_original,
2387                                    XferFolderAsyncUserCallback user_callback,
2388                                    gpointer user_data)
2389 {
2390         ModestMailOperationPrivate *priv = NULL;
2391         ModestTnyFolderRules parent_rules = 0, rules;
2392         XFerFolderAsyncHelper *helper = NULL;
2393         const gchar *folder_name = NULL;
2394         const gchar *error_msg;
2395
2396         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2397         g_return_if_fail (TNY_IS_FOLDER (folder));
2398         g_return_if_fail (TNY_IS_FOLDER_STORE (parent));
2399
2400         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2401         folder_name = tny_folder_get_name (folder);
2402
2403         /* Set the error msg */
2404         error_msg = _("mail_in_ui_folder_move_target_error");
2405
2406         /* Get account and set it into mail_operation */
2407         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2408         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2409         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2410
2411         /* Get folder rules */
2412         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2413         if (TNY_IS_FOLDER (parent))
2414                 parent_rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
2415
2416         /* Apply operation constraints */
2417         if ((gpointer) parent == (gpointer) folder ||
2418             (!TNY_IS_FOLDER_STORE (parent)) ||
2419             (rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE)) {
2420                 /* Folder rules */
2421                 goto error;
2422         } else if (TNY_IS_FOLDER (parent) &&
2423                    (parent_rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE)) {
2424                 /* Folder rules */
2425                 goto error;
2426
2427         } else if (TNY_IS_FOLDER (parent) &&
2428                    TNY_IS_FOLDER_STORE (folder) &&
2429                    modest_tny_folder_is_ancestor (TNY_FOLDER (parent),
2430                                                   TNY_FOLDER_STORE (folder))) {
2431                 /* Do not move a parent into a child */
2432                 goto error;
2433         } else if (TNY_IS_FOLDER_STORE (parent) &&
2434                    modest_tny_folder_has_subfolder_with_name (parent, folder_name, TRUE)) {
2435                 /* Check that the new folder name is not used by any
2436                    parent subfolder */
2437                 goto error;
2438         } else if (!(new_name_valid_if_local_account (priv, parent, folder_name))) {
2439                 /* Check that the new folder name is not used by any
2440                    special local folder */
2441                 goto error;
2442         } else {
2443                 /* Create the helper */
2444                 helper = g_slice_new0 (XFerFolderAsyncHelper);
2445                 helper->mail_op = g_object_ref (self);
2446                 helper->user_callback = user_callback;
2447                 helper->user_data = user_data;
2448
2449                 /* Move/Copy folder */
2450                 modest_mail_operation_notify_start (self);
2451                 tny_folder_copy_async (folder,
2452                                        parent,
2453                                        tny_folder_get_name (folder),
2454                                        delete_original,
2455                                        transfer_folder_cb,
2456                                        transfer_folder_status_cb,
2457                                        helper);
2458                 return;
2459         }
2460
2461  error:
2462         /* Set status failed and set an error */
2463         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2464         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2465                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2466                      error_msg);
2467
2468         /* Call the user callback if exists */
2469         if (user_callback)
2470                 user_callback (self, NULL, user_data);
2471
2472         /* Notify the queue */
2473         modest_mail_operation_notify_end (self);
2474 }
2475
2476 void
2477 modest_mail_operation_rename_folder (ModestMailOperation *self,
2478                                      TnyFolder *folder,
2479                                      const gchar *name,
2480                                      XferFolderAsyncUserCallback user_callback,
2481                                      gpointer user_data)
2482 {
2483         ModestMailOperationPrivate *priv;
2484         ModestTnyFolderRules rules;
2485         XFerFolderAsyncHelper *helper;
2486
2487         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2488         g_return_if_fail (TNY_IS_FOLDER_STORE (folder));
2489         g_return_if_fail (name);
2490
2491         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2492
2493         /* Get account and set it into mail_operation */
2494         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2495         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
2496
2497         /* Check folder rules */
2498         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
2499         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_RENAMEABLE) {
2500                 goto error;
2501         } else if (!strcmp (name, " ") || strchr (name, '/')) {
2502                 goto error;
2503         } else {
2504                 TnyFolderStore *into;
2505
2506                 into = tny_folder_get_folder_store (folder);
2507
2508                 /* Check that the new folder name is not used by any
2509                    special local folder */
2510                 if (new_name_valid_if_local_account (priv, into, name)) {
2511                         /* Create the helper */
2512                         helper = g_slice_new0 (XFerFolderAsyncHelper);
2513                         helper->mail_op = g_object_ref(self);
2514                         helper->user_callback = user_callback;
2515                         helper->user_data = user_data;
2516
2517                         /* Rename. Camel handles folder subscription/unsubscription */
2518                         modest_mail_operation_notify_start (self);
2519                         tny_folder_copy_async (folder, into, name, TRUE,
2520                                                transfer_folder_cb,
2521                                                transfer_folder_status_cb,
2522                                                helper);
2523                         g_object_unref (into);
2524                 } else {
2525                         g_object_unref (into);
2526                         goto error;
2527                 }
2528
2529                 return;
2530         }
2531  error:
2532         /* Set status failed and set an error */
2533         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
2534         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2535                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
2536                      _("FIXME: unable to rename"));
2537
2538         if (user_callback)
2539                 user_callback (self, NULL, user_data);
2540
2541         /* Notify about operation end */
2542         modest_mail_operation_notify_end (self);
2543 }
2544
2545 /* ******************************************************************* */
2546 /* **************************  MSG  ACTIONS  ************************* */
2547 /* ******************************************************************* */
2548
2549 void
2550 modest_mail_operation_find_msg (ModestMailOperation *self,
2551                                 TnyFolder *folder,
2552                                 const gchar *msg_uid,
2553                                 gboolean progress_feedback,
2554                                 GetMsgAsyncUserCallback user_callback,
2555                                 gpointer user_data)
2556 {
2557         GetMsgInfo *helper = NULL;
2558         ModestMailOperationPrivate *priv;
2559
2560         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2561         g_return_if_fail (msg_uid != NULL);
2562
2563         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2564         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2565         priv->total = 1;
2566         priv->done = 0;
2567
2568         /* Check memory low */
2569         if (_check_memory_low (self)) {
2570                 if (user_callback)
2571                         user_callback (self, NULL, FALSE, NULL, priv->error, user_data);
2572                 modest_mail_operation_notify_end (self);
2573                 return;
2574         }
2575
2576         /* Get account and set it into mail_operation */
2577         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2578
2579         /* Check for cached messages */
2580         if (progress_feedback) {
2581                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2582         } else {
2583                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
2584         }
2585
2586         /* Create the helper */
2587         helper = g_slice_new0 (GetMsgInfo);
2588         helper->header = NULL;
2589         helper->mail_op = g_object_ref (self);
2590         helper->user_callback = user_callback;
2591         helper->user_data = user_data;
2592         helper->destroy_notify = NULL;
2593         helper->last_total_bytes = 0;
2594         helper->sum_total_bytes = 0;
2595         helper->total_bytes = 0;
2596         helper->more_msgs = NULL;
2597
2598         modest_mail_operation_notify_start (self);
2599
2600         /* notify about the start of the operation */
2601         ModestMailOperationState *state;
2602         state = modest_mail_operation_clone_state (self);
2603         state->done = 0;
2604         state->total = 0;
2605         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
2606                                 0, state, NULL);
2607         g_slice_free (ModestMailOperationState, state);
2608
2609         tny_folder_find_msg_async (folder, msg_uid, get_msg_async_cb, get_msg_status_cb, helper);
2610 }
2611
2612 void
2613 modest_mail_operation_get_msg (ModestMailOperation *self,
2614                                TnyHeader *header,
2615                                gboolean progress_feedback,
2616                                GetMsgAsyncUserCallback user_callback,
2617                                gpointer user_data)
2618 {
2619         GetMsgInfo *helper = NULL;
2620         TnyFolder *folder;
2621         ModestMailOperationPrivate *priv;
2622
2623         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2624         g_return_if_fail (TNY_IS_HEADER (header));
2625
2626         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2627         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2628         priv->total = 1;
2629         priv->done = 0;
2630
2631         /* Check memory low */
2632         if (_check_memory_low (self)) {
2633                 if (user_callback)
2634                         user_callback (self, header, FALSE, NULL, priv->error, user_data);
2635                 modest_mail_operation_notify_end (self);
2636                 return;
2637         }
2638
2639         /* Get account and set it into mail_operation */
2640         folder = tny_header_get_folder (header);
2641         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2642
2643         /* Check for cached messages */
2644         if (progress_feedback) {
2645                 if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)
2646                         priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN;
2647                 else
2648                         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
2649         } else {
2650                 priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
2651         }
2652
2653         /* Create the helper */
2654         helper = g_slice_new0 (GetMsgInfo);
2655         helper->header = g_object_ref (header);
2656         helper->mail_op = g_object_ref (self);
2657         helper->user_callback = user_callback;
2658         helper->user_data = user_data;
2659         helper->destroy_notify = NULL;
2660         helper->last_total_bytes = 0;
2661         helper->sum_total_bytes = 0;
2662         helper->total_bytes = tny_header_get_message_size (header);
2663         helper->more_msgs = NULL;
2664
2665         modest_mail_operation_notify_start (self);
2666
2667         /* notify about the start of the operation */
2668         ModestMailOperationState *state;
2669         state = modest_mail_operation_clone_state (self);
2670         state->done = 0;
2671         state->total = 0;
2672         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
2673                                 0, state, NULL);
2674         g_slice_free (ModestMailOperationState, state);
2675
2676         tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, helper);
2677
2678         g_object_unref (G_OBJECT (folder));
2679 }
2680
2681 static void
2682 get_msg_status_cb (GObject *obj,
2683                    TnyStatus *status,
2684                    gpointer user_data)
2685 {
2686         GetMsgInfo *helper = NULL;
2687
2688         g_return_if_fail (status != NULL);
2689
2690         /* Show only the status information we want */
2691         if (status->code != TNY_FOLDER_STATUS_CODE_GET_MSG)
2692                 return;
2693
2694         helper = (GetMsgInfo *) user_data;
2695         g_return_if_fail (helper != NULL);
2696
2697         /* Notify progress */
2698         notify_progress_of_multiple_messages (helper->mail_op, status, &(helper->last_total_bytes),
2699                                               &(helper->sum_total_bytes), helper->total_bytes, FALSE);
2700 }
2701
2702 static void
2703 get_msg_async_cb (TnyFolder *folder,
2704                   gboolean canceled,
2705                   TnyMsg *msg,
2706                   GError *err,
2707                   gpointer user_data)
2708 {
2709         GetMsgInfo *info = NULL;
2710         ModestMailOperationPrivate *priv = NULL;
2711         gboolean finished;
2712
2713         info = (GetMsgInfo *) user_data;
2714
2715         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
2716         priv->done++;
2717
2718         if (info->more_msgs) {
2719                 tny_iterator_next (info->more_msgs);
2720                 finished = (tny_iterator_is_done (info->more_msgs));
2721         } else {
2722                 finished = (priv->done == priv->total) ? TRUE : FALSE;
2723         }
2724
2725         /* If canceled by the user, ignore the error given by Tinymail */
2726         if (canceled) {
2727                 canceled = TRUE;
2728                 finished = TRUE;
2729                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2730         } else if (err) {
2731                 priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
2732                 priv->error = g_error_copy ((const GError *) err);
2733                 if (priv->error) {
2734                         priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
2735                 } else {
2736                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
2737                                      MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2738                                      err->message);
2739                 }
2740         } else if (finished && priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
2741                 /* Set the success status before calling the user callback */
2742                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
2743         }
2744
2745         if (info->header == NULL && msg)
2746                 info->header = tny_msg_get_header (msg);
2747
2748         /* Call the user callback */
2749         if (info->user_callback)
2750                 info->user_callback (info->mail_op, info->header, canceled,
2751                                      msg, err, info->user_data);
2752
2753         /* Notify about operation end if this is the last callback */
2754         if (finished) {
2755                 /* Free user data */
2756                 if (info->destroy_notify)
2757                         info->destroy_notify (info->user_data);
2758
2759                 /* Notify about operation end */
2760                 modest_mail_operation_notify_end (info->mail_op);
2761
2762                 /* Clean */
2763                 if (info->more_msgs)
2764                         g_object_unref (info->more_msgs);
2765                 if (info->header)
2766                         g_object_unref (info->header);
2767                 g_object_unref (info->mail_op);
2768                 g_slice_free (GetMsgInfo, info);
2769         } else if (info->more_msgs) {
2770                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (info->more_msgs));
2771                 TnyFolder *folder = tny_header_get_folder (header);
2772
2773                 g_object_unref (info->header);
2774                 info->header = g_object_ref (header);
2775
2776                 /* Retrieve the next message */
2777                 tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, info);
2778
2779                 g_object_unref (header);
2780                 g_object_unref (folder);
2781         } else {
2782                 g_warning ("%s: finished != TRUE but no messages left", __FUNCTION__);
2783         }
2784 }
2785
2786 void
2787 modest_mail_operation_get_msgs_full (ModestMailOperation *self,
2788                                      TnyList *header_list,
2789                                      GetMsgAsyncUserCallback user_callback,
2790                                      gpointer user_data,
2791                                      GDestroyNotify notify)
2792 {
2793         ModestMailOperationPrivate *priv = NULL;
2794         gint msg_list_size;
2795         TnyIterator *iter = NULL;
2796         gboolean has_uncached_messages;
2797
2798         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2799
2800         /* Init mail operation */
2801         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2802         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
2803         priv->done = 0;
2804         priv->total = tny_list_get_length(header_list);
2805
2806         /* Check memory low */
2807         if (_check_memory_low (self)) {
2808                 if (user_callback) {
2809                         TnyHeader *header = NULL;
2810                         TnyIterator *iter;
2811
2812                         if (tny_list_get_length (header_list) > 0) {
2813                                 iter = tny_list_create_iterator (header_list);
2814                                 header = (TnyHeader *) tny_iterator_get_current (iter);
2815                                 g_object_unref (iter);
2816                         }
2817                         user_callback (self, header, FALSE, NULL, priv->error, user_data);
2818                         if (header)
2819                                 g_object_unref (header);
2820                 }
2821                 if (notify)
2822                         notify (user_data);
2823                 /* Notify about operation end */
2824                 modest_mail_operation_notify_end (self);
2825                 return;
2826         }
2827
2828         /* Check uncached messages */
2829         for (iter = tny_list_create_iterator (header_list), has_uncached_messages = FALSE;
2830              !has_uncached_messages && !tny_iterator_is_done (iter);
2831              tny_iterator_next (iter)) {
2832                 TnyHeader *header;
2833
2834                 header = (TnyHeader *) tny_iterator_get_current (iter);
2835                 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
2836                         has_uncached_messages = TRUE;
2837                 g_object_unref (header);
2838         }
2839         g_object_unref (iter);
2840         priv->op_type = has_uncached_messages?MODEST_MAIL_OPERATION_TYPE_RECEIVE:MODEST_MAIL_OPERATION_TYPE_OPEN;
2841
2842         /* Get account and set it into mail_operation */
2843         if (tny_list_get_length (header_list) >= 1) {
2844                 TnyIterator *iterator = tny_list_create_iterator (header_list);
2845                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iterator));
2846                 if (header) {
2847                         TnyFolder *folder = tny_header_get_folder (header);
2848                         if (folder) {
2849                                 priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
2850                                 g_object_unref (folder);
2851                         }
2852                         g_object_unref (header);
2853                 }
2854                 g_object_unref (iterator);
2855         }
2856
2857         msg_list_size = compute_message_list_size (header_list, 0);
2858
2859         modest_mail_operation_notify_start (self);
2860         iter = tny_list_create_iterator (header_list);
2861         if (!tny_iterator_is_done (iter)) {
2862                 /* notify about the start of the operation */
2863                 ModestMailOperationState *state;
2864                 state = modest_mail_operation_clone_state (self);
2865                 state->done = 0;
2866                 state->total = 0;
2867                 g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
2868                                0, state, NULL);
2869
2870                 GetMsgInfo *msg_info = NULL;
2871                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2872                 TnyFolder *folder = tny_header_get_folder (header);
2873
2874                 /* Create the message info */
2875                 msg_info = g_slice_new0 (GetMsgInfo);
2876                 msg_info->mail_op = g_object_ref (self);
2877                 msg_info->header = g_object_ref (header);
2878                 msg_info->more_msgs = g_object_ref (iter);
2879                 msg_info->user_callback = user_callback;
2880                 msg_info->user_data = user_data;
2881                 msg_info->destroy_notify = notify;
2882                 msg_info->last_total_bytes = 0;
2883                 msg_info->sum_total_bytes = 0;
2884                 msg_info->total_bytes = msg_list_size;
2885
2886                 /* The callback will call it per each header */
2887                 tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, msg_info);
2888
2889                 /* Free and go on */
2890                 g_object_unref (header);
2891                 g_object_unref (folder);
2892                 g_slice_free (ModestMailOperationState, state);
2893         }
2894         g_object_unref (iter);
2895 }
2896
2897
2898 static void
2899 remove_msgs_async_cb (TnyFolder *folder,
2900                       gboolean canceled,
2901                       GError *err,
2902                       gpointer user_data)
2903 {
2904         gboolean expunge, leave_on_server;
2905         const gchar *account_name;
2906         TnyAccount *account;
2907         ModestProtocolType account_proto = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
2908         ModestMailOperation *self;
2909         ModestMailOperationPrivate *priv;
2910         ModestProtocolRegistry *protocol_registry;
2911
2912         self = (ModestMailOperation *) user_data;
2913         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2914         protocol_registry = modest_runtime_get_protocol_registry ();
2915
2916         if (canceled || err) {
2917                 /* If canceled by the user, ignore the error given by Tinymail */
2918                 if (canceled) {
2919                         priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
2920                 } else if (err) {
2921                         priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
2922                         priv->error = g_error_copy ((const GError *) err);
2923                         priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
2924                 }
2925                 /* Exit */
2926                 modest_mail_operation_notify_end (self);
2927                 g_object_unref (self);
2928                 return;
2929         }
2930
2931         account = modest_tny_folder_get_account (folder);
2932         account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
2933         leave_on_server =
2934                 modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
2935                                                         account_name);
2936         account_proto = modest_tny_account_get_protocol_type (account);
2937         g_object_unref (account);
2938
2939         if ((modest_protocol_registry_protocol_type_has_leave_on_server (protocol_registry, account_proto) &&
2940              !leave_on_server) ||
2941             !modest_tny_folder_is_remote_folder (folder))
2942                 expunge = TRUE;
2943         else
2944                 expunge = FALSE;
2945
2946         /* Sync folder */
2947         tny_folder_sync_async(folder, expunge, sync_folder_finish_callback,
2948                               NULL, self);
2949 }
2950
2951 void
2952 modest_mail_operation_remove_msgs (ModestMailOperation *self,
2953                                    TnyList *headers,
2954                                    gboolean remove_to_trash /*ignored*/)
2955 {
2956         TnyFolder *folder = NULL;
2957         ModestMailOperationPrivate *priv;
2958         TnyIterator *iter = NULL;
2959         TnyHeader *header = NULL;
2960         TnyList *remove_headers = NULL;
2961         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
2962         ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
2963
2964         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
2965         g_return_if_fail (TNY_IS_LIST (headers));
2966
2967         if (remove_to_trash)
2968                 g_warning ("remove to trash is not implemented");
2969
2970         if (tny_list_get_length(headers) == 0) {
2971                 g_warning ("%s: list of headers is empty\n", __FUNCTION__);
2972                 goto cleanup; /* nothing to do */
2973         }
2974
2975         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
2976
2977         /* Get folder from first header and sync it */
2978         iter = tny_list_create_iterator (headers);
2979         header = TNY_HEADER (tny_iterator_get_current (iter));
2980         g_object_unref (iter);
2981
2982         folder = tny_header_get_folder (header);
2983         if (!TNY_IS_FOLDER(folder)) {
2984                 g_warning ("%s: could not get folder for header\n", __FUNCTION__);
2985                 goto cleanup;
2986         }
2987
2988         /* Use the merged folder if we're removing messages from outbox */
2989         if (modest_tny_folder_is_local_folder (folder)) {
2990                 ModestTnyLocalFoldersAccount *local_account;
2991
2992                 local_account = (ModestTnyLocalFoldersAccount *)
2993                         modest_tny_account_store_get_local_folders_account (accstore);
2994                 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
2995                 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
2996                         g_object_unref (folder);
2997                         folder = modest_tny_local_folders_account_get_merged_outbox (local_account);
2998                 }
2999                 g_object_unref (local_account);
3000         }
3001
3002         if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
3003                 TnyIterator *headers_iter = tny_list_create_iterator (headers);
3004
3005                 while (!tny_iterator_is_done (headers_iter)) {
3006                         TnyTransportAccount *traccount = NULL;
3007                         TnyHeader *hdr = NULL;
3008
3009                         hdr = TNY_HEADER (tny_iterator_get_current (headers_iter));
3010                         traccount = modest_tny_account_store_get_transport_account_from_outbox_header (accstore,
3011                                                                                                        header);
3012                         if (traccount) {
3013                                 ModestTnySendQueueStatus status;
3014                                 ModestTnySendQueue *send_queue;
3015
3016                                 send_queue = modest_runtime_get_send_queue(traccount, TRUE);
3017                                 if (TNY_IS_SEND_QUEUE (send_queue)) {
3018                                         char *msg_id;
3019
3020                                         msg_id = modest_tny_send_queue_get_msg_id (hdr);
3021                                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
3022                                         if (status != MODEST_TNY_SEND_QUEUE_SENDING) {
3023                                                 if (G_UNLIKELY (remove_headers == NULL))
3024                                                         remove_headers = tny_simple_list_new ();
3025                                                 tny_list_append(remove_headers, G_OBJECT(hdr));
3026                                         }
3027                                         g_free(msg_id);
3028                                 }
3029                                 g_object_unref(traccount);
3030                         }
3031                         g_object_unref(hdr);
3032                         tny_iterator_next (headers_iter);
3033                 }
3034                 g_object_unref(headers_iter);
3035         }
3036
3037         /* Get account and set it into mail_operation */
3038         priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
3039         priv->op_type = MODEST_MAIL_OPERATION_TYPE_DELETE;
3040         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3041
3042         if (!remove_headers)
3043                 remove_headers = g_object_ref (headers);
3044
3045         /* remove message from folder */
3046         modest_mail_operation_notify_start (self);
3047         tny_folder_remove_msgs_async (folder, remove_headers, remove_msgs_async_cb,
3048                                       NULL, g_object_ref (self));
3049
3050 cleanup:
3051         if (remove_headers)
3052                 g_object_unref (remove_headers);
3053         if (header)
3054                 g_object_unref (header);
3055         if (folder)
3056                 g_object_unref (folder);
3057 }
3058
3059 static void
3060 notify_progress_of_multiple_messages (ModestMailOperation *self,
3061                                       TnyStatus *status,
3062                                       gint *last_total_bytes,
3063                                       gint *sum_total_bytes,
3064                                       gint total_bytes,
3065                                       gboolean increment_done)
3066 {
3067         ModestMailOperationPrivate *priv;
3068         ModestMailOperationState *state;
3069         gboolean is_num_bytes = FALSE;
3070
3071         priv =  MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3072
3073         /* We know that tinymail sends us information about
3074          *  transferred bytes with this particular message
3075          */
3076         if (status->message)
3077                 is_num_bytes = (g_ascii_strcasecmp (status->message, "Retrieving message") == 0);
3078
3079         state = modest_mail_operation_clone_state (self);
3080         if (is_num_bytes && !((status->position == 1) && (status->of_total == 100))) {
3081                 /* We know that we're in a different message when the
3082                    total number of bytes to transfer is different. Of
3083                    course it could fail if we're transferring messages
3084                    of the same size, but this is a workarround */
3085                 if (status->of_total != *last_total_bytes) {
3086                         /* We need to increment the done when there is
3087                            no information about each individual
3088                            message, we need to do this in message
3089                            transfers, and we don't do it for getting
3090                            messages */
3091                         if (increment_done)
3092                                 priv->done++;
3093                         *sum_total_bytes += *last_total_bytes;
3094                         *last_total_bytes = status->of_total;
3095                 }
3096                 state->bytes_done += status->position + *sum_total_bytes;
3097                 state->bytes_total = total_bytes;
3098
3099                 /* Notify the status change. Only notify about changes
3100                    referred to bytes */
3101                 g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
3102                                0, state, NULL);
3103         }
3104
3105         g_slice_free (ModestMailOperationState, state);
3106 }
3107
3108 static void
3109 transfer_msgs_status_cb (GObject *obj,
3110                          TnyStatus *status,
3111                          gpointer user_data)
3112 {
3113         XFerMsgsAsyncHelper *helper;
3114
3115         g_return_if_fail (status != NULL);
3116
3117         /* Show only the status information we want */
3118         if (status->code != TNY_FOLDER_STATUS_CODE_XFER_MSGS)
3119                 return;
3120
3121         helper = (XFerMsgsAsyncHelper *) user_data;
3122         g_return_if_fail (helper != NULL);
3123
3124         /* Notify progress */
3125         notify_progress_of_multiple_messages (helper->mail_op, status, &(helper->last_total_bytes),
3126                                               &(helper->sum_total_bytes), helper->total_bytes, TRUE);
3127 }
3128
3129 static void
3130 transfer_msgs_sync_folder_cb (TnyFolder *self,
3131                               gboolean cancelled,
3132                               GError *err,
3133                               gpointer user_data)
3134 {
3135         XFerMsgsAsyncHelper *helper;
3136         /* We don't care here about the results of the
3137            synchronization */
3138         helper = (XFerMsgsAsyncHelper *) user_data;
3139
3140         /* Notify about operation end */
3141         modest_mail_operation_notify_end (helper->mail_op);
3142
3143         /* If user defined callback function was defined, call it */
3144         if (helper->user_callback)
3145                 helper->user_callback (helper->mail_op, helper->user_data);
3146
3147         /* Free */
3148         if (helper->more_msgs)
3149                 g_object_unref (helper->more_msgs);
3150         if (helper->headers)
3151                 g_object_unref (helper->headers);
3152         if (helper->dest_folder)
3153                 g_object_unref (helper->dest_folder);
3154         if (helper->mail_op)
3155                 g_object_unref (helper->mail_op);
3156         g_slice_free (XFerMsgsAsyncHelper, helper);
3157 }
3158
3159 static void
3160 transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError *err, gpointer user_data)
3161 {
3162         XFerMsgsAsyncHelper *helper;
3163         ModestMailOperation *self;
3164         ModestMailOperationPrivate *priv;
3165         gboolean finished = TRUE;
3166
3167         helper = (XFerMsgsAsyncHelper *) user_data;
3168         self = helper->mail_op;
3169
3170         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3171
3172         if (cancelled) {
3173                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
3174         } else if (err) {
3175                 priv->error = g_error_copy (err);
3176                 priv->done = 0;
3177                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3178         } else if (priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
3179                 if (helper->more_msgs) {
3180                         /* We'll transfer the next message in the list */
3181                         tny_iterator_next (helper->more_msgs);
3182                         if (!tny_iterator_is_done (helper->more_msgs)) {
3183                                 GObject *next_header;
3184                                 g_object_unref (helper->headers);
3185                                 helper->headers = tny_simple_list_new ();
3186                                 next_header = tny_iterator_get_current (helper->more_msgs);
3187                                 tny_list_append (helper->headers, next_header);
3188                                 g_object_unref (next_header);
3189                                 finished = FALSE;
3190                         }
3191                 }
3192                 if (finished) {
3193                         priv->done = 1;
3194                         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3195                 }
3196         }
3197
3198         if (finished) {
3199                 /* Synchronize the source folder contents. This should
3200                    be done by tinymail but the camel_folder_sync it's
3201                    actually disabled in transfer_msgs_thread_clean
3202                    because it's supposed to cause hangs */
3203                 tny_folder_sync_async (folder, helper->delete,
3204                                        transfer_msgs_sync_folder_cb,
3205                                        NULL, helper);
3206         } else {
3207                 /* Transfer more messages */
3208                 tny_folder_transfer_msgs_async (folder,
3209                                                 helper->headers,
3210                                                 helper->dest_folder,
3211                                                 helper->delete,
3212                                                 transfer_msgs_cb,
3213                                                 transfer_msgs_status_cb,
3214                                                 helper);
3215         }
3216 }
3217
3218 /* Computes the size of the messages the headers in the list belongs
3219    to. If num_elements is different from 0 then it only takes into
3220    account the first num_elements for the calculation */
3221 static guint
3222 compute_message_list_size (TnyList *headers,
3223                            guint num_elements)
3224 {
3225         TnyIterator *iter;
3226         guint size = 0, element = 0;
3227
3228         /* If num_elements is not valid then take all into account */
3229         if ((num_elements <= 0) || (num_elements > tny_list_get_length (headers)))
3230                 num_elements = tny_list_get_length (headers);
3231
3232         iter = tny_list_create_iterator (headers);
3233         while (!tny_iterator_is_done (iter) && element < num_elements) {
3234                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
3235                 size += tny_header_get_message_size (header);
3236                 g_object_unref (header);
3237                 tny_iterator_next (iter);
3238                 element++;
3239         }
3240         g_object_unref (iter);
3241
3242         return size;
3243 }
3244
3245 void
3246 modest_mail_operation_xfer_msgs (ModestMailOperation *self,
3247                                  TnyList *headers,
3248                                  TnyFolder *folder,
3249                                  gboolean delete_original,
3250                                  XferMsgsAsyncUserCallback user_callback,
3251                                  gpointer user_data)
3252 {
3253         ModestMailOperationPrivate *priv = NULL;
3254         TnyIterator *iter = NULL;
3255         TnyFolder *src_folder = NULL;
3256         XFerMsgsAsyncHelper *helper = NULL;
3257         TnyHeader *header = NULL;
3258         ModestTnyFolderRules rules = 0;
3259         TnyAccount *dst_account = NULL;
3260         gboolean leave_on_server;
3261         ModestMailOperationState *state;
3262         ModestProtocolRegistry *protocol_registry;
3263         ModestProtocolType account_protocol;
3264
3265         g_return_if_fail (self && MODEST_IS_MAIL_OPERATION (self));
3266         g_return_if_fail (headers && TNY_IS_LIST (headers));
3267         g_return_if_fail (folder && TNY_IS_FOLDER (folder));
3268
3269         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3270         protocol_registry = modest_runtime_get_protocol_registry ();
3271
3272         priv->total = tny_list_get_length (headers);
3273         priv->done = 0;
3274         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3275         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
3276
3277         /* Apply folder rules */
3278         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
3279         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
3280                 /* Set status failed and set an error */
3281                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3282                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
3283                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
3284                              _CS("ckct_ib_unable_to_paste_here"));
3285                 /* Notify the queue */
3286                 modest_mail_operation_notify_end (self);
3287                 return;
3288         }
3289
3290         /* Get source folder */
3291         iter = tny_list_create_iterator (headers);
3292         header = TNY_HEADER (tny_iterator_get_current (iter));
3293         if (header) {
3294                 src_folder = tny_header_get_folder (header);
3295                 g_object_unref (header);
3296         }
3297         g_object_unref (iter);
3298
3299         if (src_folder == NULL) {
3300                 /* Notify the queue */
3301                 modest_mail_operation_notify_end (self);
3302
3303                 g_warning ("%s: cannot find folder from header", __FUNCTION__);
3304                 return;
3305         }
3306
3307
3308         /* Check folder source and destination */
3309         if (src_folder == folder) {
3310                 /* Set status failed and set an error */
3311                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3312                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
3313                              MODEST_MAIL_OPERATION_ERROR_BAD_PARAMETER,
3314                              _("mail_in_ui_folder_copy_target_error"));
3315
3316                 /* Notify the queue */
3317                 modest_mail_operation_notify_end (self);
3318
3319                 /* Free */
3320                 g_object_unref (src_folder);
3321                 return;
3322         }
3323
3324         /* Create the helper */
3325         helper = g_slice_new0 (XFerMsgsAsyncHelper);
3326         helper->mail_op = g_object_ref(self);
3327         helper->dest_folder = g_object_ref(folder);
3328         helper->user_callback = user_callback;
3329         helper->user_data = user_data;
3330         helper->last_total_bytes = 0;
3331         helper->sum_total_bytes = 0;
3332         helper->total_bytes = compute_message_list_size (headers, 0);
3333
3334         /* Get account and set it into mail_operation */
3335         priv->account = modest_tny_folder_get_account (src_folder);
3336         dst_account = modest_tny_folder_get_account (folder);
3337
3338         if (priv->account == dst_account) {
3339                 /* Transfer all messages at once using the fast
3340                  * method. Note that depending on the server this
3341                  * might not be that fast, and might not be
3342                  * user-cancellable either */
3343                 helper->headers = g_object_ref (headers);
3344                 helper->more_msgs = NULL;
3345         } else {
3346                 /* Transfer messages one by one so the user can cancel
3347                  * the operation */
3348                 GObject *hdr;
3349                 helper->headers = tny_simple_list_new ();
3350                 helper->more_msgs = tny_list_create_iterator (headers);
3351                 hdr = tny_iterator_get_current (helper->more_msgs);
3352                 tny_list_append (helper->headers, hdr);
3353                 g_object_unref (hdr);
3354         }
3355
3356         /* If leave_on_server is set to TRUE then don't use
3357            delete_original, we always pass FALSE. This is because
3358            otherwise tinymail will try to sync the source folder and
3359            this could cause an error if we're offline while
3360            transferring an already downloaded message from a POP
3361            account */
3362         account_protocol = modest_tny_account_get_protocol_type (priv->account);
3363         if (modest_protocol_registry_protocol_type_has_leave_on_server (protocol_registry, account_protocol)) {
3364                 const gchar *account_name;
3365
3366                 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (priv->account);
3367                 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
3368                                                                           account_name);
3369         } else {
3370                 leave_on_server = FALSE;
3371         }
3372
3373         /* Do not delete messages if leave on server is TRUE */
3374         helper->delete = (leave_on_server) ? FALSE : delete_original;
3375
3376         modest_mail_operation_notify_start (self);
3377
3378         /* Start notifying progress */
3379         state = modest_mail_operation_clone_state (self);
3380         state->done = 0;
3381         state->total = 0;
3382         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
3383         g_slice_free (ModestMailOperationState, state);
3384
3385         tny_folder_transfer_msgs_async (src_folder,
3386                                         helper->headers,
3387                                         folder,
3388                                         helper->delete,
3389                                         transfer_msgs_cb,
3390                                         transfer_msgs_status_cb,
3391                                         helper);
3392         g_object_unref (src_folder);
3393         g_object_unref (dst_account);
3394 }
3395
3396
3397 static void
3398 on_refresh_folder (TnyFolder   *folder,
3399                    gboolean     cancelled,
3400                    GError     *error,
3401                    gpointer     user_data)
3402 {
3403         RefreshAsyncHelper *helper = NULL;
3404         ModestMailOperation *self = NULL;
3405         ModestMailOperationPrivate *priv = NULL;
3406
3407         helper = (RefreshAsyncHelper *) user_data;
3408         self = helper->mail_op;
3409         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3410
3411         g_return_if_fail(priv!=NULL);
3412
3413         if (error) {
3414                 priv->error = g_error_copy (error);
3415                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3416                 goto out;
3417         }
3418
3419         if (cancelled) {
3420                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
3421                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
3422                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
3423                              _("Error trying to refresh the contents of %s"),
3424                              tny_folder_get_name (folder));
3425                 goto out;
3426         }
3427
3428         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3429  out:
3430
3431         /* Call user defined callback, if it exists */
3432         if (helper->user_callback) {
3433
3434                 /* This is not a GDK lock because we are a Tinymail callback and
3435                  * Tinymail already acquires the Gdk lock */
3436                 helper->user_callback (self, folder, helper->user_data);
3437         }
3438
3439         /* Free */
3440         g_slice_free (RefreshAsyncHelper, helper);
3441
3442         /* Notify about operation end */
3443         modest_mail_operation_notify_end (self);
3444         g_object_unref(self);
3445 }
3446
3447 static void
3448 on_refresh_folder_status_update (GObject *obj,
3449                                  TnyStatus *status,
3450                                  gpointer user_data)
3451 {
3452         RefreshAsyncHelper *helper = NULL;
3453         ModestMailOperation *self = NULL;
3454         ModestMailOperationPrivate *priv = NULL;
3455         ModestMailOperationState *state;
3456
3457         g_return_if_fail (user_data != NULL);
3458         g_return_if_fail (status != NULL);
3459
3460         /* Show only the status information we want */
3461         if (status->code != TNY_FOLDER_STATUS_CODE_REFRESH)
3462                 return;
3463
3464         helper = (RefreshAsyncHelper *) user_data;
3465         self = helper->mail_op;
3466         g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
3467
3468         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3469
3470         priv->done = status->position;
3471         priv->total = status->of_total;
3472
3473         state = modest_mail_operation_clone_state (self);
3474
3475         /* This is not a GDK lock because we are a Tinymail callback and
3476          * Tinymail already acquires the Gdk lock */
3477         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
3478
3479         g_slice_free (ModestMailOperationState, state);
3480 }
3481
3482 void
3483 modest_mail_operation_refresh_folder  (ModestMailOperation *self,
3484                                        TnyFolder *folder,
3485                                        RefreshAsyncUserCallback user_callback,
3486                                        gpointer user_data)
3487 {
3488         ModestMailOperationPrivate *priv = NULL;
3489         RefreshAsyncHelper *helper = NULL;
3490
3491         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3492
3493         /* Check memory low */
3494         if (_check_memory_low (self)) {
3495                 if (user_callback)
3496                         user_callback (self, folder, user_data);
3497                 /* Notify about operation end */
3498                 modest_mail_operation_notify_end (self);
3499                 return;
3500         }
3501
3502         /* Get account and set it into mail_operation */
3503         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3504         priv->account = modest_tny_folder_get_account  (folder);
3505         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
3506
3507         /* Create the helper */
3508         helper = g_slice_new0 (RefreshAsyncHelper);
3509         helper->mail_op = g_object_ref(self);
3510         helper->user_callback = user_callback;
3511         helper->user_data = user_data;
3512
3513         modest_mail_operation_notify_start (self);
3514
3515         /* notify that the operation was started */
3516         ModestMailOperationState *state;
3517         state = modest_mail_operation_clone_state (self);
3518         state->done = 0;
3519         state->total = 0;
3520         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
3521                         0, state, NULL);
3522         g_slice_free (ModestMailOperationState, state);
3523
3524         tny_folder_refresh_async (folder,
3525                                   on_refresh_folder,
3526                                   on_refresh_folder_status_update,
3527                                   helper);
3528 }
3529
3530 static void
3531 run_queue_notify_and_destroy (RunQueueHelper *helper,
3532                               ModestMailOperationStatus status)
3533 {
3534         ModestMailOperationPrivate *priv;
3535
3536         /* Disconnect */
3537         if (helper->error_handler &&
3538             g_signal_handler_is_connected (helper->queue, helper->error_handler))
3539                 g_signal_handler_disconnect (helper->queue, helper->error_handler);
3540         if (helper->start_handler &&
3541             g_signal_handler_is_connected (helper->queue, helper->start_handler))
3542                 g_signal_handler_disconnect (helper->queue, helper->start_handler);
3543         if (helper->stop_handler &&
3544             g_signal_handler_is_connected (helper->queue, helper->stop_handler))
3545                 g_signal_handler_disconnect (helper->queue, helper->stop_handler);
3546
3547         /* Set status */
3548         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (helper->self);
3549         priv->status = status;
3550
3551         /* Notify end */
3552         modest_mail_operation_notify_end (helper->self);
3553
3554         /* Free data */
3555         g_object_unref (helper->queue);
3556         g_object_unref (helper->self);
3557         g_slice_free (RunQueueHelper, helper);
3558 }
3559
3560 static void
3561 run_queue_stop (ModestTnySendQueue *queue,
3562                 gpointer user_data)
3563 {
3564         RunQueueHelper *helper;
3565
3566         g_debug ("%s sending queue stopped", __FUNCTION__);
3567
3568         helper = (RunQueueHelper *) user_data;
3569         run_queue_notify_and_destroy (helper, MODEST_MAIL_OPERATION_STATUS_SUCCESS);
3570 }
3571
3572 void
3573 modest_mail_operation_run_queue (ModestMailOperation *self,
3574                                  ModestTnySendQueue *queue)
3575 {
3576         ModestMailOperationPrivate *priv;
3577         RunQueueHelper *helper;
3578
3579         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3580         g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (queue));
3581         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3582
3583         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3584         priv->account = TNY_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (queue)));
3585         priv->op_type = MODEST_MAIL_OPERATION_TYPE_RUN_QUEUE;
3586
3587         /* Create the helper */
3588         helper = g_slice_new0 (RunQueueHelper);
3589         helper->queue = g_object_ref (queue);
3590         helper->self = g_object_ref (self);
3591         helper->stop_handler = g_signal_connect (queue, "queue-stop",
3592                                                  G_CALLBACK (run_queue_stop),
3593                                                  helper);
3594
3595         /* Notify operation has started */
3596         modest_mail_operation_notify_start (self);
3597         g_debug ("%s, run queue started", __FUNCTION__);
3598 }
3599
3600 static void
3601 queue_wakeup_callback (ModestTnySendQueue *queue,
3602                        gboolean cancelled,
3603                        GError *error,
3604                        gpointer userdata)
3605 {
3606         ModestMailOperation *mail_op;
3607         ModestMailOperationPrivate *priv;
3608
3609         mail_op = (ModestMailOperation *) userdata;
3610         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
3611
3612         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3613         tny_camel_send_queue_flush (TNY_CAMEL_SEND_QUEUE (queue));
3614
3615         /* Notify end */
3616         modest_mail_operation_notify_end (mail_op);
3617         g_object_unref (mail_op);
3618 }
3619
3620 void
3621 modest_mail_operation_queue_wakeup (ModestMailOperation *self,
3622                                     ModestTnySendQueue *queue)
3623 {
3624         ModestMailOperationPrivate *priv;
3625
3626         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3627         g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (queue));
3628         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3629
3630         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3631         priv->account = TNY_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (queue)));
3632         priv->op_type = MODEST_MAIL_OPERATION_TYPE_QUEUE_WAKEUP;
3633
3634         g_object_ref (self);
3635
3636         modest_tny_send_queue_wakeup (queue, queue_wakeup_callback, self);
3637         modest_mail_operation_notify_start (self);
3638 }
3639
3640 static void
3641 shutdown_callback (ModestTnyAccountStore *account_store, gpointer userdata)
3642 {
3643         ModestMailOperation *self = (ModestMailOperation *) userdata;
3644         ModestMailOperationPrivate *priv;
3645
3646         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3647         g_return_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (account_store));
3648         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3649
3650         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3651
3652         modest_mail_operation_notify_end (self);
3653         g_object_unref (self);
3654 }
3655
3656 void
3657 modest_mail_operation_shutdown (ModestMailOperation *self, ModestTnyAccountStore *account_store)
3658 {
3659         ModestMailOperationPrivate *priv;
3660
3661         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3662         g_return_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (account_store));
3663         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3664
3665         modest_mail_operation_queue_set_running_shutdown (modest_runtime_get_mail_operation_queue ());
3666
3667         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3668         priv->account = NULL;
3669         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SHUTDOWN;
3670
3671         modest_mail_operation_notify_start (self);
3672         g_object_ref (self);
3673         modest_tny_account_store_shutdown (account_store, shutdown_callback, self);
3674 }
3675
3676 static void
3677 sync_folder_finish_callback (TnyFolder *self,
3678                              gboolean cancelled,
3679                              GError *err,
3680                              gpointer user_data)
3681
3682 {
3683         ModestMailOperation *mail_op;
3684         ModestMailOperationPrivate *priv;
3685
3686         mail_op = (ModestMailOperation *) user_data;
3687         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
3688
3689         /* If canceled by the user, ignore the error given by Tinymail */
3690         if (cancelled) {
3691                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
3692         } else if (err) {
3693                 /* If the operation was a sync then the status is
3694                    failed, but if it's part of another operation then
3695                    just set it as finished with errors */
3696                 if (priv->op_type == MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER)
3697                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3698                 else
3699                         priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
3700                 priv->error = g_error_copy ((const GError *) err);
3701                 priv->error->domain = MODEST_MAIL_OPERATION_ERROR;
3702         } else {
3703                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3704         }
3705
3706         modest_mail_operation_notify_end (mail_op);
3707         g_object_unref (mail_op);
3708 }
3709
3710 void
3711 modest_mail_operation_sync_folder (ModestMailOperation *self,
3712                                    TnyFolder *folder, gboolean expunge)
3713 {
3714         ModestMailOperationPrivate *priv;
3715
3716         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
3717         g_return_if_fail (TNY_IS_FOLDER (folder));
3718         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
3719
3720         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
3721         priv->account = modest_tny_folder_get_account (folder);
3722         priv->op_type = MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER;
3723
3724         modest_mail_operation_notify_start (self);
3725         g_object_ref (self);
3726         tny_folder_sync_async (folder, expunge,
3727                                (TnyFolderCallback) sync_folder_finish_callback,
3728                                NULL, self);
3729 }
3730
3731 static void
3732 modest_mail_operation_notify_start (ModestMailOperation *self)
3733 {
3734         ModestMailOperationPrivate *priv = NULL;
3735
3736         g_return_if_fail (self);
3737
3738         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3739
3740         /* Ensure that all the fields are filled correctly */
3741         g_return_if_fail (priv->op_type != MODEST_MAIL_OPERATION_TYPE_UNKNOWN);
3742
3743         /* Notify the observers about the mail operation. We do not
3744            wrapp this emission because we assume that this function is
3745            always called from within the main lock */
3746         g_signal_emit (G_OBJECT (self), signals[OPERATION_STARTED_SIGNAL], 0, NULL);
3747 }
3748
3749 /**
3750  *
3751  * It's used by the mail operation queue to notify the observers
3752  * attached to that signal that the operation finished. We need to use
3753  * that because tinymail does not give us the progress of a given
3754  * operation when it finishes (it directly calls the operation
3755  * callback).
3756  */
3757 static void
3758 modest_mail_operation_notify_end (ModestMailOperation *self)
3759 {
3760         ModestMailOperationPrivate *priv = NULL;
3761
3762         g_return_if_fail (self);
3763
3764         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3765
3766         /* Notify the observers about the mail operation end. We do
3767            not wrapp this emission because we assume that this
3768            function is always called from within the main lock */
3769         g_signal_emit (G_OBJECT (self), signals[OPERATION_FINISHED_SIGNAL], 0, NULL);
3770
3771         /* Remove the error user data */
3772         if (priv->error_checking_user_data && priv->error_checking_user_data_destroyer)
3773                 priv->error_checking_user_data_destroyer (priv->error_checking_user_data);
3774 }
3775
3776 TnyAccount *
3777 modest_mail_operation_get_account (ModestMailOperation *self)
3778 {
3779         ModestMailOperationPrivate *priv = NULL;
3780
3781         g_return_val_if_fail (self, NULL);
3782
3783         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3784
3785         return (priv->account) ? g_object_ref (priv->account) : NULL;
3786 }
3787
3788 void
3789 modest_mail_operation_noop (ModestMailOperation *self)
3790 {
3791         ModestMailOperationPrivate *priv = NULL;
3792
3793         g_return_if_fail (self);
3794
3795         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3796         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
3797         priv->op_type = MODEST_MAIL_OPERATION_TYPE_INFO;
3798         priv->done = 0;
3799         priv->total = 0;
3800
3801         /* This mail operation does nothing actually */
3802         modest_mail_operation_notify_start (self);
3803         modest_mail_operation_notify_end (self);
3804 }
3805
3806
3807 gchar*
3808 modest_mail_operation_to_string (ModestMailOperation *self)
3809 {
3810         const gchar *type, *status, *account_id;
3811         ModestMailOperationPrivate *priv = NULL;
3812
3813         g_return_val_if_fail (self, NULL);
3814
3815         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
3816
3817         /* new operations don't have anything interesting */
3818         if (priv->op_type == MODEST_MAIL_OPERATION_TYPE_UNKNOWN)
3819                 return g_strdup_printf ("%p <new operation>", self);
3820
3821         switch (priv->op_type) {
3822         case MODEST_MAIL_OPERATION_TYPE_SEND:    type= "SEND";    break;
3823         case MODEST_MAIL_OPERATION_TYPE_RECEIVE: type= "RECEIVE"; break;
3824         case MODEST_MAIL_OPERATION_TYPE_OPEN:    type= "OPEN";    break;
3825         case MODEST_MAIL_OPERATION_TYPE_DELETE:  type= "DELETE";  break;
3826         case MODEST_MAIL_OPERATION_TYPE_INFO:    type= "INFO";    break;
3827         case MODEST_MAIL_OPERATION_TYPE_RUN_QUEUE: type= "RUN-QUEUE"; break;
3828         case MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER: type= "SYNC-FOLDER"; break;
3829         case MODEST_MAIL_OPERATION_TYPE_UNKNOWN: type= "UNKNOWN"; break;
3830         default: type = "UNEXPECTED"; break;
3831         }
3832
3833         switch (priv->status) {
3834         case MODEST_MAIL_OPERATION_STATUS_INVALID:              status= "INVALID"; break;
3835         case MODEST_MAIL_OPERATION_STATUS_SUCCESS:              status= "SUCCESS"; break;
3836         case MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS: status= "FINISHED-WITH-ERRORS"; break;
3837         case MODEST_MAIL_OPERATION_STATUS_FAILED:               status= "FAILED"; break;
3838         case MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS:          status= "IN-PROGRESS"; break;
3839         case MODEST_MAIL_OPERATION_STATUS_CANCELED:             status= "CANCELLED"; break;
3840         default:                                                status= "UNEXPECTED"; break;
3841         }
3842
3843         account_id = priv->account ? tny_account_get_id (priv->account) : "";
3844
3845         return g_strdup_printf ("%p \"%s\" (%s) [%s] {%d/%d} '%s'", self, account_id,type, status,
3846                                 priv->done, priv->total,
3847                                 priv->error && priv->error->message ? priv->error->message : "");
3848 }
3849
3850 /*
3851  * Once the mail operations were objects this will be no longer
3852  * needed. I don't like it, but we need it for the moment
3853  */
3854 static gboolean
3855 _check_memory_low (ModestMailOperation *mail_op)
3856 {
3857         if (modest_platform_check_memory_low (NULL, FALSE)) {
3858                 ModestMailOperationPrivate *priv;
3859
3860                 priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
3861                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
3862                 g_set_error (&(priv->error),
3863                              MODEST_MAIL_OPERATION_ERROR,
3864                              MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY,
3865                              "Not enough memory to complete the operation");
3866                 return TRUE;
3867         } else {
3868                 return FALSE;
3869         }
3870 }