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 "modest-mail-operation.h"
  31 /* include other impl specific header files */
  32 #include <string.h>
  33 #include <stdarg.h>
  34 #include <tny-mime-part.h>
  35 #include <tny-store-account.h>
  36 #include <tny-folder-store.h>
  37 #include <tny-folder-store-query.h>
  38 #include <tny-camel-stream.h>
  39 #include <tny-simple-list.h>
  40 #include <tny-send-queue.h>
  41 #include <tny-status.h>
  42 #include <camel/camel-stream-mem.h>
  43 #include <glib/gi18n.h>
  44 #include <modest-tny-account.h>
  45 #include <modest-tny-send-queue.h>
  46 #include <modest-runtime.h>
  47 #include "modest-text-utils.h"
  48 #include "modest-tny-msg.h"
  49 #include "modest-tny-folder.h"
  50 #include "modest-tny-platform-factory.h"
  51 #include "modest-marshal.h"
  52 #include "modest-error.h"
  53
  54 /* 'private'/'protected' functions */
  55 static void modest_mail_operation_class_init (ModestMailOperationClass *klass);
  56 static void modest_mail_operation_init       (ModestMailOperation *obj);
  57 static void modest_mail_operation_finalize   (GObject *obj);
  58
  59 static void     update_folders_cb    (TnyFolderStore *self,
  60                                       TnyList *list,
  61                                       GError **err,
  62                                       gpointer user_data);
  63 static void     update_folders_status_cb (GObject *obj,
  64                                           TnyStatus *status,
  65                                           gpointer user_data);
  66
  67 static void     update_process_msg_status_cb (GObject *obj,
  68                                               TnyStatus *status,
  69                                               gpointer user_data);
  70 static void     get_msg_cb (TnyFolder *folder,
  71                             gboolean cancelled,
  72                             TnyMsg *msg,
  73                             GError **err,
  74                             gpointer user_data);
  75
  76 static void     get_msg_status_cb (GObject *obj,
  77                                    TnyStatus *status,
  78                                    gpointer user_data);
  79
  80
  81 enum _ModestMailOperationSignals
  82 {
  83         PROGRESS_CHANGED_SIGNAL,
  84
  85         NUM_SIGNALS
  86 };
  87
  88 typedef struct _ModestMailOperationPrivate ModestMailOperationPrivate;
  89 struct _ModestMailOperationPrivate {
  90         guint                      done;
  91         guint                      total;
  92         ModestMailOperationStatus  status;
  93         ModestMailOperationId      id;
  94         GObject                   *source;
  95         GError                    *error;
  96 };
  97
  98 #define MODEST_MAIL_OPERATION_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  99                                                    MODEST_TYPE_MAIL_OPERATION, \
 100                                                    ModestMailOperationPrivate))
 101
 102 #define CHECK_EXCEPTION(priv, new_status)  if (priv->error) {\
 103                                                    priv->status = new_status;\
 104                                                }
 105
 106 typedef struct _GetMsgAsyncHelper {
 107         ModestMailOperation *mail_op;
 108         GetMsgAsynUserCallback user_callback;
 109         guint pending_ops;
 110         gpointer user_data;
 111 } GetMsgAsyncHelper;
 112
 113 typedef struct _RefreshFolderAsyncHelper
 114 {
 115         ModestMailOperation *mail_op;
 116         TnyIterator *iter;
 117         guint failed;
 118         guint canceled;
 119
 120 } RefreshFolderAsyncHelper;
 121
 122 typedef struct _XFerMsgAsyncHelper
 123 {
 124         ModestMailOperation *mail_op;
 125         TnyList *headers;
 126         TnyFolder *dest_folder;
 127
 128 } XFerMsgAsyncHelper;
 129
 130
 131 /* globals */
 132 static GObjectClass *parent_class = NULL;
 133
 134 static guint signals[NUM_SIGNALS] = {0};
 135
 136 GType
 137 modest_mail_operation_get_type (void)
 138 {
 139         static GType my_type = 0;
 140         if (!my_type) {
 141                 static const GTypeInfo my_info = {
 142                         sizeof(ModestMailOperationClass),
 143                         NULL,           /* base init */
 144                         NULL,           /* base finalize */
 145                         (GClassInitFunc) modest_mail_operation_class_init,
 146                         NULL,           /* class finalize */
 147                         NULL,           /* class data */
 148                         sizeof(ModestMailOperation),
 149                         1,              /* n_preallocs */
 150                         (GInstanceInitFunc) modest_mail_operation_init,
 151                         NULL
 152                 };
 153                 my_type = g_type_register_static (G_TYPE_OBJECT,
 154                                                   "ModestMailOperation",
 155                                                   &my_info, 0);
 156         }
 157         return my_type;
 158 }
 159
 160 static void
 161 modest_mail_operation_class_init (ModestMailOperationClass *klass)
 162 {
 163         GObjectClass *gobject_class;
 164         gobject_class = (GObjectClass*) klass;
 165
 166         parent_class            = g_type_class_peek_parent (klass);
 167         gobject_class->finalize = modest_mail_operation_finalize;
 168
 169         g_type_class_add_private (gobject_class, sizeof(ModestMailOperationPrivate));
 170
 171         /**
 172          * ModestMailOperation::progress-changed
 173          * @self: the #MailOperation that emits the signal
 174          * @user_data: user data set when the signal handler was connected
 175          *
 176          * Emitted when the progress of a mail operation changes
 177          */
 178         signals[PROGRESS_CHANGED_SIGNAL] =
 179                 g_signal_new ("progress-changed",
 180                               G_TYPE_FROM_CLASS (gobject_class),
 181                               G_SIGNAL_RUN_FIRST,
 182                               G_STRUCT_OFFSET (ModestMailOperationClass, progress_changed),
 183                               NULL, NULL,
 184                               g_cclosure_marshal_VOID__VOID,
 185                               G_TYPE_NONE, 0);
 186 }
 187
 188 static void
 189 modest_mail_operation_init (ModestMailOperation *obj)
 190 {
 191         ModestMailOperationPrivate *priv;
 192
 193         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
 194
 195         priv->status   = MODEST_MAIL_OPERATION_STATUS_INVALID;
 196         priv->id       = MODEST_MAIL_OPERATION_ID_UNKNOWN;
 197         priv->error    = NULL;
 198         priv->done     = 0;
 199         priv->total    = 0;
 200         priv->source = NULL;
 201 }
 202
 203 static void
 204 modest_mail_operation_finalize (GObject *obj)
 205 {
 206         ModestMailOperationPrivate *priv;
 207
 208         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
 209
 210         if (priv->error) {
 211                 g_error_free (priv->error);
 212                 priv->error = NULL;
 213         }
 214         if (priv->source) {
 215                 g_object_unref (priv->source);
 216                 priv->source = NULL;
 217         }
 218
 219         G_OBJECT_CLASS(parent_class)->finalize (obj);
 220 }
 221
 222 ModestMailOperation*
 223 modest_mail_operation_new (ModestMailOperationId id,
 224                            GObject *source)
 225 {
 226         ModestMailOperation *obj;
 227         ModestMailOperationPrivate *priv;
 228
 229         obj = MODEST_MAIL_OPERATION(g_object_new(MODEST_TYPE_MAIL_OPERATION, NULL));
 230         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
 231
 232         priv->id = id;
 233         if (source != NULL)
 234                 priv->source = g_object_ref(source);
 235
 236         return obj;
 237 }
 238
 239
 240 ModestMailOperationId
 241 modest_mail_operation_get_id (ModestMailOperation *self)
 242 {
 243         ModestMailOperationPrivate *priv;
 244
 245         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 246
 247         return priv->id;
 248 }
 249
 250 gboolean
 251 modest_mail_operation_is_mine (ModestMailOperation *self,
 252                                GObject *me)
 253 {
 254         ModestMailOperationPrivate *priv;
 255
 256         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 257         if (priv->source == NULL) return FALSE;
 258
 259         return priv->source == me;
 260 }
 261
 262
 263 void
 264 modest_mail_operation_send_mail (ModestMailOperation *self,
 265                                  TnyTransportAccount *transport_account,
 266                                  TnyMsg* msg)
 267 {
 268         TnySendQueue *send_queue;
 269
 270         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
 271         g_return_if_fail (TNY_IS_TRANSPORT_ACCOUNT (transport_account));
 272         g_return_if_fail (TNY_IS_MSG (msg));
 273
 274         send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
 275         if (!TNY_IS_SEND_QUEUE(send_queue))
 276                 g_printerr ("modest: could not find send queue for account\n");
 277         else {
 278                 GError *err = NULL;
 279                 tny_send_queue_add (send_queue, msg, &err);
 280                 if (err) {
 281                         g_printerr ("modest: error adding msg to send queue: %s\n",
 282                                     err->message);
 283                         g_error_free (err);
 284                 } else {
 285                         /* g_message ("modest: message added to send queue"); */
 286                 }
 287         }
 288
 289         /* Notify the queue */
 290         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 291 }
 292
 293 void
 294 modest_mail_operation_send_new_mail (ModestMailOperation *self,
 295                                      TnyTransportAccount *transport_account,
 296                                      const gchar *from,  const gchar *to,
 297                                      const gchar *cc,  const gchar *bcc,
 298                                      const gchar *subject, const gchar *plain_body,
 299                                      const gchar *html_body,
 300                                      const GList *attachments_list,
 301                                      TnyHeaderFlags priority_flags)
 302 {
 303         TnyMsg *new_msg;
 304         ModestMailOperationPrivate *priv = NULL;
 305         /* GList *node = NULL; */
 306
 307         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
 308         g_return_if_fail (TNY_IS_TRANSPORT_ACCOUNT (transport_account));
 309
 310         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 311
 312         /* Check parametters */
 313         if (to == NULL) {
 314                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 315                              MODEST_MAIL_OPERATION_ERROR_BAD_PARAMETER,
 316                              _("Error trying to send a mail. You need to set at least one recipient"));
 317                 return;
 318         }
 319
 320         if (html_body == NULL) {
 321                 new_msg = modest_tny_msg_new (to, from, cc, bcc, subject, plain_body, (GSList *) attachments_list); /* FIXME: attachments */
 322         } else {
 323                 new_msg = modest_tny_msg_new_html_plain (to, from, cc, bcc, subject, html_body, plain_body, (GSList *) attachments_list);
 324         }
 325         if (!new_msg) {
 326                 g_printerr ("modest: failed to create a new msg\n");
 327                 return;
 328         }
 329
 330         /* TODO: add priority handling. It's received in the priority_flags operator, and
 331            it should have effect in the sending operation */
 332
 333         /* Call mail operation */
 334         modest_mail_operation_send_mail (self, transport_account, new_msg);
 335
 336         /* Free */
 337         g_object_unref (G_OBJECT (new_msg));
 338 }
 339
 340 void
 341 modest_mail_operation_save_to_drafts (ModestMailOperation *self,
 342                                       TnyTransportAccount *transport_account,
 343                                       const gchar *from,  const gchar *to,
 344                                       const gchar *cc,  const gchar *bcc,
 345                                       const gchar *subject, const gchar *plain_body,
 346                                       const gchar *html_body,
 347                                       const GList *attachments_list,
 348                                       TnyHeaderFlags priority_flags)
 349 {
 350         TnyMsg *msg = NULL;
 351         TnyFolder *folder = NULL;
 352         ModestMailOperationPrivate *priv = NULL;
 353         GError *err = NULL;
 354
 355         /* GList *node = NULL; */
 356
 357         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
 358         g_return_if_fail (TNY_IS_TRANSPORT_ACCOUNT (transport_account));
 359
 360         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 361
 362         if (html_body == NULL) {
 363                 msg = modest_tny_msg_new (to, from, cc, bcc, subject, plain_body, (GSList *) attachments_list); /* FIXME: attachments */
 364         } else {
 365                 msg = modest_tny_msg_new_html_plain (to, from, cc, bcc, subject, html_body, plain_body, (GSList *) attachments_list);
 366         }
 367         if (!msg) {
 368                 g_printerr ("modest: failed to create a new msg\n");
 369                 goto cleanup;
 370         }
 371
 372         folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account), TNY_FOLDER_TYPE_DRAFTS);
 373         if (!folder) {
 374                 g_printerr ("modest: failed to find Drafts folder\n");
 375                 goto cleanup;
 376         }
 377
 378         tny_folder_add_msg (folder, msg, &err);
 379         if (err) {
 380                 g_printerr ("modest: error adding msg to Drafts folder: %s",
 381                             err->message);
 382                 g_error_free (err);
 383                 goto cleanup;
 384         }
 385
 386         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 387
 388         /* Free */
 389 cleanup:
 390         if (msg)
 391                 g_object_unref (G_OBJECT(msg));
 392         if (folder)
 393                 g_object_unref (G_OBJECT(folder));
 394 }
 395
 396 static void
 397 recurse_folders (TnyFolderStore *store, TnyFolderStoreQuery *query, TnyList *all_folders)
 398 {
 399         TnyIterator *iter;
 400         TnyList *folders = tny_simple_list_new ();
 401
 402         tny_folder_store_get_folders (store, folders, query, NULL);
 403         iter = tny_list_create_iterator (folders);
 404
 405         while (!tny_iterator_is_done (iter)) {
 406
 407                 TnyFolderStore *folder = (TnyFolderStore*) tny_iterator_get_current (iter);
 408
 409                 tny_list_prepend (all_folders, G_OBJECT (folder));
 410
 411                 recurse_folders (folder, query, all_folders);
 412
 413                 g_object_unref (G_OBJECT (folder));
 414
 415                 tny_iterator_next (iter);
 416         }
 417          g_object_unref (G_OBJECT (iter));
 418          g_object_unref (G_OBJECT (folders));
 419 }
 420
 421 static void
 422 update_folders_status_cb (GObject *obj,
 423                           TnyStatus *status,
 424                           gpointer user_data)
 425 {
 426         ModestMailOperation *self;
 427         ModestMailOperationPrivate *priv;
 428
 429         g_return_if_fail (status != NULL);
 430         g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_REFRESH);
 431
 432         /* Temporary FIX: useful when tinymail send us status
 433            information *after* calling the function callback */
 434         if (!MODEST_IS_MAIL_OPERATION (user_data))
 435                 return;
 436
 437         self = MODEST_MAIL_OPERATION (user_data);
 438         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 439
 440         priv->done = status->position;
 441         priv->total = status->of_total;
 442
 443         if (priv->done == 1 && priv->total == 100)
 444                 return;
 445
 446         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, NULL);
 447 }
 448
 449 static void
 450 update_folders_cb (TnyFolderStore *folder_store, TnyList *list, GError **err, gpointer user_data)
 451 {
 452         ModestMailOperation *self;
 453         ModestMailOperationPrivate *priv;
 454         TnyIterator *iter;
 455         TnyList *all_folders;
 456
 457         self  = MODEST_MAIL_OPERATION (user_data);
 458         priv  = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 459
 460         /* g_message (__FUNCTION__); */
 461
 462         if (*err) {
 463                 priv->error = g_error_copy (*err);
 464                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
 465                 goto out;
 466         }
 467
 468         /* Get all the folders We can do it synchronously because
 469            we're already running in a different thread than the UI */
 470         all_folders = tny_list_copy (list);
 471         iter = tny_list_create_iterator (all_folders);
 472         while (!tny_iterator_is_done (iter)) {
 473                 TnyFolderStore *folder = TNY_FOLDER_STORE (tny_iterator_get_current (iter));
 474
 475                 recurse_folders (folder, NULL, all_folders);
 476                 tny_iterator_next (iter);
 477         }
 478         g_object_unref (G_OBJECT (iter));
 479
 480         /* Refresh folders */
 481         iter = tny_list_create_iterator (all_folders);
 482         priv->total = tny_list_get_length (all_folders);
 483
 484         while (!tny_iterator_is_done (iter) && !priv->error) {
 485
 486                 TnyFolderStore *folder = TNY_FOLDER_STORE (tny_iterator_get_current (iter));
 487
 488                 /* Refresh the folder */
 489                 tny_folder_refresh (TNY_FOLDER (folder), &(priv->error));
 490
 491                 if (priv->error) {
 492                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
 493                 } else {
 494                         /* Update status and notify */
 495                         priv->done++;
 496                         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, NULL);
 497                 }
 498
 499                 g_object_unref (G_OBJECT (folder));
 500
 501                 tny_iterator_next (iter);
 502         }
 503
 504         g_object_unref (G_OBJECT (iter));
 505  out:
 506         g_object_unref (G_OBJECT (list));
 507
 508         /* Check if the operation was a success */
 509         if (priv->done == priv->total && !priv->error)
 510                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
 511
 512         /* Free */
 513         g_object_unref (G_OBJECT (folder_store));
 514
 515         /* Notify the queue */
 516         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 517 }
 518
 519 gboolean
 520 modest_mail_operation_update_account (ModestMailOperation *self,
 521                                       TnyStoreAccount *store_account)
 522 {
 523         ModestMailOperationPrivate *priv;
 524         TnyList *folders;
 525
 526         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), FALSE);
 527         g_return_val_if_fail (TNY_IS_STORE_ACCOUNT(store_account), FALSE);
 528
 529         /* Pick async call reference */
 530         g_object_ref (store_account);
 531
 532         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 533
 534         priv->total = 0;
 535         priv->done  = 0;
 536         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
 537
 538         /* Get subscribed folders & refresh them */
 539         folders = TNY_LIST (tny_simple_list_new ());
 540
 541         /* g_message ("tny_folder_store_get_folders_async"); */
 542         tny_folder_store_get_folders_async (TNY_FOLDER_STORE (store_account),
 543                                             folders, update_folders_cb, NULL, update_folders_status_cb, self);
 544
 545         return TRUE;
 546 }
 547
 548 ModestMailOperationStatus
 549 modest_mail_operation_get_status (ModestMailOperation *self)
 550 {
 551         ModestMailOperationPrivate *priv;
 552
 553         g_return_val_if_fail (self, MODEST_MAIL_OPERATION_STATUS_INVALID);
 554         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self),
 555                               MODEST_MAIL_OPERATION_STATUS_INVALID);
 556
 557         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 558         return priv->status;
 559 }
 560
 561 const GError *
 562 modest_mail_operation_get_error (ModestMailOperation *self)
 563 {
 564         ModestMailOperationPrivate *priv;
 565
 566         g_return_val_if_fail (self, NULL);
 567         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), NULL);
 568
 569         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 570         return priv->error;
 571 }
 572
 573 gboolean
 574 modest_mail_operation_cancel (ModestMailOperation *self)
 575 {
 576         ModestMailOperationPrivate *priv;
 577
 578         if (!MODEST_IS_MAIL_OPERATION (self)) {
 579                 g_warning ("%s: invalid parametter", G_GNUC_FUNCTION);
 580                 return FALSE;
 581         }
 582
 583         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 584
 585         /* TODO: Tinymail does not support cancel operation  */
 586
 587         /* Set new status */
 588         priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
 589
 590         /* Notify the queue */
 591         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 592
 593         return TRUE;
 594 }
 595
 596 guint
 597 modest_mail_operation_get_task_done (ModestMailOperation *self)
 598 {
 599         ModestMailOperationPrivate *priv;
 600
 601         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), 0);
 602
 603         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 604         return priv->done;
 605 }
 606
 607 guint
 608 modest_mail_operation_get_task_total (ModestMailOperation *self)
 609 {
 610         ModestMailOperationPrivate *priv;
 611
 612         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), 0);
 613
 614         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 615         return priv->total;
 616 }
 617
 618 gboolean
 619 modest_mail_operation_is_finished (ModestMailOperation *self)
 620 {
 621         ModestMailOperationPrivate *priv;
 622         gboolean retval = FALSE;
 623
 624         if (!MODEST_IS_MAIL_OPERATION (self)) {
 625                 g_warning ("%s: invalid parametter", G_GNUC_FUNCTION);
 626                 return retval;
 627         }
 628
 629         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 630
 631         if (priv->status == MODEST_MAIL_OPERATION_STATUS_SUCCESS   ||
 632             priv->status == MODEST_MAIL_OPERATION_STATUS_FAILED    ||
 633             priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED  ||
 634             priv->status == MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS) {
 635                 retval = TRUE;
 636         } else {
 637                 retval = FALSE;
 638         }
 639
 640         return retval;
 641 }
 642
 643 /* ******************************************************************* */
 644 /* ************************** STORE  ACTIONS ************************* */
 645 /* ******************************************************************* */
 646
 647
 648 TnyFolder *
 649 modest_mail_operation_create_folder (ModestMailOperation *self,
 650                                      TnyFolderStore *parent,
 651                                      const gchar *name)
 652 {
 653         ModestTnyFolderRules rules;
 654         ModestMailOperationPrivate *priv;
 655         TnyFolder *new_folder = NULL;
 656         gboolean can_create = FALSE;
 657
 658         g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), NULL);
 659         g_return_val_if_fail (name, NULL);
 660
 661         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 662
 663         /* Check parent */
 664         if (!TNY_IS_FOLDER (parent)) {
 665                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 666                              MODEST_MAIL_OPERATION_ERROR_BAD_PARAMETER,
 667                              _("mail_in_ui_folder_create_error"));
 668         } else {
 669                 /* Check folder rules */
 670                 rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
 671                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE)
 672                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 673                                      MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
 674                                      _("mail_in_ui_folder_create_error"));
 675                 else
 676                         can_create = TRUE;
 677         }
 678
 679         if (can_create) {
 680                 /* Create the folder */
 681                 new_folder = tny_folder_store_create_folder (parent, name, &(priv->error));
 682                 CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
 683         }
 684
 685         /* Notify the queue */
 686         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 687
 688         return new_folder;
 689 }
 690
 691 void
 692 modest_mail_operation_remove_folder (ModestMailOperation *self,
 693                                      TnyFolder           *folder,
 694                                      gboolean             remove_to_trash)
 695 {
 696         TnyAccount *account;
 697         ModestMailOperationPrivate *priv;
 698         ModestTnyFolderRules rules;
 699
 700         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
 701         g_return_if_fail (TNY_IS_FOLDER (folder));
 702
 703         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 704
 705         /* Check folder rules */
 706         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
 707         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_DELETABLE) {
 708                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 709                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
 710                              _("mail_in_ui_folder_delete_error"));
 711                 goto end;
 712         }
 713
 714         /* Get the account */
 715         account = tny_folder_get_account (folder);
 716
 717         /* Delete folder or move to trash */
 718         if (remove_to_trash) {
 719                 TnyFolder *trash_folder, *new_folder;
 720                 trash_folder = modest_tny_account_get_special_folder (account,
 721                                                                       TNY_FOLDER_TYPE_TRASH);
 722                 /* TODO: error_handling */
 723                 new_folder = modest_mail_operation_xfer_folder (self, folder,
 724                                                                 TNY_FOLDER_STORE (trash_folder), TRUE);
 725                 g_object_unref (G_OBJECT (new_folder));
 726         } else {
 727                 TnyFolderStore *parent = tny_folder_get_folder_store (folder);
 728
 729                 tny_folder_store_remove_folder (parent, folder, &(priv->error));
 730                 CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
 731
 732                 if (parent)
 733                         g_object_unref (G_OBJECT (parent));
 734         }
 735         g_object_unref (G_OBJECT (account));
 736
 737  end:
 738         /* Notify the queue */
 739         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 740 }
 741
 742 void
 743 modest_mail_operation_rename_folder (ModestMailOperation *self,
 744                                      TnyFolder *folder,
 745                                      const gchar *name)
 746 {
 747         ModestMailOperationPrivate *priv;
 748         ModestTnyFolderRules rules;
 749
 750         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
 751         g_return_if_fail (TNY_IS_FOLDER_STORE (folder));
 752         g_return_if_fail (name);
 753
 754         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 755
 756         /* Check folder rules */
 757         rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
 758         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_RENAMEABLE) {
 759                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 760                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
 761                              _("FIXME: unable to rename"));
 762         } else {
 763                 /* Rename. Camel handles folder subscription/unsubscription */
 764                 tny_folder_set_name (folder, name, &(priv->error));
 765                 CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
 766         }
 767
 768         /* Notify the queue */
 769         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 770  }
 771
 772 TnyFolder *
 773 modest_mail_operation_xfer_folder (ModestMailOperation *self,
 774                                    TnyFolder *folder,
 775                                    TnyFolderStore *parent,
 776                                    gboolean delete_original)
 777 {
 778         ModestMailOperationPrivate *priv;
 779         TnyFolder *new_folder = NULL;
 780         ModestTnyFolderRules rules;
 781
 782         g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), NULL);
 783         g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), NULL);
 784         g_return_val_if_fail (TNY_IS_FOLDER (folder), NULL);
 785
 786         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 787
 788         /* The moveable restriction is applied also to copy operation */
 789         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
 790         if (rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE) {
 791                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 792                              MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
 793                              _("FIXME: unable to rename"));
 794         } else {
 795                 /* Move/Copy folder */
 796                 new_folder = tny_folder_copy (folder,
 797                                               parent,
 798                                               tny_folder_get_name (folder),
 799                                               delete_original,
 800                                               &(priv->error));
 801         }
 802
 803         /* Notify the queue */
 804         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 805
 806         return new_folder;
 807 }
 808
 809
 810 /* ******************************************************************* */
 811 /* **************************  MSG  ACTIONS  ************************* */
 812 /* ******************************************************************* */
 813
 814 void          modest_mail_operation_get_msg     (ModestMailOperation *self,
 815                                                  TnyHeader *header,
 816                                                  GetMsgAsynUserCallback user_callback,
 817                                                  gpointer user_data)
 818 {
 819         GetMsgAsyncHelper *helper = NULL;
 820         TnyFolder *folder;
 821         ModestMailOperationPrivate *priv;
 822
 823         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
 824         g_return_if_fail (TNY_IS_HEADER (header));
 825
 826         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 827         folder = tny_header_get_folder (header);
 828
 829         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
 830
 831         /* Get message from folder */
 832         if (folder) {
 833                 helper = g_slice_new0 (GetMsgAsyncHelper);
 834                 helper->mail_op = self;
 835                 helper->user_callback = user_callback;
 836                 helper->pending_ops = 1;
 837                 helper->user_data = user_data;
 838
 839                 tny_folder_get_msg_async (folder, header, get_msg_cb, get_msg_status_cb, helper);
 840
 841                 g_object_unref (G_OBJECT (folder));
 842         } else {
 843                 /* Set status failed and set an error */
 844                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
 845                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 846                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
 847                              _("Error trying to get a message. No folder found for header"));
 848         }
 849 }
 850
 851 static void
 852 get_msg_cb (TnyFolder *folder,
 853             gboolean cancelled,
 854             TnyMsg *msg,
 855             GError **error,
 856             gpointer user_data)
 857 {
 858         GetMsgAsyncHelper *helper = NULL;
 859         ModestMailOperation *self = NULL;
 860         ModestMailOperationPrivate *priv = NULL;
 861
 862         helper = (GetMsgAsyncHelper *) user_data;
 863         g_return_if_fail (helper != NULL);
 864         self = helper->mail_op;
 865         g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
 866         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 867
 868         helper->pending_ops--;
 869
 870         /* Check errors and cancel */
 871         if (*error) {
 872                 priv->error = g_error_copy (*error);
 873                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
 874                 goto out;
 875         }
 876         if (cancelled) {
 877                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
 878                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 879                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
 880                              _("Error trying to refresh the contents of %s"),
 881                              tny_folder_get_name (folder));
 882                 goto out;
 883         }
 884
 885         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
 886
 887         /* If user defined callback function was defined, call it */
 888         if (helper->user_callback) {
 889                 helper->user_callback (priv->source, msg, helper->user_data);
 890         }
 891
 892         /* Free */
 893  out:
 894         if (helper->pending_ops == 0) {
 895                 g_slice_free (GetMsgAsyncHelper, helper);
 896
 897                 /* Notify the queue */
 898                 modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 899         }
 900 }
 901
 902 static void
 903 get_msg_status_cb (GObject *obj,
 904                    TnyStatus *status,
 905                    gpointer user_data)
 906 {
 907         GetMsgAsyncHelper *helper = NULL;
 908         ModestMailOperation *self;
 909         ModestMailOperationPrivate *priv;
 910
 911         g_return_if_fail (status != NULL);
 912         g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_GET_MSG);
 913
 914         helper = (GetMsgAsyncHelper *) user_data;
 915         g_return_if_fail (helper != NULL);
 916
 917         /* Temporary FIX: useful when tinymail send us status
 918            information *after* calling the function callback */
 919         if (!MODEST_IS_MAIL_OPERATION (helper->mail_op))
 920                 return;
 921
 922         self = helper->mail_op;
 923         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
 924
 925         priv->done += status->position;
 926         priv->total = status->of_total;
 927
 928         if (priv->done == 1 && priv->total == 100)
 929                 return;
 930
 931         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, NULL);
 932 }
 933
 934
 935 void          modest_mail_operation_process_msg     (ModestMailOperation *self,
 936                                                      TnyList *header_list,
 937                                                      GetMsgAsynUserCallback user_callback,
 938                                                      gpointer user_data)
 939 {
 940         ModestMailOperationPrivate *priv = NULL;
 941         GetMsgAsyncHelper *helper = NULL;
 942         TnyHeader *header = NULL;
 943         TnyFolder *folder = NULL;
 944         TnyIterator *iter = NULL;
 945
 946         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
 947
 948         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
 949         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
 950
 951         iter = tny_list_create_iterator (header_list);
 952         priv->total = tny_list_get_length(header_list);
 953
 954         helper = g_slice_new0 (GetMsgAsyncHelper);
 955         helper->mail_op = self;
 956         helper->user_callback = user_callback;
 957         helper->pending_ops = priv->total;
 958         helper->user_data = user_data;
 959
 960         while (!tny_iterator_is_done (iter)) {
 961
 962                 header = TNY_HEADER (tny_iterator_get_current (iter));
 963                 folder = tny_header_get_folder (header);
 964
 965                 /* Get message from folder */
 966                 if (folder) {
 967                         /* The callback will call it per each header */
 968                         tny_folder_get_msg_async (folder, header, get_msg_cb, update_process_msg_status_cb, helper);
 969                         g_object_unref (G_OBJECT (folder));
 970                 } else {
 971                         /* Set status failed and set an error */
 972                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
 973                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
 974                                      MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
 975                                      _("Error trying to get a message. No folder found for header"));
 976
 977                         /* Notify the queue */
 978                         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
 979
 980                         /* free */
 981                         g_slice_free (GetMsgAsyncHelper, helper);
 982                         break;
 983                 }
 984
 985                 g_object_unref (header);
 986                 tny_iterator_next (iter);
 987         }
 988 }
 989
 990 static void
 991 update_process_msg_status_cb (GObject *obj,
 992                               TnyStatus *status,
 993                               gpointer user_data)
 994 {
 995         GetMsgAsyncHelper *helper = NULL;
 996         ModestMailOperation *self;
 997         ModestMailOperationPrivate *priv;
 998
 999         g_return_if_fail (status != NULL);
1000         g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_GET_MSG);
1001
1002         helper = (GetMsgAsyncHelper *) user_data;
1003         g_return_if_fail (helper != NULL);
1004
1005         /* Temporary FIX: useful when tinymail send us status
1006            information *after* calling the function callback */
1007         if (!MODEST_IS_MAIL_OPERATION (helper->mail_op))
1008                 return;
1009
1010         self = helper->mail_op;
1011         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1012
1013         if (status->of_total > 0)
1014                 priv->done += status->position/status->of_total;
1015
1016         g_print("TEST: %d/%d", priv->done, priv->total);
1017
1018         if (priv->done == 1 && priv->total == 100)
1019                 return;
1020
1021         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, NULL);
1022 }
1023
1024
1025
1026 void
1027 modest_mail_operation_remove_msg (ModestMailOperation *self,
1028                                   TnyHeader *header,
1029                                   gboolean remove_to_trash)
1030 {
1031         TnyFolder *folder;
1032         ModestMailOperationPrivate *priv;
1033
1034         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
1035         g_return_if_fail (TNY_IS_HEADER (header));
1036
1037         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
1038         folder = tny_header_get_folder (header);
1039
1040         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
1041
1042         /* Delete or move to trash */
1043         if (remove_to_trash) {
1044                 TnyFolder *trash_folder;
1045                 TnyStoreAccount *store_account;
1046
1047                 store_account = TNY_STORE_ACCOUNT (tny_folder_get_account (folder));
1048                 trash_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT(store_account),
1049                                                                       TNY_FOLDER_TYPE_TRASH);
1050                 if (trash_folder) {
1051                         TnyList *headers;
1052
1053                         /* Create list */
1054                         headers = tny_simple_list_new ();
1055                         tny_list_append (headers, G_OBJECT (header));
1056                         g_object_unref (header);
1057
1058                         /* Move to trash */
1059                         modest_mail_operation_xfer_msgs (self, headers, trash_folder, TRUE);
1060                         g_object_unref (headers);
1061 /*                      g_object_unref (trash_folder); */
1062                 } else {
1063                         ModestMailOperationPrivate *priv;
1064
1065                         /* Set status failed and set an error */
1066                         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1067                         priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1068                         g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1069                                      MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1070                                      _("Error trying to delete a message. Trash folder not found"));
1071                 }
1072
1073                 g_object_unref (G_OBJECT (store_account));
1074         } else {
1075                 tny_folder_remove_msg (folder, header, &(priv->error));
1076                 if (!priv->error)
1077                         tny_folder_sync(folder, TRUE, &(priv->error));
1078         }
1079
1080         /* Set status */
1081         if (!priv->error)
1082                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1083         else
1084                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1085
1086         /* Free */
1087         g_object_unref (G_OBJECT (folder));
1088
1089         /* Notify the queue */
1090         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
1091 }
1092
1093 static void
1094 transfer_msgs_status_cb (GObject *obj,
1095                          TnyStatus *status,
1096                          gpointer user_data)
1097 {
1098 }
1099
1100
1101 static void
1102 transfer_msgs_cb (TnyFolder *folder, GError **err, gpointer user_data)
1103 {
1104         XFerMsgAsyncHelper *helper;
1105         ModestMailOperation *self;
1106         ModestMailOperationPrivate *priv;
1107
1108         helper = (XFerMsgAsyncHelper *) user_data;
1109         self = helper->mail_op;
1110
1111         priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
1112
1113         if (*err) {
1114                 priv->error = g_error_copy (*err);
1115                 priv->done = 0;
1116                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1117         } else {
1118                 priv->done = 1;
1119                 priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1120         }
1121
1122         /* Free */
1123         g_object_unref (helper->headers);
1124         g_object_unref (helper->dest_folder);
1125         g_object_unref (folder);
1126         g_free (helper);
1127
1128         /* Notify the queue */
1129         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
1130 }
1131
1132 void
1133 modest_mail_operation_xfer_msgs (ModestMailOperation *self,
1134                                  TnyList *headers,
1135                                  TnyFolder *folder,
1136                                  gboolean delete_original)
1137 {
1138         ModestMailOperationPrivate *priv;
1139         TnyIterator *iter;
1140         TnyFolder *src_folder;
1141         XFerMsgAsyncHelper *helper;
1142         TnyHeader *header;
1143
1144         g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
1145         g_return_if_fail (TNY_IS_LIST (headers));
1146         g_return_if_fail (TNY_IS_FOLDER (folder));
1147
1148         /* Pick references for async calls */
1149         g_object_ref (folder);
1150
1151         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1152         priv->total = 1;
1153         priv->done = 0;
1154         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
1155
1156         /* Create the helper */
1157         helper = g_malloc0 (sizeof (XFerMsgAsyncHelper));
1158         helper->mail_op = self;
1159         helper->dest_folder = folder;
1160         helper->headers = headers;
1161
1162         /* Get source folder */
1163         iter = tny_list_create_iterator (headers);
1164         header = TNY_HEADER (tny_iterator_get_current (iter));
1165         src_folder = tny_header_get_folder (header);
1166         g_object_unref (header);
1167         g_object_unref (iter);
1168
1169         /* Transfer messages */
1170         tny_folder_transfer_msgs_async (src_folder,
1171                                         headers,
1172                                         folder,
1173                                         delete_original,
1174                                         transfer_msgs_cb,
1175                                         transfer_msgs_status_cb,
1176                                         helper);
1177 }
1178
1179
1180 static void
1181 on_refresh_folder (TnyFolder   *folder,
1182                    gboolean     cancelled,
1183                    GError     **error,
1184                    gpointer     user_data)
1185 {
1186         ModestMailOperation *self;
1187         ModestMailOperationPrivate *priv;
1188
1189         self = MODEST_MAIL_OPERATION (user_data);
1190         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1191
1192         if (*error) {
1193                 priv->error = g_error_copy (*error);
1194                 priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
1195                 goto out;
1196         }
1197
1198         if (cancelled) {
1199                 priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
1200                 g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
1201                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1202                              _("Error trying to refresh the contents of %s"),
1203                              tny_folder_get_name (folder));
1204                 goto out;
1205         }
1206
1207         priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
1208
1209  out:
1210         /* Free */
1211         g_object_unref (folder);
1212
1213         /* Notify the queue */
1214         modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
1215 }
1216
1217 static void
1218 on_refresh_folder_status_update (GObject *obj,
1219                                  TnyStatus *status,
1220                                  gpointer user_data)
1221 {
1222         ModestMailOperation *self;
1223         ModestMailOperationPrivate *priv;
1224
1225         g_return_if_fail (status != NULL);
1226         g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_REFRESH);
1227
1228         /* Temporary FIX: useful when tinymail send us status
1229            information *after* calling the function callback */
1230         if (!MODEST_IS_MAIL_OPERATION (user_data))
1231                 return;
1232
1233         self = MODEST_MAIL_OPERATION (user_data);
1234         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1235
1236         priv->done = status->position;
1237         priv->total = status->of_total;
1238
1239         if (priv->done == 1 && priv->total == 100)
1240                 return;
1241
1242         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, NULL);
1243 }
1244
1245 void
1246 modest_mail_operation_refresh_folder  (ModestMailOperation *self,
1247                                        TnyFolder *folder)
1248 {
1249         ModestMailOperationPrivate *priv;
1250
1251         priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
1252
1253         /* Pick a reference */
1254         g_object_ref (folder);
1255
1256         priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
1257
1258         /* Refresh the folder. TODO: tinymail could issue a status
1259            updates before the callback call then this could happen. We
1260            must review the design */
1261         tny_folder_refresh_async (folder,
1262                                   on_refresh_folder,
1263                                   on_refresh_folder_status_update,
1264                                   self);
1265 }
1266
1267 void
1268 _modest_mail_operation_notify_end (ModestMailOperation *self)
1269 {
1270         g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, NULL);
1271 }