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