git.maemo.org Git - modest/blob - src/modest-ui-actions.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 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif /*HAVE_CONFIG_H*/
  33
  34 #include <glib/gi18n.h>
  35 #include <glib/gprintf.h>
  36 #include <string.h>
  37 #include <modest-runtime.h>
  38 #include <modest-tny-folder.h>
  39 #include <modest-tny-msg.h>
  40 #include <modest-tny-account.h>
  41 #include <modest-address-book.h>
  42 #include "modest-error.h"
  43 #include "modest-ui-actions.h"
  44
  45 #include "modest-tny-platform-factory.h"
  46 #include "modest-platform.h"
  47 #include <tny-mime-part.h>
  48 #include <tny-camel-folder.h>
  49 #include <tny-camel-imap-folder.h>
  50 #include <tny-camel-pop-folder.h>
  51
  52 #ifdef MODEST_PLATFORM_MAEMO
  53 #include "maemo/modest-osso-state-saving.h"
  54 #include "maemo/modest-maemo-utils.h"
  55 #include "maemo/modest-hildon-includes.h"
  56 #endif /* MODEST_PLATFORM_MAEMO */
  57
  58 #include "widgets/modest-ui-constants.h"
  59 #include <widgets/modest-main-window.h>
  60 #include <widgets/modest-msg-view-window.h>
  61 #include <widgets/modest-account-view-window.h>
  62 #include <widgets/modest-details-dialog.h>
  63 #include <widgets/modest-attachments-view.h>
  64 #include "widgets/modest-folder-view.h"
  65 #include "widgets/modest-global-settings-dialog.h"
  66 #include "modest-connection-specific-smtp-window.h"
  67 #include "modest-account-mgr-helpers.h"
  68 #include "modest-mail-operation.h"
  69 #include "modest-text-utils.h"
  70
  71 #ifdef MODEST_HAVE_EASYSETUP
  72 #include "easysetup/modest-easysetup-wizard.h"
  73 #endif /* MODEST_HAVE_EASYSETUP */
  74
  75 #include <modest-widget-memory.h>
  76 #include <tny-error.h>
  77 #include <tny-simple-list.h>
  78 #include <tny-msg-view.h>
  79 #include <tny-device.h>
  80 #include <tny-merge-folder.h>
  81
  82 #include <gtkhtml/gtkhtml.h>
  83
  84 typedef struct _GetMsgAsyncHelper {
  85         ModestWindow *window;
  86         ModestMailOperation *mail_op;
  87         TnyIterator *iter;
  88         guint num_ops;
  89         GFunc func;
  90         gpointer user_data;
  91 } GetMsgAsyncHelper;
  92
  93 typedef enum _ReplyForwardAction {
  94         ACTION_REPLY,
  95         ACTION_REPLY_TO_ALL,
  96         ACTION_FORWARD
  97 } ReplyForwardAction;
  98
  99 typedef struct _ReplyForwardHelper {
 100         guint reply_forward_type;
 101         ReplyForwardAction action;
 102         gchar *account_name;
 103         GtkWidget *parent_window;
 104 } ReplyForwardHelper;
 105
 106 typedef struct _PasteAsAttachmentHelper {
 107         ModestMsgEditWindow *window;
 108         GtkWidget *banner;
 109 } PasteAsAttachmentHelper;
 110
 111
 112 /*
 113  * The do_headers_action uses this kind of functions to perform some
 114  * action to each member of a list of headers
 115  */
 116 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
 117
 118 static void     do_headers_action     (ModestWindow *win,
 119                                        HeadersFunc func,
 120                                        gpointer user_data);
 121
 122 static void     open_msg_cb            (ModestMailOperation *mail_op,
 123                                         TnyHeader *header,
 124                                         TnyMsg *msg,
 125                                         gpointer user_data);
 126
 127 static void     reply_forward_cb       (ModestMailOperation *mail_op,
 128                                         TnyHeader *header,
 129                                         TnyMsg *msg,
 130                                         gpointer user_data);
 131
 132 static void     reply_forward          (ReplyForwardAction action, ModestWindow *win);
 133
 134 static void     folder_refreshed_cb    (ModestMailOperation *mail_op,
 135                                         TnyFolder *folder,
 136                                         gpointer user_data);
 137
 138 static void     _on_send_receive_progress_changed (ModestMailOperation  *mail_op,
 139                                                    ModestMailOperationState *state,
 140                                                    gpointer user_data);
 141
 142 static gboolean
 143 download_uncached_messages (TnyList *header_list, GtkWindow *win);
 144
 145
 146 static gint
 147 msgs_move_to_confirmation (GtkWindow *win,
 148                            TnyFolder *dest_folder,
 149                            gboolean delete,
 150                            TnyList *headers);
 151
 152
 153 /* Show the account creation wizard dialog.
 154  * returns: TRUE if an account was created. FALSE if the user cancelled.
 155  */
 156 gboolean
 157 modest_run_account_setup_wizard (ModestWindow *win)
 158 {
 159         gboolean result = FALSE;
 160         ModestEasysetupWizardDialog *wizard;
 161
 162         if (!win)
 163                 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
 164
 165         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 166
 167         wizard = modest_easysetup_wizard_dialog_new ();
 168         gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
 169
 170         /* Don't make this a modal window, because secondary windows will then
 171          * be unusable, freezing the UI: */
 172         /* gtk_window_set_modal (GTK_WINDOW (wizard), TRUE); */
 173
 174         gint dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
 175         if (dialog_response == GTK_RESPONSE_CANCEL)
 176                 result = FALSE;
 177         else {
 178                 /* Check whether an account was created: */
 179                 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
 180         }
 181
 182         gtk_widget_destroy (GTK_WIDGET (wizard));
 183
 184         return result;
 185 }
 186
 187
 188 void
 189 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
 190 {
 191         GtkWidget *about;
 192         const gchar *authors[] = {
 193                 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
 194                 NULL
 195         };
 196         about = gtk_about_dialog_new ();
 197         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
 198         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
 199         gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
 200                                         _("Copyright (c) 2006, Nokia Corporation\n"
 201                                           "All rights reserved."));
 202         gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
 203                                        _("a modest e-mail client\n\n"
 204                                          "design and implementation: Dirk-Jan C. Binnema\n"
 205                                          "contributions from the fine people at KC and Ig\n"
 206                                          "uses the tinymail email framework written by Philip van Hoof"));
 207         gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
 208         gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
 209         gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
 210         gtk_window_set_modal (GTK_WINDOW (about), TRUE);
 211
 212         gtk_dialog_run (GTK_DIALOG (about));
 213         gtk_widget_destroy(about);
 214 }
 215
 216 /*
 217  * Gets the list of currently selected messages. If the win is the
 218  * main window, then it returns a newly allocated list of the headers
 219  * selected in the header view. If win is the msg view window, then
 220  * the value returned is a list with just a single header.
 221  *
 222  * The caller of this funcion must free the list.
 223  */
 224 static TnyList *
 225 get_selected_headers (ModestWindow *win)
 226 {
 227         if (MODEST_IS_MAIN_WINDOW(win)) {
 228                 GtkWidget *header_view;
 229
 230                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 231                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 232                 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 233
 234         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 235                 /* for MsgViewWindows, we simply return a list with one element */
 236                 TnyHeader *header;
 237                 TnyList *list = NULL;
 238
 239                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
 240                 if (header != NULL) {
 241                         list = tny_simple_list_new ();
 242                         tny_list_prepend (list, G_OBJECT(header));
 243                         g_object_unref (G_OBJECT(header));
 244                 }
 245
 246                 return list;
 247
 248         } else
 249                 return NULL;
 250 }
 251
 252 static void
 253 headers_action_mark_as_read (TnyHeader *header,
 254                              ModestWindow *win,
 255                              gpointer user_data)
 256 {
 257         TnyHeaderFlags flags;
 258
 259         g_return_if_fail (TNY_IS_HEADER(header));
 260
 261         flags = tny_header_get_flags (header);
 262         if (flags & TNY_HEADER_FLAG_SEEN) return;
 263         tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
 264 }
 265
 266 static void
 267 headers_action_mark_as_unread (TnyHeader *header,
 268                                ModestWindow *win,
 269                                gpointer user_data)
 270 {
 271         TnyHeaderFlags flags;
 272
 273         g_return_if_fail (TNY_IS_HEADER(header));
 274
 275         flags = tny_header_get_flags (header);
 276         if (flags & TNY_HEADER_FLAG_SEEN)  {
 277                 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
 278         }
 279 }
 280
 281 /** A convenience method, because deleting a message is
 282  * otherwise complicated, and it's best to change it in one place
 283  * when we change it.
 284  */
 285 void modest_do_message_delete (TnyHeader *header, ModestWindow *win)
 286 {
 287         ModestMailOperation *mail_op = NULL;
 288         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
 289                 win ? G_OBJECT(win) : NULL);
 290         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 291                                          mail_op);
 292
 293         /* Always delete. TODO: Move to trash still not supported */
 294         modest_mail_operation_remove_msg (mail_op, header, FALSE);
 295         g_object_unref (G_OBJECT (mail_op));
 296 }
 297
 298 static void
 299 headers_action_delete (TnyHeader *header,
 300                        ModestWindow *win,
 301                        gpointer user_data)
 302 {
 303         modest_do_message_delete (header, win);
 304 }
 305
 306 /** After deleing a message that is currently visible in a window,
 307  * show the next message from the list, or close the window if there are no more messages.
 308  **/
 309 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
 310 {
 311         /* Close msg view window or select next */
 312         if (modest_msg_view_window_last_message_selected (win) &&
 313                 modest_msg_view_window_first_message_selected (win)) {
 314                 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
 315         } else {
 316                 if (!modest_msg_view_window_select_next_message (win)) {
 317                         gboolean ret_value;
 318                         g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 319                 }
 320         }
 321 }
 322
 323 void
 324 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
 325 {
 326         TnyList *header_list = NULL;
 327         TnyIterator *iter = NULL;
 328         TnyHeader *header = NULL;
 329         gchar *message = NULL;
 330         gchar *desc = NULL;
 331         gint response;
 332         ModestWindowMgr *mgr;
 333         GtkWidget *header_view = NULL;
 334
 335         g_return_if_fail (MODEST_IS_WINDOW(win));
 336
 337         /* Check first if the header view has the focus */
 338         if (MODEST_IS_MAIN_WINDOW (win)) {
 339                 header_view =
 340                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 341                                                              MODEST_WIDGET_TYPE_HEADER_VIEW);
 342                 if (!gtk_widget_is_focus (header_view))
 343                         return;
 344         }
 345
 346         /* Get the headers, either from the header view (if win is the main window),
 347          * or from the message view window: */
 348         header_list = get_selected_headers (win);
 349         if (!header_list) return;
 350
 351         /* Check if any of the headers are already opened, or in the process of being opened */
 352         if (MODEST_IS_MAIN_WINDOW (win)) {
 353                 gboolean found;
 354                 iter = tny_list_create_iterator (header_list);
 355                 found = FALSE;
 356                 mgr = modest_runtime_get_window_mgr ();
 357                 while (!tny_iterator_is_done (iter) && !found) {
 358                         header = TNY_HEADER (tny_iterator_get_current (iter));
 359                         if (header) {
 360                                 found =  modest_window_mgr_find_registered_header (mgr, header, NULL);
 361                                 g_object_unref (header);
 362                         }
 363
 364                         tny_iterator_next (iter);
 365                 }
 366                 g_object_unref (iter);
 367
 368                 if (found) {
 369                         gchar *num, *msg;
 370
 371                         num = g_strdup_printf ("%d", tny_list_get_length (header_list));
 372                         msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
 373
 374                         modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
 375
 376                         g_free (msg);
 377                         g_free (num);
 378                         g_object_unref (header_list);
 379                         return;
 380                 }
 381         }
 382
 383         /* Select message */
 384         if (tny_list_get_length(header_list) == 1) {
 385                 iter = tny_list_create_iterator (header_list);
 386                 header = TNY_HEADER (tny_iterator_get_current (iter));
 387                 if (header) {
 388                         desc = g_strdup_printf ("%s", tny_header_get_subject (header));
 389                         g_object_unref (header);
 390                 }
 391
 392                 g_object_unref (iter);
 393         }
 394         message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
 395                                            tny_list_get_length(header_list)), desc);
 396
 397         /* Confirmation dialog */
 398         printf("DEBUG: %s\n", __FUNCTION__);
 399         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
 400                                                             message);
 401
 402
 403         if (response == GTK_RESPONSE_OK) {
 404                 ModestWindow *main_window = NULL;
 405                 ModestWindowMgr *mgr = NULL;
 406                 GtkTreeModel *model = NULL;
 407                 GtkTreeSelection *sel = NULL;
 408                 GList *sel_list = NULL, *tmp = NULL;
 409                 GtkTreeRowReference *row_reference = NULL;
 410                 GtkTreePath *next_path = NULL;
 411                 TnyFolder *folder = NULL;
 412                 GError *err = NULL;
 413
 414                 /* Find last selected row */
 415                 if (MODEST_IS_MAIN_WINDOW (win)) {
 416                         model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
 417                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 418                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 419                         for (tmp=sel_list; tmp; tmp=tmp->next) {
 420                                 if (tmp->next == NULL) {
 421                                         next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
 422                                         gtk_tree_path_next (next_path);
 423                                         row_reference = gtk_tree_row_reference_new (model, next_path);
 424                                         gtk_tree_path_free (next_path);
 425                                 }
 426                         }
 427                 }
 428
 429                 /* Remove each header. If it's a view window header_view == NULL */
 430                 do_headers_action (win, headers_action_delete, header_view);
 431
 432                 /* refresh the header view (removing marked-as-deleted)*/
 433                 modest_header_view_refilter (MODEST_HEADER_VIEW(header_view));
 434
 435                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 436                         modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
 437
 438                         /* Get main window */
 439                         mgr = modest_runtime_get_window_mgr ();
 440                         main_window = modest_window_mgr_get_main_window (mgr);
 441                 }
 442                 else {
 443                         /* Move cursor to next row */
 444                         main_window = win;
 445
 446                         /* Select next row */
 447                         if (gtk_tree_row_reference_valid (row_reference)) {
 448                                 next_path = gtk_tree_row_reference_get_path (row_reference);
 449                                 gtk_tree_selection_select_path (sel, next_path);
 450                                 gtk_tree_path_free (next_path);
 451                         }
 452                         if (row_reference != NULL)
 453                                 gtk_tree_row_reference_free (row_reference);
 454                 }
 455
 456                 /* Get folder from first header and sync it */
 457                 iter = tny_list_create_iterator (header_list);
 458                 header = TNY_HEADER (tny_iterator_get_current (iter));
 459                 folder = tny_header_get_folder (header);
 460                 if (TNY_IS_CAMEL_IMAP_FOLDER (folder))
 461 /*                      tny_folder_sync_async(folder, FALSE, NULL, NULL, NULL); /\* FALSE --> don't expunge *\/ */
 462                         tny_folder_sync (folder, FALSE, &err); /* FALSE --> don't expunge */
 463                 else if (TNY_IS_CAMEL_POP_FOLDER (folder))
 464 /*                      tny_folder_sync_async(folder, FALSE, NULL, NULL, NULL); /\* TRUE --> dont expunge *\/ */
 465                         tny_folder_sync (folder, TRUE, &err); /* TRUE --> expunge */
 466                 else
 467                         /* local folders */
 468 /*                      tny_folder_sync_async(folder, TRUE, NULL, NULL, NULL); /\* TRUE --> expunge *\/ */
 469                         tny_folder_sync (folder, TRUE, &err); /* TRUE --> expunge */
 470
 471                 if (err != NULL) {
 472                         printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, err->code, err->message);
 473                         g_error_free(err);
 474                 }
 475
 476                 g_object_unref (header);
 477                 g_object_unref (iter);
 478                 g_object_unref (folder);
 479
 480                 /* Update toolbar dimming state */
 481                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
 482
 483                 /* Free */
 484                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 485                 g_list_free (sel_list);
 486         }
 487
 488         /* Free*/
 489         g_free(message);
 490         g_free(desc);
 491         g_object_unref (header_list);
 492 }
 493
 494
 495
 496
 497 /* delete either message or folder, based on where we are */
 498 void
 499 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
 500 {
 501         g_return_if_fail (MODEST_IS_WINDOW(win));
 502
 503         /* Check first if the header view has the focus */
 504         if (MODEST_IS_MAIN_WINDOW (win)) {
 505                 GtkWidget *w;
 506                 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 507                                                          MODEST_WIDGET_TYPE_FOLDER_VIEW);
 508                 if (gtk_widget_is_focus (w)) {
 509                         modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
 510                         return;
 511                 }
 512         }
 513         modest_ui_actions_on_delete_message (action, win);
 514 }
 515
 516
 517
 518 void
 519 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
 520 {
 521 #ifdef MODEST_PLATFORM_MAEMO
 522         modest_osso_save_state();
 523 #endif /* MODEST_PLATFORM_MAEMO */
 524
 525         g_debug ("closing down, clearing %d item(s) from operation queue",
 526                  modest_mail_operation_queue_num_elements
 527                  (modest_runtime_get_mail_operation_queue()));
 528
 529         /* cancel all outstanding operations */
 530         modest_mail_operation_queue_cancel_all
 531                 (modest_runtime_get_mail_operation_queue());
 532
 533         g_debug ("queue has been cleared");
 534
 535         /* note: when modest-tny-account-store is finalized,
 536            it will automatically set all network connections
 537            to offline */
 538
 539         gtk_main_quit ();
 540 }
 541
 542 void
 543 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
 544 {
 545         gboolean ret_value;
 546
 547         g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 548
 549 /*      if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
 550 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
 551 /*      } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
 552 /*              gboolean ret_value; */
 553 /*              g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
 554 /*      } else if (MODEST_IS_WINDOW (win)) { */
 555 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
 556 /*      } else { */
 557 /*              g_return_if_reached (); */
 558 /*      } */
 559 }
 560
 561 void
 562 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
 563 {
 564         GtkClipboard *clipboard = NULL;
 565         gchar *selection = NULL;
 566
 567         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 568         selection = gtk_clipboard_wait_for_text (clipboard);
 569
 570         /* Question: why is the clipboard being used here?
 571          * It doesn't really make a lot of sense. */
 572
 573         if (selection)
 574         {
 575                 modest_address_book_add_address (selection);
 576                 g_free (selection);
 577         }
 578 }
 579
 580 void
 581 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
 582 {
 583         /* This is currently only implemented for Maemo */
 584 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 585         if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
 586                 modest_run_account_setup_wizard (win);
 587                 return;
 588         } else  {
 589                 /* Show the list of accounts: */
 590                 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
 591                 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW (win));
 592
 593                 /* Don't make this a modal window, because secondary windows will then
 594                  * be unusable, freezing the UI: */
 595                 /* gtk_window_set_modal (GTK_WINDOW (account_win), TRUE); */
 596                 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
 597         }
 598 #else
 599         GtkWidget *dialog, *label;
 600
 601         /* Create the widgets */
 602
 603         dialog = gtk_dialog_new_with_buttons ("Message",
 604                                               GTK_WINDOW(win),
 605                                               GTK_DIALOG_DESTROY_WITH_PARENT,
 606                                               GTK_STOCK_OK,
 607                                               GTK_RESPONSE_NONE,
 608                                               NULL);
 609         label = gtk_label_new ("Hello World!");
 610
 611         /* Ensure that the dialog box is destroyed when the user responds. */
 612
 613         g_signal_connect_swapped (dialog, "response",
 614                                   G_CALLBACK (gtk_widget_destroy),
 615                                   dialog);
 616
 617         /* Add the label, and show everything we've added to the dialog. */
 618
 619         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
 620                            label);
 621         gtk_widget_show_all (dialog);
 622 #endif /* MODEST_PLATFORM_MAEMO */
 623 }
 624
 625 static void
 626 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
 627 {
 628         ModestWindow *main_window = MODEST_WINDOW (user_data);
 629
 630         /* Save any changes. */
 631         modest_connection_specific_smtp_window_save_server_accounts (
 632                         MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
 633                         modest_window_get_active_account (main_window));
 634         gtk_widget_destroy (GTK_WIDGET (window));
 635 }
 636
 637
 638
 639 void
 640 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
 641 {
 642         /* This is currently only implemented for Maemo,
 643          * because it requires an API (libconic) to detect different connection
 644          * possiblities.
 645          */
 646 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 647
 648         /* Create the window if necessary: */
 649         const gchar *active_account_name = modest_window_get_active_account (win);
 650
 651         /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
 652          * or show the default account?
 653          * If we show the default account then the account name should be shown in
 654          * the window when we show it. */
 655         if (!active_account_name) {
 656                 g_warning ("%s: No account is active.", __FUNCTION__);
 657                 return;
 658         }
 659
 660         GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
 661         modest_connection_specific_smtp_window_fill_with_connections (
 662                 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
 663                 modest_runtime_get_account_mgr(),
 664                 active_account_name);
 665
 666         /* Show the window: */
 667         gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
 668         gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
 669         gtk_widget_show (specific_window);
 670
 671         /* Save changes when the window is hidden: */
 672         g_signal_connect (specific_window, "hide",
 673                 G_CALLBACK (on_smtp_servers_window_hide), win);
 674 #endif /* MODEST_PLATFORM_MAEMO */
 675 }
 676
 677 void
 678 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
 679 {
 680         ModestWindow *msg_win = NULL;
 681         TnyMsg *msg = NULL;
 682         TnyFolder *folder = NULL;
 683         gchar *account_name = NULL;
 684         gchar *from_str = NULL;
 685 /*      GError *err = NULL; */
 686         TnyAccount *account = NULL;
 687         ModestWindowMgr *mgr;
 688         gchar *signature = NULL, *blank_and_signature = NULL;
 689
 690         /* if there are no accounts yet, just show the wizard */
 691         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
 692                         const gboolean created = modest_run_account_setup_wizard (win);
 693                         if (!created)
 694                                 return;
 695         }
 696
 697         account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
 698         if (!account_name)
 699                 account_name = g_strdup (modest_window_get_active_account (win));
 700         if (!account_name) {
 701                 g_printerr ("modest: no account found\n");
 702                 goto cleanup;
 703         }
 704
 705         account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
 706                                                                        account_name,
 707                                                                        TNY_ACCOUNT_TYPE_STORE);
 708         if (!account) {
 709                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
 710                 goto cleanup;
 711         }
 712
 713         from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
 714         if (!from_str) {
 715                 g_printerr ("modest: failed get from string for '%s'\n", account_name);
 716                 goto cleanup;
 717         }
 718
 719         gboolean use_signature = FALSE;
 720         signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr (), account_name, &use_signature);
 721
 722         if (use_signature) {
 723                 blank_and_signature = g_strconcat ("\n", signature, NULL);
 724         } else {
 725                 blank_and_signature = g_strdup ("");
 726         }
 727
 728         g_free (signature);
 729
 730         msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
 731         if (!msg) {
 732                 g_printerr ("modest: failed to create new msg\n");
 733                 goto cleanup;
 734         }
 735
 736         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 737         if (!folder) {
 738                 g_printerr ("modest: failed to find Drafts folder\n");
 739                 goto cleanup;
 740         }
 741
 742
 743         /* Create and register edit window */
 744         /* This is destroyed by TODO. */
 745         msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
 746         mgr = modest_runtime_get_window_mgr ();
 747         modest_window_mgr_register_window (mgr, msg_win);
 748
 749         if (win)
 750                 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
 751                                               GTK_WINDOW (win));
 752         gtk_widget_show_all (GTK_WIDGET (msg_win));
 753
 754 cleanup:
 755         g_free (account_name);
 756         g_free (from_str);
 757         g_free (blank_and_signature);
 758         if (msg_win)
 759                 g_object_unref (msg_win);
 760         if (account)
 761                 g_object_unref (G_OBJECT(account));
 762         if (msg)
 763                 g_object_unref (G_OBJECT(msg));
 764         if (folder)
 765                 g_object_unref (G_OBJECT(folder));
 766 }
 767
 768 gboolean
 769 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
 770                                        TnyHeader *header,
 771                                        TnyMsg *msg)
 772 {
 773         ModestMailOperationStatus status;
 774
 775         /* If there is no message or the operation was not successful */
 776         status = modest_mail_operation_get_status (mail_op);
 777         if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
 778
 779                 /* Remove the header from the preregistered uids */
 780                 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
 781                                                      header);
 782
 783                 return FALSE;
 784         }
 785
 786         return TRUE;
 787 }
 788
 789 static void
 790 open_msg_cb (ModestMailOperation *mail_op,
 791              TnyHeader *header,
 792              TnyMsg *msg,
 793              gpointer user_data)
 794 {
 795         ModestWindowMgr *mgr = NULL;
 796         ModestWindow *parent_win = NULL;
 797         ModestWindow *win = NULL;
 798         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
 799         gchar *account = NULL;
 800         TnyFolder *folder;
 801
 802         /* Do nothing if there was any problem with the mail
 803            operation. The error will be shown by the error_handler of
 804            the mail operation */
 805         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
 806                 return;
 807         }
 808
 809         parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
 810         folder = tny_header_get_folder (header);
 811
 812         /* Mark header as read */
 813         headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
 814
 815         /* Get account */
 816         account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
 817         if (!account)
 818                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 819
 820         /* Gets folder type (OUTBOX headers will be opened in edit window */
 821         if (modest_tny_folder_is_local_folder (folder))
 822                 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
 823
 824         /* If the header is in the drafts folder then open the editor,
 825            else the message view window */
 826         if ((folder_type == TNY_FOLDER_TYPE_DRAFTS) ||
 827             (folder_type == TNY_FOLDER_TYPE_OUTBOX)) {
 828                 /* we cannot edit without a valid account... */
 829                 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
 830                         const gboolean created = modest_run_account_setup_wizard(parent_win);
 831                         if (!created)
 832                                 goto cleanup;
 833                 }
 834                 win = modest_msg_edit_window_new (msg, account, TRUE);
 835
 836         } else {
 837                 gchar *uid = modest_tny_folder_get_header_unique_id (header);
 838
 839                 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
 840                         GtkWidget *header_view;
 841                         GtkTreeSelection *sel;
 842                         GList *sel_list = NULL;
 843                         GtkTreeModel *model;
 844
 845                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
 846                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 847
 848                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 849                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 850
 851                         if (sel_list != NULL) {
 852                                 GtkTreeRowReference *row_reference;
 853
 854                                 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
 855                                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 856                                 g_list_free (sel_list);
 857
 858                                 win = modest_msg_view_window_new_with_header_model (
 859                                                 msg, account, (const gchar*) uid,
 860                                                 model, row_reference);
 861                                 gtk_tree_row_reference_free (row_reference);
 862                         } else {
 863                                 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
 864                         }
 865                 } else {
 866                         win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
 867                 }
 868                 g_free (uid);
 869         }
 870
 871         /* Register and show new window */
 872         if (win != NULL) {
 873                 mgr = modest_runtime_get_window_mgr ();
 874                 modest_window_mgr_register_window (mgr, win);
 875                 g_object_unref (win);
 876                 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
 877                 gtk_widget_show_all (GTK_WIDGET(win));
 878         }
 879
 880         /* Update toolbar dimming state */
 881         if (MODEST_IS_MAIN_WINDOW (parent_win)) {
 882                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
 883         }
 884
 885 cleanup:
 886         /* Free */
 887         g_free(account);
 888         g_object_unref (parent_win);
 889         g_object_unref (folder);
 890 }
 891
 892 void
 893 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
 894                                                gpointer user_data)
 895 {
 896         const GError *error;
 897         GObject *win = modest_mail_operation_get_source (mail_op);
 898
 899         error = modest_mail_operation_get_error (mail_op);
 900         printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
 901
 902         if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
 903
 904                 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
 905                                                         error->message);
 906         } else {
 907                 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
 908                                                         _("mail_ni_ui_folder_get_msg_folder_error"));
 909         }
 910
 911         if (win)
 912                 g_object_unref (win);
 913 }
 914
 915 /*
 916  * This function is used by both modest_ui_actions_on_open and
 917  * modest_ui_actions_on_header_activated. This way we always do the
 918  * same when trying to open messages.
 919  */
 920 static void
 921 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
 922 {
 923         ModestWindowMgr *mgr = NULL;
 924         TnyIterator *iter = NULL;
 925         ModestMailOperation *mail_op = NULL;
 926         TnyList *not_opened_headers = NULL;
 927         TnyHeaderFlags flags = 0;
 928
 929         /* Look if we already have a message view for each header. If
 930            true, then remove the header from the list of headers to
 931            open */
 932         mgr = modest_runtime_get_window_mgr ();
 933         iter = tny_list_create_iterator (headers);
 934         not_opened_headers = tny_simple_list_new ();
 935
 936         while (!tny_iterator_is_done (iter)) {
 937
 938                 ModestWindow *window = NULL;
 939                 TnyHeader *header = NULL;
 940                 gboolean found = FALSE;
 941
 942                 header = TNY_HEADER (tny_iterator_get_current (iter));
 943                 if (header)
 944                         flags = tny_header_get_flags (header);
 945
 946                 window = NULL;
 947                 found = modest_window_mgr_find_registered_header (mgr, header, &window);
 948
 949                 /* Do not open again the message and present the
 950                    window to the user */
 951                 if (found) {
 952                         if (window)
 953                                 gtk_window_present (GTK_WINDOW (window));
 954                         else
 955                                 /* the header has been registered already, we don't do
 956                                  * anything but wait for the window to come up*/
 957                                 g_debug ("header %p already registered, waiting for window", header);
 958                 } else {
 959                         tny_list_append (not_opened_headers, G_OBJECT (header));
 960                 }
 961
 962                 if (header)
 963                         g_object_unref (header);
 964
 965                 tny_iterator_next (iter);
 966         }
 967         g_object_unref (iter);
 968         iter = NULL;
 969
 970         /* If some messages would have to be downloaded, ask the user to
 971          * make a connection. It's generally easier to do this here (in the mainloop)
 972          * than later in a thread:
 973          */
 974         if (tny_list_get_length (not_opened_headers) > 0) {
 975                 TnyIterator *iter;
 976                 gboolean found = FALSE;
 977
 978                 iter = tny_list_create_iterator (not_opened_headers);
 979                 while (!tny_iterator_is_done (iter) && !found) {
 980                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
 981                         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
 982                                 found = TRUE;
 983                         else
 984                                 tny_iterator_next (iter);
 985
 986                         g_object_unref (header);
 987                 }
 988                 g_object_unref (iter);
 989
 990                 if (found && !modest_platform_connect_and_wait (GTK_WINDOW (win), NULL)) {
 991                         g_object_unref (not_opened_headers);
 992                         return;
 993                 }
 994         }
 995
 996         /* Register the headers before actually creating the windows: */
 997         TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
 998         while (!tny_iterator_is_done (iter_not_opened)) {
 999                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
1000                 if (header) {
1001                         modest_window_mgr_register_header (mgr, header);
1002                         g_object_unref (header);
1003                 }
1004
1005                 tny_iterator_next (iter_not_opened);
1006         }
1007         g_object_unref (iter_not_opened);
1008         iter_not_opened = NULL;
1009
1010         /* Open each message */
1011         if (tny_list_get_length (not_opened_headers) > 0) {
1012                 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1013                                                                          G_OBJECT (win),
1014                                                                          modest_ui_actions_get_msgs_full_error_handler,
1015                                                                          NULL);
1016                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1017                 if (tny_list_get_length (not_opened_headers) > 1) {
1018                         modest_mail_operation_get_msgs_full (mail_op,
1019                                                              not_opened_headers,
1020                                                              open_msg_cb,
1021                                                              NULL,
1022                                                              NULL);
1023                 } else {
1024                         TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
1025                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1026                         modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
1027                         g_object_unref (header);
1028                         g_object_unref (iter);
1029                 }
1030                 g_object_unref (mail_op);
1031         }
1032
1033         /* Clean */
1034         if (not_opened_headers != NULL)
1035                 g_object_unref (not_opened_headers);
1036 }
1037
1038 void
1039 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1040 {
1041         TnyList *headers;
1042
1043         /* Get headers */
1044         headers = get_selected_headers (win);
1045         if (!headers)
1046                 return;
1047
1048         /* Open them */
1049         _modest_ui_actions_open (headers, win);
1050
1051         g_object_unref(headers);
1052 }
1053
1054
1055 static void
1056 free_reply_forward_helper (gpointer data)
1057 {
1058         ReplyForwardHelper *helper;
1059
1060         helper = (ReplyForwardHelper *) data;
1061         g_free (helper->account_name);
1062         g_slice_free (ReplyForwardHelper, helper);
1063 }
1064
1065 static void
1066 reply_forward_cb (ModestMailOperation *mail_op,
1067                   TnyHeader *header,
1068                   TnyMsg *msg,
1069                   gpointer user_data)
1070 {
1071         TnyMsg *new_msg;
1072         ReplyForwardHelper *rf_helper;
1073         ModestWindow *msg_win = NULL;
1074         ModestEditType edit_type;
1075         gchar *from = NULL;
1076         TnyAccount *account = NULL;
1077         ModestWindowMgr *mgr = NULL;
1078         gchar *signature = NULL;
1079
1080         /* If there was any error. The mail operation could be NULL,
1081            this means that we already have the message downloaded and
1082            that we didn't do a mail operation to retrieve it */
1083         if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1084                 return;
1085
1086         g_return_if_fail (user_data != NULL);
1087         rf_helper = (ReplyForwardHelper *) user_data;
1088
1089         from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1090                                                    rf_helper->account_name);
1091         if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1092                                          rf_helper->account_name,
1093                                          MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1094                 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1095                                                            rf_helper->account_name,
1096                                                            MODEST_ACCOUNT_SIGNATURE, FALSE);
1097         }
1098
1099         /* Create reply mail */
1100         switch (rf_helper->action) {
1101         case ACTION_REPLY:
1102                 new_msg =
1103                         modest_tny_msg_create_reply_msg (msg, header, from, signature,
1104                                                          rf_helper->reply_forward_type,
1105                                                          MODEST_TNY_MSG_REPLY_MODE_SENDER);
1106                 break;
1107         case ACTION_REPLY_TO_ALL:
1108                 new_msg =
1109                         modest_tny_msg_create_reply_msg (msg, header, from, signature, rf_helper->reply_forward_type,
1110                                                          MODEST_TNY_MSG_REPLY_MODE_ALL);
1111                 edit_type = MODEST_EDIT_TYPE_REPLY;
1112                 break;
1113         case ACTION_FORWARD:
1114                 new_msg =
1115                         modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1116                 edit_type = MODEST_EDIT_TYPE_FORWARD;
1117                 break;
1118         default:
1119                 g_return_if_reached ();
1120                 return;
1121         }
1122
1123         g_free (signature);
1124
1125         if (!new_msg) {
1126                 g_printerr ("modest: failed to create message\n");
1127                 goto cleanup;
1128         }
1129
1130         account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1131                                                                        rf_helper->account_name,
1132                                                                        TNY_ACCOUNT_TYPE_STORE);
1133         if (!account) {
1134                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1135                 goto cleanup;
1136         }
1137
1138         /* Create and register the windows */
1139         msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
1140         mgr = modest_runtime_get_window_mgr ();
1141         modest_window_mgr_register_window (mgr, msg_win);
1142
1143         if (rf_helper->parent_window != NULL) {
1144                 gdouble parent_zoom;
1145
1146                 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1147                 modest_window_set_zoom (msg_win, parent_zoom);
1148         }
1149
1150         /* Show edit window */
1151         gtk_widget_show_all (GTK_WIDGET (msg_win));
1152
1153 cleanup:
1154         if (msg_win)
1155                 g_object_unref (msg_win);
1156         if (new_msg)
1157                 g_object_unref (G_OBJECT (new_msg));
1158         if (account)
1159                 g_object_unref (G_OBJECT (account));
1160 /*      g_object_unref (msg); */
1161         free_reply_forward_helper (rf_helper);
1162 }
1163
1164 /*
1165  * Checks a list of headers. If any of them are not currently
1166  * downloaded (CACHED) then it asks the user for permission to
1167  * download them.
1168  *
1169  * Returns FALSE if the user does not want to download the
1170  * messages. Returns TRUE if the user allowed the download or if all
1171  * of them are currently downloaded
1172  */
1173 static gboolean
1174 download_uncached_messages (TnyList *header_list,
1175                             GtkWindow *win)
1176 {
1177         TnyIterator *iter;
1178         gboolean retval;
1179         gint uncached_messages = 0;
1180
1181         iter = tny_list_create_iterator (header_list);
1182         while (!tny_iterator_is_done (iter)) {
1183                 TnyHeader *header;
1184
1185                 header = TNY_HEADER (tny_iterator_get_current (iter));
1186                 if (header) {
1187                         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1188                                 uncached_messages ++;
1189                         g_object_unref (header);
1190                 }
1191
1192                 tny_iterator_next (iter);
1193         }
1194         g_object_unref (iter);
1195
1196         /* Ask for user permission to download the messages */
1197         retval = TRUE;
1198         if (uncached_messages > 0) {
1199                 gboolean download = TRUE;
1200                 if (!tny_device_is_online (modest_runtime_get_device())) {
1201                         GtkResponseType response =
1202                                 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1203                                                                          ngettext("mcen_nc_get_msg",
1204                                                                                   "mcen_nc_get_msgs",
1205                                                                                   uncached_messages));
1206                         if (response == GTK_RESPONSE_CANCEL) download = FALSE;
1207                 }
1208                 if (download) {
1209                         /* If a download will be necessary, make sure that we have a connection: */
1210                         retval = modest_platform_connect_and_wait(win, NULL);
1211                 } else {
1212                         retval = FALSE;
1213                 }
1214         }
1215         return retval;
1216 }
1217
1218
1219 /*
1220  * Common code for the reply and forward actions
1221  */
1222 static void
1223 reply_forward (ReplyForwardAction action, ModestWindow *win)
1224 {
1225         ModestMailOperation *mail_op = NULL;
1226         TnyList *header_list = NULL;
1227         ReplyForwardHelper *rf_helper = NULL;
1228         guint reply_forward_type;
1229         gboolean continue_download = TRUE;
1230         gboolean do_retrieve = TRUE;
1231
1232         g_return_if_fail (MODEST_IS_WINDOW(win));
1233
1234         /* we need an account when editing */
1235         if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1236                 const gboolean created = modest_run_account_setup_wizard (win);
1237                 if (!created)
1238                         return;
1239         }
1240
1241         header_list = get_selected_headers (win);
1242         if (!header_list)
1243                 return;
1244
1245         reply_forward_type =
1246                 modest_conf_get_int (modest_runtime_get_conf (),
1247                                      (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1248                                      NULL);
1249
1250         /* Check that the messages have been previously downloaded */
1251         do_retrieve = (action == ACTION_FORWARD) || (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1252         if (do_retrieve)
1253                 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
1254         if (!continue_download) {
1255                 g_object_unref (header_list);
1256                 return;
1257         }
1258
1259         /* We assume that we can only select messages of the
1260            same folder and that we reply all of them from the
1261            same account. In fact the interface currently only
1262            allows single selection */
1263
1264         /* Fill helpers */
1265         rf_helper = g_slice_new0 (ReplyForwardHelper);
1266         rf_helper->reply_forward_type = reply_forward_type;
1267         rf_helper->action = action;
1268         rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1269
1270         if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1271                 rf_helper->parent_window = GTK_WIDGET (win);
1272         if (!rf_helper->account_name)
1273                 rf_helper->account_name =
1274                         modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1275
1276         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1277                 TnyMsg *msg;
1278                 TnyHeader *header;
1279                 /* Get header and message. Do not free them here, the
1280                    reply_forward_cb must do it */
1281                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1282                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1283                 if (!msg || !header) {
1284                         if (msg)
1285                                 g_object_unref (msg);
1286                         g_printerr ("modest: no message found\n");
1287                         return;
1288                 } else {
1289                         reply_forward_cb (NULL, header, msg, rf_helper);
1290                 }
1291                 if (header)
1292                         g_object_unref (header);
1293         } else {
1294                 TnyHeader *header;
1295                 TnyIterator *iter;
1296
1297                 /* Only reply/forward to one message */
1298                 iter = tny_list_create_iterator (header_list);
1299                 header = TNY_HEADER (tny_iterator_get_current (iter));
1300                 g_object_unref (iter);
1301
1302                 if (header) {
1303                         /* Retrieve messages */
1304                         if (do_retrieve) {
1305                                 mail_op = modest_mail_operation_new_with_error_handling (
1306                                         MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1307                                         G_OBJECT(win),
1308                                         modest_ui_actions_get_msgs_full_error_handler,
1309                                         NULL);
1310                                 modest_mail_operation_queue_add (
1311                                         modest_runtime_get_mail_operation_queue (), mail_op);
1312
1313                                 modest_mail_operation_get_msg (mail_op,
1314                                                                header,
1315                                                                reply_forward_cb,
1316                                                                rf_helper);
1317                                 /* Clean */
1318                                 g_object_unref(mail_op);
1319                         } else {
1320                                 /* we put a ref here to prevent double unref as the reply
1321                                  * forward callback unrefs the header at its end */
1322                                 reply_forward_cb (NULL, header, NULL, rf_helper);
1323                         }
1324
1325
1326                         g_object_unref (header);
1327                 }
1328
1329         }
1330
1331         /* Free */
1332         g_object_unref (header_list);
1333 }
1334
1335 void
1336 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1337 {
1338         g_return_if_fail (MODEST_IS_WINDOW(win));
1339
1340         reply_forward (ACTION_REPLY, win);
1341 }
1342
1343 void
1344 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1345 {
1346         g_return_if_fail (MODEST_IS_WINDOW(win));
1347
1348         reply_forward (ACTION_FORWARD, win);
1349 }
1350
1351 void
1352 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1353 {
1354         g_return_if_fail (MODEST_IS_WINDOW(win));
1355
1356         reply_forward (ACTION_REPLY_TO_ALL, win);
1357 }
1358
1359 void
1360 modest_ui_actions_on_next (GtkAction *action,
1361                            ModestWindow *window)
1362 {
1363         if (MODEST_IS_MAIN_WINDOW (window)) {
1364                 GtkWidget *header_view;
1365
1366                 header_view = modest_main_window_get_child_widget (
1367                                 MODEST_MAIN_WINDOW(window),
1368                                 MODEST_WIDGET_TYPE_HEADER_VIEW);
1369                 if (!header_view)
1370                         return;
1371
1372                 modest_header_view_select_next (
1373                                 MODEST_HEADER_VIEW(header_view));
1374         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1375                 modest_msg_view_window_select_next_message (
1376                                 MODEST_MSG_VIEW_WINDOW (window));
1377         } else {
1378                 g_return_if_reached ();
1379         }
1380 }
1381
1382 void
1383 modest_ui_actions_on_prev (GtkAction *action,
1384                            ModestWindow *window)
1385 {
1386         g_return_if_fail (MODEST_IS_WINDOW(window));
1387
1388         if (MODEST_IS_MAIN_WINDOW (window)) {
1389                 GtkWidget *header_view;
1390                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1391                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1392                 if (!header_view)
1393                         return;
1394
1395                 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1396         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1397                 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1398         } else {
1399                 g_return_if_reached ();
1400         }
1401 }
1402
1403 void
1404 modest_ui_actions_on_sort (GtkAction *action,
1405                            ModestWindow *window)
1406 {
1407         g_return_if_fail (MODEST_IS_WINDOW(window));
1408
1409         if (MODEST_IS_MAIN_WINDOW (window)) {
1410                 GtkWidget *header_view;
1411                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1412                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1413                 if (!header_view) {
1414                         modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1415
1416                         return;
1417                 }
1418
1419                 /* Show sorting dialog */
1420                 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1421         }
1422 }
1423
1424 static void
1425 new_messages_arrived (ModestMailOperation *self,
1426                       gint new_messages,
1427                       gpointer user_data)
1428 {
1429         ModestMainWindow *win = NULL;
1430         GtkWidget *folder_view = NULL;
1431         TnyFolderStore *folder = NULL;
1432         gboolean folder_empty = FALSE;
1433
1434         g_return_if_fail (MODEST_IS_MAIN_WINDOW (user_data));
1435         win = MODEST_MAIN_WINDOW (user_data);
1436
1437         /* Set contents style of headers view */
1438         if (modest_main_window_get_contents_style (win) == MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY) {
1439                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1440                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
1441                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1442
1443
1444                 folder_empty = (tny_folder_get_all_count (TNY_FOLDER (folder)) == 0);
1445
1446                 if (!folder_empty)
1447                         modest_main_window_set_contents_style (win,
1448                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1449         }
1450
1451         /* Notify new messages have been downloaded */
1452         if (new_messages > 0)
1453                 modest_platform_on_new_msg ();
1454 }
1455
1456 /*
1457  * This function performs the send & receive required actions. The
1458  * window is used to create the mail operation. Typically it should
1459  * always be the main window, but we pass it as argument in order to
1460  * be more flexible.
1461  */
1462 void
1463 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1464 {
1465         gchar *acc_name = NULL;
1466         ModestMailOperation *mail_op;
1467
1468         /* If no account name was provided then get the current account, and if
1469            there is no current account then pick the default one: */
1470         if (!account_name) {
1471                 acc_name = g_strdup (modest_window_get_active_account(win));
1472                 if (!acc_name)
1473                         acc_name  = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1474                 if (!acc_name) {
1475                         g_printerr ("modest: cannot get default account\n");
1476                         return;
1477                 }
1478         } else {
1479                 acc_name = g_strdup (account_name);
1480         }
1481
1482         /* Set send/receive operation in progress */
1483         modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1484
1485         mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1486                                                                  G_OBJECT (win),
1487                                                                  modest_ui_actions_send_receive_error_handler,
1488                                                                  NULL);
1489
1490         g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1491                           G_CALLBACK (_on_send_receive_progress_changed),
1492                           win);
1493
1494         /* Send & receive. */
1495         /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1496         /* Receive and then send. The operation is tagged initially as
1497            a receive operation because the account update performs a
1498            receive and then a send. The operation changes its type
1499            internally, so the progress objects will receive the proper
1500            progress information */
1501         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1502         modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, win);
1503         g_object_unref (G_OBJECT (mail_op));
1504
1505         /* Free */
1506         g_free (acc_name);
1507 }
1508
1509
1510 static void
1511 modest_ui_actions_do_cancel_send (const gchar *account_name,
1512                                   ModestWindow *win)
1513 {
1514         TnyTransportAccount *transport_account;
1515         TnySendQueue *send_queue = NULL;
1516         GError *error = NULL;
1517
1518         /* Get transport account */
1519         transport_account =
1520                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1521                                       (modest_runtime_get_account_store(),
1522                                        account_name,
1523                                        TNY_ACCOUNT_TYPE_TRANSPORT));
1524         if (!transport_account) {
1525                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1526                 goto frees;
1527         }
1528
1529         /* Get send queue*/
1530         send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1531         if (!TNY_IS_SEND_QUEUE(send_queue)) {
1532                 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1533                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1534                              "modest: could not find send queue for account\n");
1535         } else {
1536                 /* Keeep messages in outbox folder */
1537                 tny_send_queue_cancel (send_queue, FALSE, &error);
1538         }
1539
1540  frees:
1541         if (transport_account != NULL)
1542                 g_object_unref (G_OBJECT (transport_account));
1543 }
1544
1545 static void
1546 modest_ui_actions_cancel_send_all (ModestWindow *win)
1547 {
1548         GSList *account_names, *iter;
1549
1550         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1551                                                           TRUE);
1552
1553         iter = account_names;
1554         while (iter) {
1555                 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1556                 iter = g_slist_next (iter);
1557         }
1558
1559         modest_account_mgr_free_account_names (account_names);
1560         account_names = NULL;
1561 }
1562
1563 void
1564 modest_ui_actions_cancel_send (GtkAction *action,  ModestWindow *win)
1565
1566 {
1567         /* Check if accounts exist */
1568         gboolean accounts_exist =
1569                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1570
1571         /* If not, allow the user to create an account before trying to send/receive. */
1572         if (!accounts_exist)
1573                 modest_ui_actions_on_accounts (NULL, win);
1574
1575         /* Cancel all sending operaitons */
1576         modest_ui_actions_cancel_send_all (win);
1577 }
1578
1579 /*
1580  * Refreshes all accounts. This function will be used by automatic
1581  * updates
1582  */
1583 void
1584 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1585 {
1586         GSList *account_names, *iter;
1587
1588         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1589                                                           TRUE);
1590
1591         iter = account_names;
1592         while (iter) {
1593                 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1594                 iter = g_slist_next (iter);
1595         }
1596
1597         modest_account_mgr_free_account_names (account_names);
1598         account_names = NULL;
1599 }
1600
1601 void
1602 modest_do_refresh_current_folder(ModestWindow *win)
1603 {
1604         /* Refresh currently selected folder. Note that if we only
1605            want to retreive the headers, then the refresh only will
1606            invoke a poke_status over all folders, i.e., only the
1607            total/unread count will be updated */
1608         if (MODEST_IS_MAIN_WINDOW (win)) {
1609                 GtkWidget *header_view, *folder_view;
1610                 TnyFolderStore *folder_store;
1611
1612                 /* Get folder and header view */
1613                 folder_view =
1614                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1615                                                              MODEST_WIDGET_TYPE_FOLDER_VIEW);
1616
1617                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1618
1619                 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1620                         header_view =
1621                                 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1622                                                                      MODEST_WIDGET_TYPE_HEADER_VIEW);
1623
1624                         /* We do not need to set the contents style
1625                            because it hasn't changed. We also do not
1626                            need to save the widget status. Just force
1627                            a refresh */
1628                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1629                                                        TNY_FOLDER (folder_store),
1630                                                        folder_refreshed_cb,
1631                                                        MODEST_MAIN_WINDOW (win));
1632                 }
1633
1634                 if (folder_store)
1635                         g_object_unref (folder_store);
1636         }
1637 }
1638
1639
1640 /*
1641  * Handler of the click on Send&Receive button in the main toolbar
1642  */
1643 void
1644 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1645 {
1646         /* Check if accounts exist */
1647         gboolean accounts_exist =
1648                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1649
1650         /* If not, allow the user to create an account before trying to send/receive. */
1651         if (!accounts_exist)
1652                 modest_ui_actions_on_accounts (NULL, win);
1653
1654         modest_do_refresh_current_folder (win);
1655
1656         /* Refresh the active account */
1657         modest_ui_actions_do_send_receive (NULL, win);
1658 }
1659
1660
1661 void
1662 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1663 {
1664         ModestConf *conf;
1665         GtkWidget *header_view;
1666
1667         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1668
1669         header_view = modest_main_window_get_child_widget (main_window,
1670                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1671         if (!header_view)
1672                 return;
1673
1674         conf = modest_runtime_get_conf ();
1675
1676         /* what is saved/restored is depending on the style; thus; we save with
1677          * old style, then update the style, and restore for this new style
1678          */
1679         modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1680
1681         if (modest_header_view_get_style
1682             (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1683                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1684                                               MODEST_HEADER_VIEW_STYLE_TWOLINES);
1685         else
1686                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1687                                               MODEST_HEADER_VIEW_STYLE_DETAILS);
1688
1689         modest_widget_memory_restore (conf, G_OBJECT(header_view),
1690                                       MODEST_CONF_HEADER_VIEW_KEY);
1691 }
1692
1693
1694 void
1695 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1696                                       TnyHeader *header,
1697                                       ModestMainWindow *main_window)
1698 {
1699         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1700         g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1701
1702         /* in the case the folder is empty, show the empty folder message and focus
1703          * folder view */
1704         if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
1705                 if (modest_header_view_is_empty (header_view)) {
1706                         TnyFolder *folder = modest_header_view_get_folder (header_view);
1707                         GtkWidget *folder_view =
1708                                 modest_main_window_get_child_widget (main_window,
1709                                                                      MODEST_WIDGET_TYPE_FOLDER_VIEW);
1710                         if (folder != NULL)
1711                                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
1712                         gtk_widget_grab_focus (GTK_WIDGET (folder_view));
1713                         return;
1714                 }
1715         }
1716         /* If no header has been selected then exit */
1717         if (!header)
1718                 return;
1719
1720         /* Update focus */
1721         if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1722             gtk_widget_grab_focus (GTK_WIDGET(header_view));
1723
1724         /* Update Main window title */
1725         if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1726                 const gchar *subject = tny_header_get_subject (header);
1727                 if (subject && strlen(subject) > 0)
1728                         gtk_window_set_title (GTK_WINDOW (main_window), subject);
1729                 else
1730                         gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1731         }
1732
1733         /* Update toolbar dimming state */
1734         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1735 }
1736
1737 void
1738 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1739                                        TnyHeader *header,
1740                                        ModestMainWindow *main_window)
1741 {
1742         TnyList *headers;
1743
1744         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1745
1746         if (!header)
1747                 return;
1748
1749         headers = tny_simple_list_new ();
1750         tny_list_prepend (headers, G_OBJECT (header));
1751
1752         _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1753
1754         g_object_unref (headers);
1755 }
1756
1757 static void
1758 set_active_account_from_tny_account (TnyAccount *account,
1759                                      ModestWindow *window)
1760 {
1761         const gchar *server_acc_name = tny_account_get_id (account);
1762
1763         /* We need the TnyAccount provided by the
1764            account store because that is the one that
1765            knows the name of the Modest account */
1766         TnyAccount *modest_server_account = modest_server_account =
1767                 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1768                                                              MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1769                                                              server_acc_name);
1770
1771         const gchar *modest_acc_name =
1772                 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1773         modest_window_set_active_account (window, modest_acc_name);
1774         g_object_unref (modest_server_account);
1775 }
1776
1777
1778 static void
1779 folder_refreshed_cb (ModestMailOperation *mail_op,
1780                      TnyFolder *folder,
1781                      gpointer user_data)
1782 {
1783         ModestMainWindow *win = NULL;
1784         GtkWidget *header_view;
1785         TnyFolder *current_folder;
1786         gboolean folder_empty = TRUE;
1787         gboolean all_marked_as_deleted = TRUE;
1788
1789         g_return_if_fail (TNY_IS_FOLDER (folder));
1790
1791         win = MODEST_MAIN_WINDOW (user_data);
1792         header_view =
1793                 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1794
1795         if (header_view) {
1796                 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
1797                 if (current_folder != NULL && folder != current_folder) {
1798                         return;
1799                 }
1800         }
1801
1802         /* Check if folder is empty and set headers view contents style */
1803         folder_empty = (tny_folder_get_all_count (folder) == 0);
1804         all_marked_as_deleted = modest_header_view_is_empty (MODEST_HEADER_VIEW(header_view));
1805         folder_empty = folder_empty || all_marked_as_deleted ;
1806         if (folder_empty) {
1807
1808         printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1809                 modest_main_window_set_contents_style (win,
1810                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1811         } else {
1812                 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1813         }
1814 }
1815
1816 void
1817 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1818                                                TnyFolderStore *folder_store,
1819                                                gboolean selected,
1820                                                ModestMainWindow *main_window)
1821 {
1822         ModestConf *conf;
1823         GtkWidget *header_view;
1824
1825         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1826
1827         header_view = modest_main_window_get_child_widget(main_window,
1828                                                           MODEST_WIDGET_TYPE_HEADER_VIEW);
1829         if (!header_view)
1830                 return;
1831
1832         conf = modest_runtime_get_conf ();
1833
1834         if (TNY_IS_ACCOUNT (folder_store)) {
1835                 if (selected) {
1836                         /* Update active account */
1837                         set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1838                         /* Show account details */
1839                         modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1840                 }
1841         } else {
1842                 if (TNY_IS_FOLDER (folder_store) && selected) {
1843
1844                         /* Update the active account */
1845                         TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1846                         if (account) {
1847                                 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1848                                 g_object_unref (account);
1849                                 account = NULL;
1850                         }
1851
1852                         /* Set the header style by default, it could
1853                            be changed later by the refresh callback to
1854                            empty */
1855                         modest_main_window_set_contents_style (main_window,
1856                                                                MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1857
1858                         /* Set folder on header view. This function
1859                            will call tny_folder_refresh_async so we
1860                            pass a callback that will be called when
1861                            finished. We use that callback to set the
1862                            empty view if there are no messages */
1863                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1864                                                        TNY_FOLDER (folder_store),
1865                                                        folder_refreshed_cb,
1866                                                        main_window);
1867
1868                         /* Restore configuration. We need to do this
1869                            *after* the set_folder because the widget
1870                            memory asks the header view about its
1871                            folder  */
1872                         modest_widget_memory_restore (modest_runtime_get_conf (),
1873                                                       G_OBJECT(header_view),
1874                                                       MODEST_CONF_HEADER_VIEW_KEY);
1875                 } else {
1876                         /* Update the active account */
1877                         modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1878                         /* Save only if we're seeing headers */
1879                         if (modest_main_window_get_contents_style (main_window) ==
1880                             MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1881                                 modest_widget_memory_save (conf, G_OBJECT (header_view),
1882                                                            MODEST_CONF_HEADER_VIEW_KEY);
1883                         modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1884                 }
1885         }
1886
1887         /* Update toolbar dimming state */
1888         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1889 }
1890
1891 void
1892 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1893                                      ModestWindow *win)
1894 {
1895         GtkWidget *dialog;
1896         gchar *txt, *item;
1897         gboolean online;
1898
1899         item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1900
1901         online = tny_device_is_online (modest_runtime_get_device());
1902
1903         if (online) {
1904                 /* already online -- the item is simply not there... */
1905                 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1906                                                  GTK_DIALOG_MODAL,
1907                                                  GTK_MESSAGE_WARNING,
1908                                                  GTK_BUTTONS_OK,
1909                                                  _("The %s you selected cannot be found"),
1910                                                  item);
1911                 gtk_dialog_run (GTK_DIALOG(dialog));
1912         } else {
1913                 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1914                                                       GTK_WINDOW (win),
1915                                                       GTK_DIALOG_MODAL,
1916                                                       GTK_STOCK_CANCEL,
1917                                                       GTK_RESPONSE_REJECT,
1918                                                       GTK_STOCK_OK,
1919                                                       GTK_RESPONSE_ACCEPT,
1920                                                       NULL);
1921                 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1922                                          "Do you want to get online?"), item);
1923                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1924                                     gtk_label_new (txt), FALSE, FALSE, 0);
1925                 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1926                 g_free (txt);
1927
1928                 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1929                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1930                         /* TODO: Comment about why is this commented out: */
1931                         /* modest_platform_connect_and_wait (); */
1932                 }
1933         }
1934         gtk_widget_destroy (dialog);
1935 }
1936
1937 void
1938 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1939                                      ModestWindow *win)
1940 {
1941         /* g_message ("%s %s", __FUNCTION__, link); */
1942 }
1943
1944
1945 void
1946 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1947                                         ModestWindow *win)
1948 {
1949         modest_platform_activate_uri (link);
1950 }
1951
1952 void
1953 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1954                                           ModestWindow *win)
1955 {
1956         modest_platform_show_uri_popup (link);
1957 }
1958
1959 void
1960 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1961                                              ModestWindow *win)
1962 {
1963         modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1964 }
1965
1966 void
1967 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1968                                           const gchar *address,
1969                                           ModestWindow *win)
1970 {
1971         /* g_message ("%s %s", __FUNCTION__, address); */
1972 }
1973
1974 void
1975 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1976 {
1977         TnyTransportAccount *transport_account;
1978         ModestMailOperation *mail_operation;
1979         MsgData *data;
1980         gchar *account_name, *from;
1981         ModestAccountMgr *account_mgr;
1982         gchar *info_text = NULL;
1983
1984         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1985
1986         data = modest_msg_edit_window_get_msg_data (edit_window);
1987
1988         account_mgr = modest_runtime_get_account_mgr();
1989         account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1990         if (!account_name)
1991                 account_name = modest_account_mgr_get_default_account (account_mgr);
1992         if (!account_name) {
1993                 g_printerr ("modest: no account found\n");
1994                 modest_msg_edit_window_free_msg_data (edit_window, data);
1995                 return;
1996         }
1997
1998         if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1999                 account_name = g_strdup (data->account_name);
2000         }
2001
2002         transport_account =
2003                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2004                                       (modest_runtime_get_account_store(),
2005                                        account_name,
2006                                        TNY_ACCOUNT_TYPE_TRANSPORT));
2007         if (!transport_account) {
2008                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2009                 g_free (account_name);
2010                 modest_msg_edit_window_free_msg_data (edit_window, data);
2011                 return;
2012         }
2013         from = modest_account_mgr_get_from_string (account_mgr, account_name);
2014
2015         /* Create the mail operation */
2016         mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
2017         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2018
2019         modest_mail_operation_save_to_drafts (mail_operation,
2020                                               transport_account,
2021                                               data->draft_msg,
2022                                               edit_window,
2023                                               from,
2024                                               data->to,
2025                                               data->cc,
2026                                               data->bcc,
2027                                               data->subject,
2028                                               data->plain_body,
2029                                               data->html_body,
2030                                               data->attachments,
2031                                               data->priority_flags);
2032         /* Frees */
2033         g_free (from);
2034         g_free (account_name);
2035         g_object_unref (G_OBJECT (transport_account));
2036         g_object_unref (G_OBJECT (mail_operation));
2037
2038         modest_msg_edit_window_free_msg_data (edit_window, data);
2039
2040         info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
2041         modest_platform_information_banner (NULL, NULL, info_text);
2042         g_free (info_text);
2043 }
2044
2045 /* For instance, when clicking the Send toolbar button when editing a message: */
2046 void
2047 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2048 {
2049         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
2050
2051         if (!modest_msg_edit_window_check_names (edit_window, TRUE))
2052                 return;
2053
2054         /* Offer the connection dialog, if necessary: */
2055         if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window), NULL))
2056                 return;
2057
2058         /* FIXME: Code added just for testing. The final version will
2059            use the send queue provided by tinymail and some
2060            classifier */
2061         ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
2062         gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2063         if (!account_name)
2064                 account_name = modest_account_mgr_get_default_account (account_mgr);
2065
2066         if (!account_name) {
2067                 /* Run account setup wizard */
2068                 const gboolean created = modest_run_account_setup_wizard(MODEST_WINDOW(edit_window));
2069                 if (!created)
2070                         return;
2071         }
2072
2073         MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
2074
2075         if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2076                 account_name = g_strdup (data->account_name);
2077         }
2078
2079         /* Get the currently-active transport account for this modest account: */
2080         TnyTransportAccount *transport_account =
2081                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
2082                                       (modest_runtime_get_account_store(),
2083                                        account_name));
2084         if (!transport_account) {
2085                 /* Run account setup wizard */
2086                 const gboolean created = modest_run_account_setup_wizard(MODEST_WINDOW(edit_window));
2087                 if (!created)
2088                         return;
2089         }
2090
2091         gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
2092
2093         /* mail content checks and dialogs */
2094         if (data->subject == NULL || data->subject[0] == '\0') {
2095                 GtkResponseType response;
2096                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
2097                                                                     _("mcen_nc_subject_is_empty_send"));
2098                 if (response == GTK_RESPONSE_CANCEL) {
2099                         g_free (account_name);
2100                         return;
2101                 }
2102         }
2103
2104         if (data->plain_body == NULL || data->plain_body[0] == '\0') {
2105                 GtkResponseType response;
2106                 gchar *note_message;
2107                 gchar *note_subject = data->subject;
2108                 if (note_subject == NULL || note_subject[0] == '\0')
2109                         note_subject = _("mail_va_no_subject");
2110                 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
2111                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
2112                                                                     note_message);
2113                 g_free (note_message);
2114                 if (response == GTK_RESPONSE_CANCEL) {
2115                         g_free (account_name);
2116                         return;
2117                 }
2118         }
2119
2120         modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
2121
2122         /* Create the mail operation */
2123         ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
2124         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2125
2126         modest_mail_operation_send_new_mail (mail_operation,
2127                                              transport_account,
2128                                              data->draft_msg,
2129                                              from,
2130                                              data->to,
2131                                              data->cc,
2132                                              data->bcc,
2133                                              data->subject,
2134                                              data->plain_body,
2135                                              data->html_body,
2136                                              data->attachments,
2137                                              data->priority_flags);
2138
2139         /* Free data: */
2140         g_free (from);
2141         g_free (account_name);
2142         g_object_unref (G_OBJECT (transport_account));
2143         g_object_unref (G_OBJECT (mail_operation));
2144
2145         modest_msg_edit_window_free_msg_data (edit_window, data);
2146         modest_msg_edit_window_set_sent (edit_window, TRUE);
2147
2148         /* Save settings and close the window: */
2149         modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2150 }
2151
2152 void
2153 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2154                                   ModestMsgEditWindow *window)
2155 {
2156         ModestMsgEditFormatState *format_state = NULL;
2157
2158         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2159         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2160
2161         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2162                 return;
2163
2164         format_state = modest_msg_edit_window_get_format_state (window);
2165         g_return_if_fail (format_state != NULL);
2166
2167         format_state->bold = gtk_toggle_action_get_active (action);
2168         modest_msg_edit_window_set_format_state (window, format_state);
2169         g_free (format_state);
2170
2171 }
2172
2173 void
2174 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2175                                      ModestMsgEditWindow *window)
2176 {
2177         ModestMsgEditFormatState *format_state = NULL;
2178
2179         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2180         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2181
2182         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2183                 return;
2184
2185         format_state = modest_msg_edit_window_get_format_state (window);
2186         g_return_if_fail (format_state != NULL);
2187
2188         format_state->italics = gtk_toggle_action_get_active (action);
2189         modest_msg_edit_window_set_format_state (window, format_state);
2190         g_free (format_state);
2191
2192 }
2193
2194 void
2195 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2196                                      ModestMsgEditWindow *window)
2197 {
2198         ModestMsgEditFormatState *format_state = NULL;
2199
2200         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2201         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2202
2203         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2204                 return;
2205
2206         format_state = modest_msg_edit_window_get_format_state (window);
2207         g_return_if_fail (format_state != NULL);
2208
2209         format_state->bullet = gtk_toggle_action_get_active (action);
2210         modest_msg_edit_window_set_format_state (window, format_state);
2211         g_free (format_state);
2212
2213 }
2214
2215 void
2216 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2217                                      GtkRadioAction *selected,
2218                                      ModestMsgEditWindow *window)
2219 {
2220         ModestMsgEditFormatState *format_state = NULL;
2221         GtkJustification value;
2222
2223         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2224
2225         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2226                 return;
2227
2228         value = gtk_radio_action_get_current_value (selected);
2229
2230         format_state = modest_msg_edit_window_get_format_state (window);
2231         g_return_if_fail (format_state != NULL);
2232
2233         format_state->justification = value;
2234         modest_msg_edit_window_set_format_state (window, format_state);
2235         g_free (format_state);
2236 }
2237
2238 void
2239 modest_ui_actions_on_select_editor_color (GtkAction *action,
2240                                           ModestMsgEditWindow *window)
2241 {
2242         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2243         g_return_if_fail (GTK_IS_ACTION (action));
2244
2245         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2246                 return;
2247
2248         modest_msg_edit_window_select_color (window);
2249 }
2250
2251 void
2252 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2253                                                      ModestMsgEditWindow *window)
2254 {
2255         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2256         g_return_if_fail (GTK_IS_ACTION (action));
2257
2258         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2259                 return;
2260
2261         modest_msg_edit_window_select_background_color (window);
2262 }
2263
2264 void
2265 modest_ui_actions_on_insert_image (GtkAction *action,
2266                                    ModestMsgEditWindow *window)
2267 {
2268         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2269         g_return_if_fail (GTK_IS_ACTION (action));
2270
2271         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2272                 return;
2273
2274         modest_msg_edit_window_insert_image (window);
2275 }
2276
2277 void
2278 modest_ui_actions_on_attach_file (GtkAction *action,
2279                                   ModestMsgEditWindow *window)
2280 {
2281         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2282         g_return_if_fail (GTK_IS_ACTION (action));
2283
2284         modest_msg_edit_window_offer_attach_file (window);
2285 }
2286
2287 void
2288 modest_ui_actions_on_remove_attachments (GtkAction *action,
2289                                          ModestMsgEditWindow *window)
2290 {
2291         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2292         g_return_if_fail (GTK_IS_ACTION (action));
2293
2294         modest_msg_edit_window_remove_attachments (window, NULL);
2295 }
2296
2297 static void
2298 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2299                                             gpointer user_data)
2300 {
2301         ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2302         const GError *error = modest_mail_operation_get_error (mail_op);
2303
2304         if(error)
2305         {
2306                 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2307                                                     modest_mail_operation_get_error (mail_op)->message);
2308         }
2309 }
2310
2311 static void
2312 modest_ui_actions_create_folder(GtkWidget *parent_window,
2313                                 GtkWidget *folder_view)
2314 {
2315         TnyFolderStore *parent_folder;
2316
2317         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2318
2319         if (parent_folder) {
2320                 gboolean finished = FALSE;
2321                 gint result;
2322                 gchar *folder_name = NULL, *suggested_name = NULL;
2323                 const gchar *proto_str = NULL;
2324                 TnyAccount *account;
2325
2326                 if (TNY_IS_ACCOUNT (parent_folder))
2327                         account = g_object_ref (parent_folder);
2328                 else
2329                         account = tny_folder_get_account (TNY_FOLDER (parent_folder));
2330                 proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2331
2332                 if (proto_str && modest_protocol_info_get_transport_store_protocol (proto_str) ==
2333                     MODEST_PROTOCOL_STORE_POP) {
2334                         finished = TRUE;
2335                         hildon_banner_show_information (NULL, NULL, _("mail_in_ui_folder_create_error"));
2336                 }
2337                 g_object_unref (account);
2338
2339                 /* Run the new folder dialog */
2340                 while (!finished) {
2341                         result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2342                                                                         parent_folder,
2343                                                                         suggested_name,
2344                                                                         &folder_name);
2345
2346                         g_free (suggested_name);
2347                         suggested_name = NULL;
2348
2349                         if (result == GTK_RESPONSE_REJECT) {
2350                                 finished = TRUE;
2351                         } else {
2352                                 ModestMailOperation *mail_op;
2353                                 TnyFolder *new_folder = NULL;
2354
2355                                 mail_op  = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2356                                                                                           G_OBJECT(parent_window),
2357                                                                                           modest_ui_actions_new_folder_error_handler,
2358                                                                                           parent_window);
2359
2360                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2361                                                                  mail_op);
2362                                 new_folder = modest_mail_operation_create_folder (mail_op,
2363                                                                                   parent_folder,
2364                                                                                   (const gchar *) folder_name);
2365                                 if (new_folder) {
2366                                         modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2367                                                                           new_folder, TRUE);
2368
2369                                         g_object_unref (new_folder);
2370                                         finished = TRUE;
2371                                 }
2372                                 g_object_unref (mail_op);
2373                         }
2374
2375                         suggested_name = folder_name;
2376                         folder_name = NULL;
2377                 }
2378
2379                 g_object_unref (parent_folder);
2380         }
2381 }
2382
2383 void
2384 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2385 {
2386         GtkWidget *folder_view;
2387
2388         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2389
2390         folder_view = modest_main_window_get_child_widget (main_window,
2391                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2392         if (!folder_view)
2393                 return;
2394
2395         modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2396 }
2397
2398 static void
2399 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2400                                                gpointer user_data)
2401 {
2402         ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2403         const GError *error = NULL;
2404         const gchar *message = NULL;
2405
2406         /* Get error message */
2407         error = modest_mail_operation_get_error (mail_op);
2408         if (error != NULL && error->message != NULL) {
2409                 message = error->message;
2410         } else {
2411                 message = _("!!! FIXME: Unable to rename");
2412         }
2413
2414         modest_platform_information_banner (GTK_WIDGET (window), NULL,
2415                                             message);
2416 }
2417
2418 void
2419 modest_ui_actions_on_rename_folder (GtkAction *action,
2420                                      ModestMainWindow *main_window)
2421 {
2422         TnyFolderStore *folder;
2423         GtkWidget *folder_view;
2424         GtkWidget *header_view;
2425
2426         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2427
2428         folder_view = modest_main_window_get_child_widget (main_window,
2429                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2430         if (!folder_view)
2431                 return;
2432
2433         header_view = modest_main_window_get_child_widget (main_window,
2434                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2435
2436         if (!header_view)
2437                 return;
2438
2439         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2440         if (!folder)
2441                 return;
2442
2443         /* Offer the connection dialog if necessary: */
2444         if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2445                 g_object_unref (G_OBJECT (folder));
2446                 return;
2447         }
2448
2449
2450         if (TNY_IS_FOLDER (folder)) {
2451                 gchar *folder_name;
2452                 gint response;
2453                 const gchar *current_name;
2454
2455                 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2456                 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2457                                                                      current_name, &folder_name);
2458
2459                 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2460                         ModestMailOperation *mail_op;
2461
2462                         mail_op =
2463                                 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2464                                                                                G_OBJECT(main_window),
2465                                                                                modest_ui_actions_rename_folder_error_handler,
2466                                                                                main_window);
2467
2468                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2469                                                          mail_op);
2470
2471                         modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2472
2473                         modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2474                                                           TNY_FOLDER(folder), TRUE);
2475
2476                         modest_header_view_clear ((ModestHeaderView *) header_view);
2477
2478                         modest_mail_operation_rename_folder (mail_op,
2479                                                              TNY_FOLDER (folder),
2480                                                              (const gchar *) folder_name);
2481
2482                         g_object_unref (mail_op);
2483                         g_free (folder_name);
2484                 }
2485         }
2486         g_object_unref (folder);
2487 }
2488
2489 static void
2490 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2491                                                gpointer user_data)
2492 {
2493         GObject *win = modest_mail_operation_get_source (mail_op);
2494
2495         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2496                                                 _("mail_in_ui_folder_delete_error"));
2497         g_object_unref (win);
2498 }
2499
2500 static void
2501 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2502 {
2503         TnyFolderStore *folder;
2504         GtkWidget *folder_view;
2505         gint response;
2506         gchar *message;
2507
2508         g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2509
2510         folder_view = modest_main_window_get_child_widget (main_window,
2511                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2512         if (!folder_view)
2513                 return;
2514
2515         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2516
2517         /* Show an error if it's an account */
2518         if (!TNY_IS_FOLDER (folder)) {
2519                 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2520                                                         _("mail_in_ui_folder_delete_error"));
2521                 g_object_unref (G_OBJECT (folder));
2522                 return ;
2523         }
2524
2525         /* Offer the connection dialog if necessary: */
2526         if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2527                 g_object_unref (G_OBJECT (folder));
2528                 return;
2529         }
2530
2531         /* Ask the user */
2532         message =  g_strdup_printf (_("mcen_nc_delete_folder_text"),
2533                                     tny_folder_get_name (TNY_FOLDER (folder)));
2534         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2535                                                             (const gchar *) message);
2536         g_free (message);
2537
2538         if (response == GTK_RESPONSE_OK) {
2539                 ModestMailOperation *mail_op =
2540                         modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2541                                                                        G_OBJECT(main_window),
2542                                                                        modest_ui_actions_delete_folder_error_handler,
2543                                                                        NULL);
2544
2545                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2546                                                  mail_op);
2547                 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2548                 g_object_unref (G_OBJECT (mail_op));
2549         }
2550
2551         g_object_unref (G_OBJECT (folder));
2552 }
2553
2554 void
2555 modest_ui_actions_on_delete_folder (GtkAction *action,
2556                                      ModestMainWindow *main_window)
2557 {
2558         GtkWidget *folder_view;
2559         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2560
2561         delete_folder (main_window, FALSE);
2562         folder_view = modest_main_window_get_child_widget (main_window,
2563                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2564         if (!folder_view)
2565                 return;
2566         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
2567 }
2568
2569 void
2570 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2571 {
2572         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2573
2574         delete_folder (main_window, TRUE);
2575 }
2576
2577
2578 static void
2579 show_error (GtkWidget *parent_widget, const gchar* text)
2580 {
2581         hildon_banner_show_information(parent_widget, NULL, text);
2582
2583 #if 0
2584         GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); */
2585         /*
2586           GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
2587           (GtkDialogFlags)0,
2588           GTK_MESSAGE_ERROR,
2589           GTK_BUTTONS_OK,
2590           text ));
2591         */
2592
2593         gtk_dialog_run (dialog);
2594         gtk_widget_destroy (GTK_WIDGET (dialog));
2595 #endif
2596 }
2597
2598 void
2599 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2600                                          const gchar* server_account_name,
2601                                          gchar **username,
2602                                          gchar **password,
2603                                          gboolean *cancel,
2604                                          gboolean *remember,
2605                                          ModestMainWindow *main_window)
2606 {
2607         g_return_if_fail(server_account_name);
2608         /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2609
2610         /* Initalize output parameters: */
2611         if (cancel)
2612                 *cancel = FALSE;
2613
2614         if (remember)
2615                 *remember = TRUE;
2616
2617 #ifdef MODEST_PLATFORM_MAEMO
2618         /* Maemo uses a different (awkward) button order,
2619          * It should probably just use gtk_alternative_dialog_button_order ().
2620          */
2621         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2622                                               NULL,
2623                                               GTK_DIALOG_MODAL,
2624                                               GTK_STOCK_OK,
2625                                               GTK_RESPONSE_ACCEPT,
2626                                               GTK_STOCK_CANCEL,
2627                                               GTK_RESPONSE_REJECT,
2628                                               NULL);
2629 #else
2630         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2631                                               NULL,
2632                                               GTK_DIALOG_MODAL,
2633                                               GTK_STOCK_CANCEL,
2634                                               GTK_RESPONSE_REJECT,
2635                                               GTK_STOCK_OK,
2636                                               GTK_RESPONSE_ACCEPT,
2637                                               NULL);
2638 #endif /* MODEST_PLATFORM_MAEMO */
2639
2640         gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2641
2642         gchar *server_name = modest_server_account_get_hostname (
2643                 modest_runtime_get_account_mgr(), server_account_name);
2644         if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2645                 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2646                 *cancel = TRUE;
2647                 return;
2648         }
2649
2650         /* This causes a warning because the logical ID has no %s in it,
2651          * though the translation does, but there is not much we can do about that: */
2652         gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2653         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2654                             FALSE, FALSE, 0);
2655         g_free (txt);
2656         g_free (server_name);
2657         server_name = NULL;
2658
2659         /* username: */
2660         gchar *initial_username = modest_server_account_get_username (
2661                 modest_runtime_get_account_mgr(), server_account_name);
2662
2663         GtkWidget *entry_username = gtk_entry_new ();
2664         if (initial_username)
2665                 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2666         /* Dim this if a connection has ever succeeded with this username,
2667          * as per the UI spec: */
2668         const gboolean username_known =
2669                 modest_server_account_get_username_has_succeeded(
2670                         modest_runtime_get_account_mgr(), server_account_name);
2671         gtk_widget_set_sensitive (entry_username, !username_known);
2672
2673 #ifdef MODEST_PLATFORM_MAEMO
2674         /* Auto-capitalization is the default, so let's turn it off: */
2675         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2676
2677         /* Create a size group to be used by all captions.
2678          * Note that HildonCaption does not create a default size group if we do not specify one.
2679          * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2680         GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2681
2682         GtkWidget *caption = hildon_caption_new (sizegroup,
2683                 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2684         gtk_widget_show (entry_username);
2685         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2686                 FALSE, FALSE, MODEST_MARGIN_HALF);
2687         gtk_widget_show (caption);
2688 #else
2689         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2690                             TRUE, FALSE, 0);
2691 #endif /* MODEST_PLATFORM_MAEMO */
2692
2693         /* password: */
2694         GtkWidget *entry_password = gtk_entry_new ();
2695         gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2696         /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2697
2698 #ifdef MODEST_PLATFORM_MAEMO
2699         /* Auto-capitalization is the default, so let's turn it off: */
2700         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2701                 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2702
2703         caption = hildon_caption_new (sizegroup,
2704                 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2705         gtk_widget_show (entry_password);
2706         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2707                 FALSE, FALSE, MODEST_MARGIN_HALF);
2708         gtk_widget_show (caption);
2709         g_object_unref (sizegroup);
2710 #else
2711         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2712                             TRUE, FALSE, 0);
2713 #endif /* MODEST_PLATFORM_MAEMO */
2714
2715 /* This is not in the Maemo UI spec:
2716         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2717         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2718                             TRUE, FALSE, 0);
2719 */
2720
2721         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2722
2723         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2724                 if (username) {
2725                         *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2726
2727                         modest_server_account_set_username (
2728                                  modest_runtime_get_account_mgr(), server_account_name,
2729                                  *username);
2730
2731                         const gboolean username_was_changed =
2732                                 (strcmp (*username, initial_username) != 0);
2733                         if (username_was_changed) {
2734                                 g_warning ("%s: tinymail does not yet support changing the "
2735                                         "username in the get_password() callback.\n", __FUNCTION__);
2736                         }
2737                 }
2738
2739                 if (password) {
2740                         *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2741
2742                         /* We do not save the password in the configuration,
2743                          * because this function is only called for passwords that should
2744                          * not be remembered:
2745                         modest_server_account_set_password (
2746                                  modest_runtime_get_account_mgr(), server_account_name,
2747                                  *password);
2748                         */
2749                 }
2750
2751                 if (cancel)
2752                         *cancel   = FALSE;
2753
2754         } else {
2755                 show_error(GTK_WIDGET (main_window), _("mail_ib_login_cancelled"));
2756
2757                 if (username)
2758                         *username = NULL;
2759
2760                 if (password)
2761                         *password = NULL;
2762
2763                 if (cancel)
2764                         *cancel   = TRUE;
2765         }
2766
2767 /* This is not in the Maemo UI spec:
2768         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2769                 *remember = TRUE;
2770         else
2771                 *remember = FALSE;
2772 */
2773
2774         gtk_widget_destroy (dialog);
2775
2776         /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2777 }
2778
2779 void
2780 modest_ui_actions_on_cut (GtkAction *action,
2781                           ModestWindow *window)
2782 {
2783         GtkWidget *focused_widget;
2784         GtkClipboard *clipboard;
2785
2786         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2787         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2788         if (GTK_IS_EDITABLE (focused_widget)) {
2789                 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2790                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2791                 gtk_clipboard_store (clipboard);
2792         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2793                 GtkTextBuffer *buffer;
2794
2795                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2796                 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2797                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2798                 gtk_clipboard_store (clipboard);
2799         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2800                 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2801         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2802                 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2803         }
2804 }
2805
2806 void
2807 modest_ui_actions_on_copy (GtkAction *action,
2808                            ModestWindow *window)
2809 {
2810         GtkClipboard *clipboard;
2811         GtkWidget *focused_widget;
2812
2813         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2814         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2815
2816         if (GTK_IS_LABEL (focused_widget)) {
2817                 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2818                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2819                 gtk_clipboard_store (clipboard);
2820         } else if (GTK_IS_EDITABLE (focused_widget)) {
2821                 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2822                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2823                 gtk_clipboard_store (clipboard);
2824         } else if (GTK_IS_HTML (focused_widget)) {
2825                 gtk_html_copy (GTK_HTML (focused_widget));
2826                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2827                 gtk_clipboard_store (clipboard);
2828         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2829                 GtkTextBuffer *buffer;
2830                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2831                 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2832                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2833                 gtk_clipboard_store (clipboard);
2834         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2835                 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2836                 TnyIterator *iter = tny_list_create_iterator (header_list);
2837                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2838
2839                 gboolean ask = FALSE;
2840                 if (header) {
2841                         TnyFolder *folder = tny_header_get_folder (header);
2842                         TnyAccount *account = tny_folder_get_account (folder);
2843                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2844                         /* If it's POP then ask */
2845                         ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2846                                 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2847                         g_object_unref (account);
2848                         g_object_unref (folder);
2849                         g_object_unref (header);
2850                 }
2851
2852                 g_object_unref (iter);
2853
2854                 /* Check that the messages have been previously downloaded */
2855                 gboolean continue_download = TRUE;
2856                 if (ask)
2857                         continue_download = download_uncached_messages (header_list, GTK_WINDOW (window));
2858                 if (continue_download)
2859                         modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2860                 g_object_unref (header_list);
2861         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2862                 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2863         }
2864
2865         /* Show information banner */
2866         modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2867
2868 }
2869
2870 void
2871 modest_ui_actions_on_undo (GtkAction *action,
2872                            ModestWindow *window)
2873 {
2874         ModestEmailClipboard *clipboard = NULL;
2875
2876         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2877                 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2878         } else if (MODEST_IS_MAIN_WINDOW (window)) {
2879                 /* Clear clipboard source */
2880                 clipboard = modest_runtime_get_email_clipboard ();
2881                 modest_email_clipboard_clear (clipboard);
2882         }
2883         else {
2884                 g_return_if_reached ();
2885         }
2886 }
2887
2888 void
2889 modest_ui_actions_on_redo (GtkAction *action,
2890                            ModestWindow *window)
2891 {
2892         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2893                 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2894         }
2895         else {
2896                 g_return_if_reached ();
2897         }
2898 }
2899
2900
2901 static void
2902 paste_msgs_cb (const GObject *object, gpointer user_data)
2903 {
2904         g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2905         g_return_if_fail (GTK_IS_WIDGET (user_data));
2906
2907         /* destroy information note */
2908         gtk_widget_destroy (GTK_WIDGET(user_data));
2909 }
2910
2911 static void
2912 paste_as_attachment_free (gpointer data)
2913 {
2914         PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
2915
2916         gtk_widget_destroy (helper->banner);
2917         g_object_unref (helper->banner);
2918         g_free (helper);
2919 }
2920
2921 static void
2922 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
2923                             TnyHeader *header,
2924                             TnyMsg *msg,
2925                             gpointer userdata)
2926 {
2927         PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
2928         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
2929
2930         if (msg == NULL)
2931                 return;
2932
2933         modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
2934
2935 }
2936
2937 void
2938 modest_ui_actions_on_paste (GtkAction *action,
2939                             ModestWindow *window)
2940 {
2941         GtkWidget *focused_widget = NULL;
2942         GtkWidget *inf_note = NULL;
2943         ModestMailOperation *mail_op = NULL;
2944
2945         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2946         if (GTK_IS_EDITABLE (focused_widget)) {
2947                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2948         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2949                 ModestEmailClipboard *e_clipboard = NULL;
2950                 e_clipboard = modest_runtime_get_email_clipboard ();
2951                 if (modest_email_clipboard_cleared (e_clipboard)) {
2952                         GtkTextBuffer *buffer;
2953                         GtkClipboard *clipboard;
2954
2955                         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2956                         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2957                         gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2958                 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2959                         ModestMailOperation *mail_op;
2960                         TnyFolder *src_folder;
2961                         TnyList *data;
2962                         gboolean delete;
2963                         PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
2964                         helper->window = MODEST_MSG_EDIT_WINDOW (window);
2965                         helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2966                                                                            _CS("ckct_nw_pasting"));
2967                         modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
2968                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2969                                                              G_OBJECT (window));
2970                         if (helper->banner != NULL) {
2971                                 g_object_ref (G_OBJECT (helper->banner));
2972                                 gtk_window_set_modal (GTK_WINDOW (helper->banner), FALSE);
2973                                 gtk_widget_show (GTK_WIDGET (helper->banner));
2974                         }
2975
2976                         if (data != NULL) {
2977                                 modest_mail_operation_get_msgs_full (mail_op,
2978                                                                      data,
2979                                                                      (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
2980                                                                      helper,
2981                                                                      paste_as_attachment_free);
2982                         }
2983                 }
2984         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2985                 ModestEmailClipboard *clipboard = NULL;
2986                 TnyFolder *src_folder = NULL;
2987                 TnyFolderStore *folder_store = NULL;
2988                 TnyList *data = NULL;
2989                 gboolean delete = FALSE;
2990
2991                 /* Check clipboard source */
2992                 clipboard = modest_runtime_get_email_clipboard ();
2993                 if (modest_email_clipboard_cleared (clipboard))
2994                         return;
2995
2996                 /* Get elements to paste */
2997                 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2998
2999                 /* Create a new mail operation */
3000                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
3001
3002                 /* Get destination folder */
3003                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
3004
3005                 /* transfer messages  */
3006                 if (data != NULL) {
3007                         gint response = 0;
3008
3009                         /* Ask for user confirmation */
3010                         response = msgs_move_to_confirmation (GTK_WINDOW (window),
3011                                                               TNY_FOLDER (folder_store),
3012                                                               delete,
3013                                                               data);
3014
3015                         if (response == GTK_RESPONSE_OK) {
3016                                 /* Launch notification */
3017                                 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3018                                                                              _CS("ckct_nw_pasting"));
3019                                 if (inf_note != NULL)  {
3020                                         gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3021                                         gtk_widget_show (GTK_WIDGET(inf_note));
3022                                 }
3023
3024                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3025                                 modest_mail_operation_xfer_msgs (mail_op,
3026                                                                  data,
3027                                                                  TNY_FOLDER (folder_store),
3028                                                                  delete,
3029                                                                  paste_msgs_cb,
3030                                                                  inf_note);
3031                         } else {
3032                                 g_object_unref (mail_op);
3033                         }
3034
3035                 } else if (src_folder != NULL) {
3036                         /* Launch notification */
3037                         inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3038                                                                      _CS("ckct_nw_pasting"));
3039                         if (inf_note != NULL)  {
3040                                 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3041                                 gtk_widget_show (GTK_WIDGET(inf_note));
3042                         }
3043
3044                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3045                         modest_mail_operation_xfer_folder (mail_op,
3046                                                            src_folder,
3047                                                            folder_store,
3048                                                            delete,
3049                                                            paste_msgs_cb,
3050                                                            inf_note);
3051                 }
3052
3053                 /* Free */
3054                 if (data != NULL)
3055                         g_object_unref (data);
3056                 if (src_folder != NULL)
3057                         g_object_unref (src_folder);
3058                 if (folder_store != NULL)
3059                         g_object_unref (folder_store);
3060         }
3061 }
3062
3063
3064 void
3065 modest_ui_actions_on_select_all (GtkAction *action,
3066                                  ModestWindow *window)
3067 {
3068         GtkWidget *focused_widget;
3069
3070         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3071         if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
3072                 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
3073         } else if (GTK_IS_LABEL (focused_widget)) {
3074                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
3075         } else if (GTK_IS_EDITABLE (focused_widget)) {
3076                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
3077         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3078                 GtkTextBuffer *buffer;
3079                 GtkTextIter start, end;
3080
3081                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3082                 gtk_text_buffer_get_start_iter (buffer, &start);
3083                 gtk_text_buffer_get_end_iter (buffer, &end);
3084                 gtk_text_buffer_select_range (buffer, &start, &end);
3085         } else if (GTK_IS_HTML (focused_widget)) {
3086                 gtk_html_select_all (GTK_HTML (focused_widget));
3087         } else if (MODEST_IS_MAIN_WINDOW (window)) {
3088                 GtkWidget *header_view = focused_widget;
3089                 GtkTreeSelection *selection = NULL;
3090
3091                 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
3092                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3093                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
3094
3095                 /* Select all messages */
3096                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
3097                 gtk_tree_selection_select_all (selection);
3098
3099                 /* Set focuse on header view */
3100                 gtk_widget_grab_focus (header_view);
3101         }
3102
3103 }
3104
3105 void
3106 modest_ui_actions_on_mark_as_read (GtkAction *action,
3107                                    ModestWindow *window)
3108 {
3109         g_return_if_fail (MODEST_IS_WINDOW(window));
3110
3111         /* Mark each header as read */
3112         do_headers_action (window, headers_action_mark_as_read, NULL);
3113 }
3114
3115 void
3116 modest_ui_actions_on_mark_as_unread (GtkAction *action,
3117                                      ModestWindow *window)
3118 {
3119         g_return_if_fail (MODEST_IS_WINDOW(window));
3120
3121         /* Mark each header as read */
3122         do_headers_action (window, headers_action_mark_as_unread, NULL);
3123 }
3124
3125 void
3126 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
3127                                   GtkRadioAction *selected,
3128                                   ModestWindow *window)
3129 {
3130         gint value;
3131
3132         value = gtk_radio_action_get_current_value (selected);
3133         if (MODEST_IS_WINDOW (window)) {
3134                 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
3135         }
3136 }
3137
3138 void     modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
3139                                                         GtkRadioAction *selected,
3140                                                         ModestWindow *window)
3141 {
3142         TnyHeaderFlags flags;
3143         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3144
3145         flags = gtk_radio_action_get_current_value (selected);
3146         modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
3147 }
3148
3149 void     modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
3150                                                            GtkRadioAction *selected,
3151                                                            ModestWindow *window)
3152 {
3153         gint file_format;
3154
3155         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3156
3157         file_format = gtk_radio_action_get_current_value (selected);
3158         modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
3159 }
3160
3161
3162 void
3163 modest_ui_actions_on_zoom_plus (GtkAction *action,
3164                                 ModestWindow *window)
3165 {
3166         g_return_if_fail (MODEST_IS_WINDOW (window));
3167
3168         modest_window_zoom_plus (MODEST_WINDOW (window));
3169 }
3170
3171 void
3172 modest_ui_actions_on_zoom_minus (GtkAction *action,
3173                                  ModestWindow *window)
3174 {
3175         g_return_if_fail (MODEST_IS_WINDOW (window));
3176
3177         modest_window_zoom_minus (MODEST_WINDOW (window));
3178 }
3179
3180 void
3181 modest_ui_actions_on_toggle_fullscreen    (GtkToggleAction *toggle,
3182                                            ModestWindow *window)
3183 {
3184         ModestWindowMgr *mgr;
3185         gboolean fullscreen, active;
3186         g_return_if_fail (MODEST_IS_WINDOW (window));
3187
3188         mgr = modest_runtime_get_window_mgr ();
3189
3190         active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
3191         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3192
3193         if (active != fullscreen) {
3194                 modest_window_mgr_set_fullscreen_mode (mgr, active);
3195                 gtk_window_present (GTK_WINDOW (window));
3196         }
3197 }
3198
3199 void
3200 modest_ui_actions_on_change_fullscreen (GtkAction *action,
3201                                         ModestWindow *window)
3202 {
3203         ModestWindowMgr *mgr;
3204         gboolean fullscreen;
3205
3206         g_return_if_fail (MODEST_IS_WINDOW (window));
3207
3208         mgr = modest_runtime_get_window_mgr ();
3209         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3210         modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
3211
3212         gtk_window_present (GTK_WINDOW (window));
3213 }
3214
3215 /*
3216  * Used by modest_ui_actions_on_details to call do_headers_action
3217  */
3218 static void
3219 headers_action_show_details (TnyHeader *header,
3220                              ModestWindow *window,
3221                              gpointer user_data)
3222
3223 {
3224         GtkWidget *dialog;
3225
3226         /* Create dialog */
3227         dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
3228
3229         /* Run dialog */
3230         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3231         gtk_widget_show_all (dialog);
3232         gtk_dialog_run (GTK_DIALOG (dialog));
3233
3234         gtk_widget_destroy (dialog);
3235 }
3236
3237 /*
3238  * Show the folder details in a ModestDetailsDialog widget
3239  */
3240 static void
3241 show_folder_details (TnyFolder *folder,
3242                      GtkWindow *window)
3243 {
3244         GtkWidget *dialog;
3245
3246         /* Create dialog */
3247         dialog = modest_details_dialog_new_with_folder (window, folder);
3248
3249         /* Run dialog */
3250         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3251         gtk_widget_show_all (dialog);
3252         gtk_dialog_run (GTK_DIALOG (dialog));
3253
3254         gtk_widget_destroy (dialog);
3255 }
3256
3257 /*
3258  * Show the header details in a ModestDetailsDialog widget
3259  */
3260 void
3261 modest_ui_actions_on_details (GtkAction *action,
3262                               ModestWindow *win)
3263 {
3264         TnyList * headers_list;
3265         TnyIterator *iter;
3266         TnyHeader *header;
3267
3268         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3269                 TnyMsg *msg;
3270
3271                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3272                 if (!msg)
3273                         return;
3274                 g_object_unref (msg);
3275
3276                 headers_list = get_selected_headers (win);
3277                 if (!headers_list)
3278                         return;
3279
3280                 iter = tny_list_create_iterator (headers_list);
3281
3282                 header = TNY_HEADER (tny_iterator_get_current (iter));
3283                 if (header) {
3284                         headers_action_show_details (header, win, NULL);
3285                         g_object_unref (header);
3286                 }
3287
3288                 g_object_unref (iter);
3289                 g_object_unref (headers_list);
3290
3291         } else if (MODEST_IS_MAIN_WINDOW (win)) {
3292                 GtkWidget *folder_view, *header_view;
3293
3294                 /* Check which widget has the focus */
3295                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3296                                                                     MODEST_WIDGET_TYPE_FOLDER_VIEW);
3297                 if (gtk_widget_is_focus (folder_view)) {
3298                         TnyFolderStore *folder_store
3299                                 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3300                         if (!folder_store) {
3301                                 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3302                                 return;
3303                         }
3304                         /* Show only when it's a folder */
3305                         /* This function should not be called for account items,
3306                          * because we dim the menu item for them. */
3307                         if (TNY_IS_FOLDER (folder_store)) {
3308                                 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3309                         }
3310
3311                         g_object_unref (folder_store);
3312
3313                 } else {
3314                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3315                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
3316                         /* Show details of each header */
3317                         do_headers_action (win, headers_action_show_details, header_view);
3318                 }
3319         }
3320 }
3321
3322 void
3323 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3324                                      ModestMsgEditWindow *window)
3325 {
3326         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3327
3328         modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3329 }
3330
3331 void
3332 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3333                                       ModestMsgEditWindow *window)
3334 {
3335         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3336
3337         modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3338 }
3339
3340 void
3341 modest_ui_actions_toggle_folders_view (GtkAction *action,
3342                                        ModestMainWindow *main_window)
3343 {
3344         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3345
3346         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3347                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3348         else
3349                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3350 }
3351
3352 void
3353 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3354                                      ModestWindow *window)
3355 {
3356         gboolean active, fullscreen = FALSE;
3357         ModestWindowMgr *mgr;
3358
3359         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3360
3361         /* Check if we want to toggle the toolbar vuew in fullscreen
3362            or normal mode */
3363         if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3364                      "ViewShowToolbarFullScreen")) {
3365                 fullscreen = TRUE;
3366         }
3367
3368         /* Toggle toolbar */
3369         mgr = modest_runtime_get_window_mgr ();
3370         modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3371 }
3372
3373 void
3374 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3375                                            ModestMsgEditWindow *window)
3376 {
3377         modest_msg_edit_window_select_font (window);
3378 }
3379
3380 void
3381 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3382                                                   const gchar *display_name,
3383                                                   GtkWindow *window)
3384 {
3385         /* Do not change the application name if the widget has not
3386            the focus. This callback could be called even if the folder
3387            view has not the focus, because the handled signal could be
3388            emitted when the folder view is redrawn */
3389         if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3390                 if (display_name)
3391                         gtk_window_set_title (window, display_name);
3392                 else
3393                         gtk_window_set_title (window, " ");
3394         }
3395 }
3396
3397 void
3398 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3399 {
3400         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3401         modest_msg_edit_window_select_contacts (window);
3402 }
3403
3404 void
3405 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3406 {
3407         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3408         modest_msg_edit_window_check_names (window, FALSE);
3409 }
3410
3411 static void
3412 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3413 {
3414         modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3415                                          GTK_WIDGET (user_data));
3416 }
3417
3418 static GtkWidget*
3419 create_move_to_dialog (GtkWindow *win,
3420                        GtkWidget *folder_view,
3421                        GtkWidget **tree_view)
3422 {
3423         GtkWidget *dialog, *scroll;
3424         GtkWidget *new_button;
3425
3426         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3427                                               GTK_WINDOW (win),
3428                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3429                                               NULL);
3430
3431         gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
3432         /* We do this manually so GTK+ does not associate a response ID for
3433          * the button. */
3434         new_button = gtk_button_new_from_stock (GTK_STOCK_NEW);
3435         gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3436         gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
3437
3438         /* Create scrolled window */
3439         scroll = gtk_scrolled_window_new (NULL, NULL);
3440         gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scroll),
3441                                          GTK_POLICY_AUTOMATIC,
3442                                          GTK_POLICY_AUTOMATIC);
3443
3444         /* Create folder view */
3445         *tree_view = modest_platform_create_folder_view (NULL);
3446
3447         g_signal_connect (G_OBJECT (new_button), "clicked", G_CALLBACK(create_move_to_dialog_on_new_folder), *tree_view);
3448
3449         /* It could happen that we're trying to move a message from a
3450            window (msg window for example) after the main window was
3451            closed, so we can not just get the model of the folder
3452            view */
3453         if (MODEST_IS_FOLDER_VIEW (folder_view))
3454                 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3455                                          gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3456         else
3457                 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3458                                                  TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3459
3460         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3461
3462         gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3463
3464         /* Add scroll to dialog */
3465         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3466                             scroll, TRUE, TRUE, 0);
3467
3468         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3469         gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3470
3471         return dialog;
3472 }
3473
3474 /*
3475  * Returns TRUE if at least one of the headers of the list belongs to
3476  * a message that has been fully retrieved.
3477  */
3478 static gboolean
3479 has_retrieved_msgs (TnyList *list)
3480 {
3481         TnyIterator *iter;
3482         gboolean found = FALSE;
3483
3484         iter = tny_list_create_iterator (list);
3485         while (!tny_iterator_is_done (iter) && !found) {
3486                 TnyHeader *header;
3487                 TnyHeaderFlags flags = 0;
3488
3489                 header = TNY_HEADER (tny_iterator_get_current (iter));
3490                 if (header) {
3491                         flags = tny_header_get_flags (header);
3492                         if (flags & TNY_HEADER_FLAG_CACHED)
3493 /*                      if (!(flags & TNY_HEADER_FLAG_PARTIAL)) */
3494                                 found = TRUE;
3495
3496                         g_object_unref (header);
3497                 }
3498
3499                 if (!found)
3500                         tny_iterator_next (iter);
3501         }
3502         g_object_unref (iter);
3503
3504         return found;
3505 }
3506
3507 /*
3508  * Shows a confirmation dialog to the user when we're moving messages
3509  * from a remote server to the local storage. Returns the dialog
3510  * response. If it's other kind of movement the it always returns
3511  * GTK_RESPONSE_OK
3512  */
3513 static gint
3514 msgs_move_to_confirmation (GtkWindow *win,
3515                            TnyFolder *dest_folder,
3516                            gboolean delete,
3517                            TnyList *headers)
3518 {
3519         gint response = GTK_RESPONSE_OK;
3520
3521         /* If the destination is a local folder (or MMC folder )*/
3522         if (!modest_tny_folder_is_remote_folder (dest_folder)) {
3523 /*      if (modest_tny_folder_is_local_folder (dest_folder)) { */
3524                 TnyFolder *src_folder = NULL;
3525                 TnyIterator *iter = NULL;
3526                 TnyHeader *header = NULL;
3527
3528                 /* Get source folder */
3529                 iter = tny_list_create_iterator (headers);
3530                 header = TNY_HEADER (tny_iterator_get_current (iter));
3531                 if (header) {
3532                         src_folder = tny_header_get_folder (header);
3533                         g_object_unref (header);
3534                 }
3535
3536                 g_object_unref (iter);
3537
3538                 /* if no src_folder, message may be an attahcment */
3539                 if (src_folder == NULL)
3540                         return GTK_RESPONSE_CANCEL;
3541
3542                 /* If the source is a remote folder */
3543 /*              if (!modest_tny_folder_is_local_folder (src_folder)) { */
3544                 if (modest_tny_folder_is_remote_folder (src_folder)) {
3545                         const gchar *message = NULL;
3546                         gboolean cached = has_retrieved_msgs (headers);
3547                         if (cached)
3548                                 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3549                                                     tny_list_get_length (headers));
3550                         else
3551                                 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3552                                                     tny_list_get_length (headers));
3553
3554                         if (cached && !delete)
3555                                 response = GTK_RESPONSE_OK;
3556                         else
3557                                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3558                                                                                     (const gchar *) message);
3559                 }
3560
3561                 g_object_unref (src_folder);
3562         }
3563
3564         return response;
3565 }
3566
3567
3568
3569 static void
3570 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3571 {
3572         ModestMsgViewWindow *self = NULL;
3573
3574         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3575         self = MODEST_MSG_VIEW_WINDOW (object);
3576
3577         if (!modest_msg_view_window_select_next_message (self))
3578                 if (!modest_msg_view_window_select_previous_message (self))
3579                         /* No more messages to view, so close this window */
3580                         modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3581 }
3582
3583 void
3584 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3585                                              gpointer user_data)
3586 {
3587         GObject *win = modest_mail_operation_get_source (mail_op);
3588         const GError *error = NULL;
3589         const gchar *message = NULL;
3590
3591         /* Get error message */
3592         error = modest_mail_operation_get_error (mail_op);
3593         if (error != NULL && error->message != NULL) {
3594                 message = error->message;
3595         } else {
3596                 message = _("mail_in_ui_folder_move_target_error");
3597         }
3598
3599         /* Show notification dialog */
3600         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3601         g_object_unref (win);
3602 }
3603
3604 void
3605 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3606                                               gpointer user_data)
3607 {
3608         GObject *win = modest_mail_operation_get_source (mail_op);
3609         const GError *error = modest_mail_operation_get_error (mail_op);
3610
3611         g_return_if_fail (error != NULL);
3612         if (error->message != NULL)
3613                 g_printerr ("modest: %s\n", error->message);
3614         else
3615                 g_printerr ("modest: unkonw error on send&receive operation");
3616
3617         /* Show error message */
3618 /*      if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3619 /*              modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3620 /*                                                      _CS("sfil_ib_unable_to_receive")); */
3621 /*      else  */
3622 /*              modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3623 /*                                                      _CS("sfil_ib_unable_to_send")); */
3624         g_object_unref (win);
3625 }
3626
3627 static void
3628 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3629                        TnyHeader *header,
3630                        TnyMsg *msg,
3631                        gpointer user_data)
3632 {
3633         TnyList *parts;
3634         TnyIterator *iter;
3635         gint pending_purges = 0;
3636         gboolean some_purged = FALSE;
3637         ModestWindow *win = MODEST_WINDOW (user_data);
3638         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
3639
3640         /* If there was any error */
3641         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
3642                 modest_window_mgr_unregister_header (mgr, header);
3643                 return;
3644         }
3645
3646         /* Once the message has been retrieved for purging, we check if
3647          * it's all ok for purging */
3648
3649         parts = tny_simple_list_new ();
3650         tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3651         iter = tny_list_create_iterator (parts);
3652
3653         while (!tny_iterator_is_done (iter)) {
3654                 TnyMimePart *part;
3655                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3656                 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
3657                         if (tny_mime_part_is_purged (part))
3658                                 some_purged = TRUE;
3659                         else
3660                                 pending_purges++;
3661                 }
3662
3663                 if (part)
3664                         g_object_unref (part);
3665
3666                 tny_iterator_next (iter);
3667         }
3668
3669         if (pending_purges>0) {
3670                 gint response;
3671                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3672
3673                 if (response == GTK_RESPONSE_OK) {
3674                         modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3675                         tny_iterator_first (iter);
3676                         while (!tny_iterator_is_done (iter)) {
3677                                 TnyMimePart *part;
3678
3679                                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3680                                 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
3681                                         tny_mime_part_set_purged (part);
3682
3683                                 if (part)
3684                                         g_object_unref (part);
3685
3686                                 tny_iterator_next (iter);
3687                         }
3688
3689                         tny_msg_rewrite_cache (msg);
3690                 }
3691         } else {
3692                 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3693         }
3694
3695         /* remove attachments */
3696         tny_iterator_first (iter);
3697         while (!tny_iterator_is_done (iter)) {
3698                 TnyMimePart *part;
3699
3700                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3701                 if (part) {
3702                         /* One for the reference given by tny_iterator_get_current(): */
3703                         g_object_unref (part);
3704
3705                         /* TODO: Is this meant to remove the attachment by doing another unref()?
3706                          * Otherwise, this seems useless. */
3707                 }
3708
3709                 tny_iterator_next (iter);
3710         }
3711         modest_window_mgr_unregister_header (mgr, header);
3712
3713         g_object_unref (iter);
3714         g_object_unref (parts);
3715 }
3716
3717 static void
3718 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3719                                                      ModestMainWindow *win)
3720 {
3721         GtkWidget *header_view;
3722         TnyList *header_list;
3723         TnyIterator *iter;
3724         TnyHeader *header;
3725         TnyHeaderFlags flags;
3726         ModestWindow *msg_view_window =  NULL;
3727         gboolean found;
3728
3729         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3730
3731         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3732                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
3733
3734         header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3735
3736         if (tny_list_get_length (header_list) == 1) {
3737                 iter = tny_list_create_iterator (header_list);
3738                 header = TNY_HEADER (tny_iterator_get_current (iter));
3739                 g_object_unref (iter);
3740         } else {
3741                 return;
3742         }
3743
3744         found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3745                                                           header, &msg_view_window);
3746         flags = tny_header_get_flags (header);
3747         if (!(flags & TNY_HEADER_FLAG_CACHED))
3748                 return;
3749         if (found) {
3750                 if (msg_view_window != NULL)
3751                         modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3752                 else {
3753                         /* do nothing; uid was registered before, so window is probably on it's way */
3754                         g_warning ("debug: header %p has already been registered", header);
3755                 }
3756         } else {
3757                 ModestMailOperation *mail_op = NULL;
3758                 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3759                 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3760                                                                          G_OBJECT (win),
3761                                                                          modest_ui_actions_get_msgs_full_error_handler,
3762                                                                          NULL);
3763                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3764                 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3765
3766                 g_object_unref (mail_op);
3767         }
3768         if (header)
3769                 g_object_unref (header);
3770         if (header_list)
3771                 g_object_unref (header_list);
3772 }
3773
3774 /**
3775  * Utility function that transfer messages from both the main window
3776  * and the msg view window when using the "Move to" dialog
3777  */
3778 static void
3779 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
3780                                               ModestWindow *win)
3781 {
3782         TnyList *headers = NULL;
3783         gint response = 0;
3784         TnyAccount *dst_account = NULL;
3785         const gchar *proto_str = NULL;
3786         gboolean dst_is_pop = FALSE;
3787
3788         if (!TNY_IS_FOLDER (dst_folder)) {
3789                 modest_platform_information_banner (GTK_WIDGET (win),
3790                                                     NULL,
3791                                                     _CS("ckdg_ib_unable_to_move_to_current_location"));
3792                 return;
3793         }
3794
3795         dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
3796         proto_str = tny_account_get_proto (dst_account);
3797         dst_is_pop = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
3798                       MODEST_PROTOCOL_STORE_POP);
3799         g_object_unref (dst_account);
3800
3801         /* Get selected headers */
3802         headers = get_selected_headers (MODEST_WINDOW (win));
3803
3804         if (dst_is_pop) {
3805                 modest_platform_information_banner (GTK_WIDGET (win),
3806                                                     NULL,
3807                                                     ngettext("mail_in_ui_folder_move_target_error",
3808                                                              "mail_in_ui_folder_move_targets_error",
3809                                                              tny_list_get_length (headers)));
3810                 g_object_unref (headers);
3811                 return;
3812         }
3813
3814         /* Ask for user confirmation */
3815         response = msgs_move_to_confirmation (GTK_WINDOW (win),
3816                                               TNY_FOLDER (dst_folder),
3817                                               TRUE,
3818                                               headers);
3819
3820         /* Transfer messages */
3821         if (response == GTK_RESPONSE_OK) {
3822                 ModestMailOperation *mail_op =
3823                         modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3824                                                                        G_OBJECT(win),
3825                                                                        modest_ui_actions_move_folder_error_handler,
3826                                                                        NULL);
3827                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3828                                                  mail_op);
3829
3830                 modest_mail_operation_xfer_msgs (mail_op,
3831                                                  headers,
3832                                                  TNY_FOLDER (dst_folder),
3833                                                  TRUE,
3834                                                  (MODEST_IS_MSG_VIEW_WINDOW (win)) ? transfer_msgs_from_viewer_cb : NULL,
3835                                                  NULL);
3836
3837                 g_object_unref (G_OBJECT (mail_op));
3838         }
3839         g_object_unref (headers);
3840 }
3841
3842
3843 /*
3844  * UI handler for the "Move to" action when invoked from the
3845  * ModestMainWindow
3846  */
3847 static void
3848 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3849                                           GtkWidget *folder_view,
3850                                           TnyFolderStore *dst_folder,
3851                                           ModestMainWindow *win)
3852 {
3853         GtkWidget *header_view = NULL;
3854         ModestMailOperation *mail_op = NULL;
3855         TnyFolderStore *src_folder;
3856
3857         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3858
3859         /* Get the source folder */
3860         src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3861
3862         /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3863         if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3864                                                                       src_folder))
3865                 goto end;
3866
3867         /* Get header view */
3868         header_view =
3869                 modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW);
3870
3871         /* Get folder or messages to transfer */
3872         if (gtk_widget_is_focus (folder_view)) {
3873
3874                 /* Allow only to transfer folders to the local root folder */
3875                 if (TNY_IS_ACCOUNT (dst_folder) &&
3876                     !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder))
3877                         goto end;
3878
3879                 /* Clean folder on header view before moving it */
3880                 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3881
3882                 if (TNY_IS_FOLDER (src_folder)) {
3883                         mail_op =
3884                                 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3885                                                                                G_OBJECT(win),
3886                                                                                modest_ui_actions_move_folder_error_handler,
3887                                                                                NULL);
3888                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3889                                                          mail_op);
3890
3891                         modest_mail_operation_xfer_folder (mail_op,
3892                                                            TNY_FOLDER (src_folder),
3893                                                            dst_folder,
3894                                                            TRUE, NULL, NULL);
3895                         /* Unref mail operation */
3896                         g_object_unref (G_OBJECT (mail_op));
3897                 } else {
3898                         g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3899                 }
3900         } else if (gtk_widget_is_focus (header_view)) {
3901                 /* Transfer messages */
3902                 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3903         }
3904
3905  end:
3906     if (src_folder)
3907         g_object_unref (src_folder);
3908 }
3909
3910
3911 /*
3912  * UI handler for the "Move to" action when invoked from the
3913  * ModestMsgViewWindow
3914  */
3915 static void
3916 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3917                                               TnyFolderStore *dst_folder,
3918                                               ModestMsgViewWindow *win)
3919 {
3920         TnyHeader *header = NULL;
3921         TnyFolder *src_folder;
3922
3923         /* Create header list */
3924         header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3925         src_folder = tny_header_get_folder(header);
3926         g_object_unref (header);
3927
3928         /* Transfer the message */
3929         if (modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (src_folder)))
3930                 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3931
3932         g_object_unref (src_folder);
3933 }
3934
3935 void
3936 modest_ui_actions_on_move_to (GtkAction *action,
3937                               ModestWindow *win)
3938 {
3939         GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3940         gint result = 0;
3941         TnyFolderStore *dst_folder = NULL;
3942         ModestMainWindow *main_window;
3943
3944         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3945                           MODEST_IS_MSG_VIEW_WINDOW (win));
3946
3947         /* Get the main window if exists */
3948         if (MODEST_IS_MAIN_WINDOW (win))
3949                 main_window = MODEST_MAIN_WINDOW (win);
3950         else
3951                 main_window =
3952                         MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3953
3954         /* Get the folder view widget if exists */
3955         if (main_window)
3956                 folder_view = modest_main_window_get_child_widget (main_window,
3957                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
3958         else
3959                 folder_view = NULL;
3960
3961         /* Create and run the dialog */
3962         dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
3963         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3964         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3965         result = gtk_dialog_run (GTK_DIALOG(dialog));
3966         g_object_ref (tree_view);
3967         gtk_widget_destroy (dialog);
3968
3969         if (result != GTK_RESPONSE_ACCEPT)
3970                 return;
3971
3972         dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3973         /* Offer the connection dialog if necessary: */
3974         if (modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3975                                                                       dst_folder)) {
3976
3977                 /* Do window specific stuff */
3978                 if (MODEST_IS_MAIN_WINDOW (win))
3979                         modest_ui_actions_on_main_window_move_to (action,
3980                                                                   folder_view,
3981                                                                   dst_folder,
3982                                                                   MODEST_MAIN_WINDOW (win));
3983                 else
3984                         modest_ui_actions_on_msg_view_window_move_to (action,
3985                                                                       dst_folder,
3986                                                                       MODEST_MSG_VIEW_WINDOW (win));
3987         }
3988         if (dst_folder)
3989                 g_object_unref (dst_folder);
3990 }
3991
3992 /*
3993  * Calls #HeadersFunc for each header already selected in the main
3994  * window or the message currently being shown in the msg view window
3995  */
3996 static void
3997 do_headers_action (ModestWindow *win,
3998                    HeadersFunc func,
3999                    gpointer user_data)
4000 {
4001         TnyList *headers_list = NULL;
4002         TnyIterator *iter = NULL;
4003         TnyHeader *header = NULL;
4004         TnyFolder *folder = NULL;
4005
4006         /* Get headers */
4007         headers_list = get_selected_headers (win);
4008         if (!headers_list)
4009                 return;
4010
4011         /* Get the folder */
4012         iter = tny_list_create_iterator (headers_list);
4013         header = TNY_HEADER (tny_iterator_get_current (iter));
4014         if (header) {
4015                 folder = tny_header_get_folder (header);
4016                 g_object_unref (header);
4017         }
4018
4019         /* Call the function for each header */
4020         while (!tny_iterator_is_done (iter)) {
4021                 header = TNY_HEADER (tny_iterator_get_current (iter));
4022                 func (header, win, user_data);
4023                 g_object_unref (header);
4024                 tny_iterator_next (iter);
4025         }
4026
4027         /* Trick: do a poke status in order to speed up the signaling
4028            of observers */
4029         tny_folder_poke_status (folder);
4030
4031         /* Frees */
4032         g_object_unref (folder);
4033         g_object_unref (iter);
4034         g_object_unref (headers_list);
4035 }
4036
4037 void
4038 modest_ui_actions_view_attachment (GtkAction *action,
4039                                    ModestWindow *window)
4040 {
4041         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4042                 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
4043         } else {
4044                 /* not supported window for this action */
4045                 g_return_if_reached ();
4046         }
4047 }
4048
4049 void
4050 modest_ui_actions_save_attachments (GtkAction *action,
4051                                     ModestWindow *window)
4052 {
4053         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4054                 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
4055         } else {
4056                 /* not supported window for this action */
4057                 g_return_if_reached ();
4058         }
4059 }
4060
4061 void
4062 modest_ui_actions_remove_attachments (GtkAction *action,
4063                                       ModestWindow *window)
4064 {
4065         if (MODEST_IS_MAIN_WINDOW (window)) {
4066                 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
4067         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4068                 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
4069         } else {
4070                 /* not supported window for this action */
4071                 g_return_if_reached ();
4072         }
4073 }
4074
4075 void
4076 modest_ui_actions_on_settings (GtkAction *action,
4077                                ModestWindow *win)
4078 {
4079         GtkWidget *dialog;
4080
4081         dialog = modest_platform_get_global_settings_dialog ();
4082         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
4083         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
4084         gtk_widget_show_all (dialog);
4085
4086         gtk_dialog_run (GTK_DIALOG (dialog));
4087
4088         gtk_widget_destroy (dialog);
4089 }
4090
4091 void
4092 modest_ui_actions_on_help (GtkAction *action,
4093                            ModestWindow *win)
4094 {
4095         const gchar *help_id = NULL;
4096
4097         if (MODEST_IS_MAIN_WINDOW (win)) {
4098                 const gchar *action_name;
4099                 action_name = gtk_action_get_name (action);
4100
4101                 if (!strcmp (action_name, "FolderViewCSMHelp") ||
4102                     !strcmp (action_name, "HeaderViewCSMHelp")) {
4103                         GtkWidget *folder_view;
4104                         TnyFolderStore *folder_store;
4105                         /* Get selected folder */
4106                         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4107                                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
4108                         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4109
4110                         /* Switch help_id */
4111                         if (TNY_IS_FOLDER (folder_store)) {
4112                                 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
4113                                 case TNY_FOLDER_TYPE_NORMAL:
4114                                         help_id = "applications_email_managefolders";
4115                                         break;
4116                                 case TNY_FOLDER_TYPE_INBOX:
4117                                         help_id = "applications_email_inbox";
4118                                         break;
4119                                 case TNY_FOLDER_TYPE_OUTBOX:
4120                                         help_id = "applications_email_outbox";
4121                                         break;
4122                                 case TNY_FOLDER_TYPE_SENT:
4123                                         help_id = "applications_email_sent";
4124                                         break;
4125                                 case TNY_FOLDER_TYPE_DRAFTS:
4126                                         help_id = "applications_email_drafts";
4127                                         break;
4128                                 case TNY_FOLDER_TYPE_ARCHIVE:
4129                                         help_id = "applications_email_managefolders";
4130                                         break;
4131                                 default:
4132                                         help_id = "applications_email_managefolders";
4133                                 }
4134                         } else {
4135                                 help_id = "applications_email_mainview";
4136                         }
4137                         g_object_unref (folder_store);
4138                 } else {
4139                         help_id = "applications_email_mainview";
4140                 }
4141         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4142                 help_id = "applications_email_viewer";
4143         } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
4144                 help_id = "applications_email_editor";
4145
4146         modest_platform_show_help (GTK_WINDOW (win), help_id);
4147 }
4148
4149 void
4150 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
4151                                             ModestWindow *window)
4152 {
4153         ModestMailOperation *mail_op;
4154         TnyList *headers;
4155
4156         /* Get headers */
4157         headers = get_selected_headers (window);
4158         if (!headers)
4159                 return;
4160
4161         /* Create mail operation */
4162         mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4163                                                                  G_OBJECT (window),
4164                                                                  modest_ui_actions_get_msgs_full_error_handler,
4165                                                                  NULL);
4166         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4167         modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
4168
4169         /* Frees */
4170         g_object_unref (headers);
4171         g_object_unref (mail_op);
4172 }
4173
4174 void
4175 modest_ui_actions_on_email_menu_activated (GtkAction *action,
4176                                           ModestWindow *window)
4177 {
4178         g_return_if_fail (MODEST_IS_WINDOW (window));
4179
4180         /* Update dimmed */
4181         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4182 }
4183
4184 void
4185 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
4186                                           ModestWindow *window)
4187 {
4188         g_return_if_fail (MODEST_IS_WINDOW (window));
4189
4190         /* Update dimmed */
4191         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4192 }
4193
4194 void
4195 modest_ui_actions_on_view_menu_activated (GtkAction *action,
4196                                           ModestWindow *window)
4197 {
4198         g_return_if_fail (MODEST_IS_WINDOW (window));
4199
4200         /* Update dimmed */
4201         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4202 }
4203
4204 void
4205 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
4206                                           ModestWindow *window)
4207 {
4208         g_return_if_fail (MODEST_IS_WINDOW (window));
4209
4210         /* Update dimmed */
4211         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4212 }
4213
4214 void
4215 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
4216                                           ModestWindow *window)
4217 {
4218         g_return_if_fail (MODEST_IS_WINDOW (window));
4219
4220         /* Update dimmed */
4221         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4222 }
4223
4224 void
4225 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
4226                                                  ModestWindow *window)
4227 {
4228         g_return_if_fail (MODEST_IS_WINDOW (window));
4229
4230         /* Update dimmed */
4231         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4232 }
4233
4234 void
4235 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
4236                                                      ModestWindow *window)
4237 {
4238         g_return_if_fail (MODEST_IS_WINDOW (window));
4239
4240         /* Update dimmed */
4241         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4242 }
4243
4244 void
4245 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
4246                                                      ModestWindow *window)
4247 {
4248         g_return_if_fail (MODEST_IS_WINDOW (window));
4249
4250         /* Update dimmed */
4251         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4252 }
4253
4254 void
4255 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
4256 {
4257         g_return_if_fail (MODEST_IS_WINDOW (window));
4258
4259         /* Update dimmed */
4260         modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
4261 }
4262
4263 void
4264 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
4265 {
4266         g_return_if_fail (MODEST_IS_WINDOW (window));
4267
4268         modest_platform_show_search_messages (GTK_WINDOW (window));
4269 }
4270
4271 void
4272 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
4273 {
4274         g_return_if_fail (MODEST_IS_WINDOW (win));
4275         modest_platform_show_addressbook (GTK_WINDOW (win));
4276 }
4277
4278
4279 void
4280 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
4281                                           ModestWindow *window)
4282 {
4283         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4284
4285         modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
4286 }
4287
4288 static void
4289 _on_send_receive_progress_changed (ModestMailOperation  *mail_op,
4290                                    ModestMailOperationState *state,
4291                                    gpointer user_data)
4292 {
4293         g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
4294
4295         /* Set send/receive operation finished */
4296         if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
4297                 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));
4298
4299 }
4300
4301