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