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 #include "modest-protocol-info.h"
  45 #include "modest-tny-platform-factory.h"
  46 #include "modest-platform.h"
  47 #include "modest-debug.h"
  48 #include <tny-mime-part.h>
  49 #include <tny-camel-folder.h>
  50 #include <tny-camel-imap-folder.h>
  51 #include <tny-camel-pop-folder.h>
  52
  53 #ifdef MODEST_PLATFORM_MAEMO
  54 #include "maemo/modest-osso-state-saving.h"
  55 #include "maemo/modest-hildon-includes.h"
  56 #include "maemo/modest-connection-specific-smtp-window.h"
  57 #endif /* MODEST_PLATFORM_MAEMO */
  58 #include <modest-utils.h>
  59
  60 #include "widgets/modest-ui-constants.h"
  61 #include <widgets/modest-main-window.h>
  62 #include <widgets/modest-msg-view-window.h>
  63 #include <widgets/modest-account-view-window.h>
  64 #include <widgets/modest-details-dialog.h>
  65 #include <widgets/modest-attachments-view.h>
  66 #include "widgets/modest-folder-view.h"
  67 #include "widgets/modest-global-settings-dialog.h"
  68 #include "modest-account-mgr-helpers.h"
  69 #include "modest-mail-operation.h"
  70 #include "modest-text-utils.h"
  71
  72 #ifdef MODEST_HAVE_EASYSETUP
  73 #include "easysetup/modest-easysetup-wizard.h"
  74 #endif /* MODEST_HAVE_EASYSETUP */
  75
  76 #include <modest-widget-memory.h>
  77 #include <tny-error.h>
  78 #include <tny-simple-list.h>
  79 #include <tny-msg-view.h>
  80 #include <tny-device.h>
  81 #include <tny-merge-folder.h>
  82
  83 #include <gtkhtml/gtkhtml.h>
  84
  85 typedef struct _GetMsgAsyncHelper {
  86         ModestWindow *window;
  87         ModestMailOperation *mail_op;
  88         TnyIterator *iter;
  89         guint num_ops;
  90         GFunc func;
  91         gpointer user_data;
  92 } GetMsgAsyncHelper;
  93
  94 typedef enum _ReplyForwardAction {
  95         ACTION_REPLY,
  96         ACTION_REPLY_TO_ALL,
  97         ACTION_FORWARD
  98 } ReplyForwardAction;
  99
 100 typedef struct _ReplyForwardHelper {
 101         guint reply_forward_type;
 102         ReplyForwardAction action;
 103         gchar *account_name;
 104         GtkWidget *parent_window;
 105 } ReplyForwardHelper;
 106
 107 typedef struct _MoveToHelper {
 108         GtkTreeRowReference *reference;
 109         GtkWidget *banner;
 110 } MoveToHelper;
 111
 112 typedef struct _PasteAsAttachmentHelper {
 113         ModestMsgEditWindow *window;
 114         GtkWidget *banner;
 115 } PasteAsAttachmentHelper;
 116
 117
 118 /*
 119  * The do_headers_action uses this kind of functions to perform some
 120  * action to each member of a list of headers
 121  */
 122 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
 123
 124 static void     do_headers_action     (ModestWindow *win,
 125                                        HeadersFunc func,
 126                                        gpointer user_data);
 127
 128 static void     open_msg_cb            (ModestMailOperation *mail_op,
 129                                         TnyHeader *header,
 130                                         gboolean canceled,
 131                                         TnyMsg *msg,
 132                                         GError *err,
 133                                         gpointer user_data);
 134
 135 static void     reply_forward_cb       (ModestMailOperation *mail_op,
 136                                         TnyHeader *header,
 137                                         gboolean canceled,
 138                                         TnyMsg *msg,
 139                                         GError *err,
 140                                         gpointer user_data);
 141
 142 static void     reply_forward          (ReplyForwardAction action, ModestWindow *win);
 143
 144 static void     folder_refreshed_cb    (ModestMailOperation *mail_op,
 145                                         TnyFolder *folder,
 146                                         gpointer user_data);
 147
 148 static void     on_send_receive_finished (ModestMailOperation  *mail_op,
 149                                           gpointer user_data);
 150
 151 static gint header_list_count_uncached_msgs (TnyList *header_list);
 152
 153 static gboolean connect_to_get_msg (ModestWindow *win,
 154                                     gint num_of_uncached_msgs,
 155                                     TnyAccount *account);
 156
 157 static gboolean remote_folder_is_pop (TnyFolderStore *folder);
 158
 159 static void     do_create_folder (GtkWindow *window,
 160                                   TnyFolderStore *parent_folder,
 161                                   const gchar *suggested_name);
 162
 163 static GtkWidget* get_folder_view_from_move_to_dialog (GtkWidget *move_to_dialog);
 164
 165 static TnyAccount *get_account_from_folder_store (TnyFolderStore *folder_store);
 166
 167 static void transfer_messages_helper (GtkWindow *win,
 168                                       TnyFolder *src_folder,
 169                                       TnyList *headers,
 170                                       TnyFolder *dst_folder);
 171
 172 /*
 173  * This function checks whether a TnyFolderStore is a pop account
 174  */
 175 static gboolean
 176 remote_folder_is_pop (TnyFolderStore *folder)
 177 {
 178         const gchar *proto = NULL;
 179         TnyAccount *account = NULL;
 180
 181         g_return_val_if_fail (TNY_IS_FOLDER_STORE (folder), FALSE);
 182
 183         account = get_account_from_folder_store (folder);
 184         proto = tny_account_get_proto (account);
 185         g_object_unref (account);
 186
 187         return (modest_protocol_info_get_transport_store_protocol (proto) == MODEST_PROTOCOL_STORE_POP);
 188 }
 189
 190 /* FIXME: this should be merged with the similar code in modest-account-view-window */
 191 /* Show the account creation wizard dialog.
 192  * returns: TRUE if an account was created. FALSE if the user cancelled.
 193  */
 194 gboolean
 195 modest_ui_actions_run_account_setup_wizard (ModestWindow *win)
 196 {
 197         gboolean result = FALSE;
 198         GtkWindow *dialog, *wizard;
 199         gint dialog_response;
 200
 201         /* Show the easy-setup wizard: */
 202         dialog = modest_window_mgr_get_modal (modest_runtime_get_window_mgr());
 203         if (dialog) {
 204                 /* old wizard is active already;
 205                  */
 206                 gtk_window_present (GTK_WINDOW(dialog));
 207                 return FALSE;
 208         }
 209
 210
 211         /* there is no such wizard yet */
 212         wizard = GTK_WINDOW (modest_platform_get_account_settings_wizard ());
 213         modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), wizard);
 214
 215         /* always present a main window in the background
 216          * we do it here, so we cannot end up with two wizards (as this
 217          * function might be called in modest_window_mgr_get_main_window as well */
 218         if (!win)
 219                 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
 220                                                          TRUE);  /* create if not existent */
 221
 222         /* make sure the mainwindow is visible */
 223         gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
 224         gtk_widget_show_all (GTK_WIDGET(win));
 225         gtk_window_present (GTK_WINDOW(win));
 226
 227         dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
 228         gtk_widget_destroy (GTK_WIDGET (wizard));
 229         if (gtk_events_pending ())
 230                 gtk_main_iteration ();
 231
 232         if (dialog_response == GTK_RESPONSE_CANCEL) {
 233                 result = FALSE;
 234         } else {
 235                 /* Check whether an account was created: */
 236                 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
 237         }
 238         return result;
 239 }
 240
 241
 242 void
 243 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
 244 {
 245         GtkWidget *about;
 246         const gchar *authors[] = {
 247                 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
 248                 NULL
 249         };
 250         about = gtk_about_dialog_new ();
 251         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
 252         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
 253         gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
 254                                         _("Copyright (c) 2006, Nokia Corporation\n"
 255                                           "All rights reserved."));
 256         gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
 257                                        _("a modest e-mail client\n\n"
 258                                          "design and implementation: Dirk-Jan C. Binnema\n"
 259                                          "contributions from the fine people at KC and Ig\n"
 260                                          "uses the tinymail email framework written by Philip van Hoof"));
 261         gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
 262         gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
 263         gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
 264         gtk_window_set_modal (GTK_WINDOW (about), TRUE);
 265
 266         gtk_dialog_run (GTK_DIALOG (about));
 267         gtk_widget_destroy(about);
 268 }
 269
 270 /*
 271  * Gets the list of currently selected messages. If the win is the
 272  * main window, then it returns a newly allocated list of the headers
 273  * selected in the header view. If win is the msg view window, then
 274  * the value returned is a list with just a single header.
 275  *
 276  * The caller of this funcion must free the list.
 277  */
 278 static TnyList *
 279 get_selected_headers (ModestWindow *win)
 280 {
 281         if (MODEST_IS_MAIN_WINDOW(win)) {
 282                 GtkWidget *header_view;
 283
 284                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 285                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
 286                 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 287
 288         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 289                 /* for MsgViewWindows, we simply return a list with one element */
 290                 TnyHeader *header;
 291                 TnyList *list = NULL;
 292
 293                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
 294                 if (header != NULL) {
 295                         list = tny_simple_list_new ();
 296                         tny_list_prepend (list, G_OBJECT(header));
 297                         g_object_unref (G_OBJECT(header));
 298                 }
 299
 300                 return list;
 301
 302         } else
 303                 return NULL;
 304 }
 305
 306 static GtkTreeRowReference *
 307 get_next_after_selected_headers (ModestHeaderView *header_view)
 308 {
 309         GtkTreeSelection *sel;
 310         GList *selected_rows, *node;
 311         GtkTreePath *path;
 312         GtkTreeRowReference *result;
 313         GtkTreeModel *model;
 314
 315         model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
 316         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 317         selected_rows = gtk_tree_selection_get_selected_rows (sel, NULL);
 318
 319         if (selected_rows == NULL)
 320                 return NULL;
 321
 322         node = g_list_last (selected_rows);
 323         path = gtk_tree_path_copy ((GtkTreePath *) node->data);
 324         gtk_tree_path_next (path);
 325
 326         result = gtk_tree_row_reference_new (model, path);
 327
 328         gtk_tree_path_free (path);
 329         g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
 330         g_list_free (selected_rows);
 331
 332         return result;
 333 }
 334
 335 static void
 336 headers_action_mark_as_read (TnyHeader *header,
 337                              ModestWindow *win,
 338                              gpointer user_data)
 339 {
 340         TnyHeaderFlags flags;
 341
 342         g_return_if_fail (TNY_IS_HEADER(header));
 343
 344         flags = tny_header_get_flags (header);
 345         if (flags & TNY_HEADER_FLAG_SEEN) return;
 346         tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
 347 }
 348
 349 static void
 350 headers_action_mark_as_unread (TnyHeader *header,
 351                                ModestWindow *win,
 352                                gpointer user_data)
 353 {
 354         TnyHeaderFlags flags;
 355
 356         g_return_if_fail (TNY_IS_HEADER(header));
 357
 358         flags = tny_header_get_flags (header);
 359         if (flags & TNY_HEADER_FLAG_SEEN)  {
 360                 tny_header_unset_flag (header, TNY_HEADER_FLAG_SEEN);
 361         }
 362 }
 363
 364 /** After deleing a message that is currently visible in a window,
 365  * show the next message from the list, or close the window if there are no more messages.
 366  **/
 367 void
 368 modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
 369 {
 370         /* Close msg view window or select next */
 371         if (!modest_msg_view_window_select_next_message (win) &&
 372             !modest_msg_view_window_select_previous_message (win)) {
 373                 gboolean ret_value;
 374                 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 375         }
 376 }
 377
 378
 379 void
 380 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
 381 {
 382         TnyList *header_list = NULL;
 383         TnyIterator *iter = NULL;
 384         TnyHeader *header = NULL;
 385         gchar *message = NULL;
 386         gchar *desc = NULL;
 387         gint response;
 388         ModestWindowMgr *mgr;
 389         GtkWidget *header_view = NULL;
 390
 391         g_return_if_fail (MODEST_IS_WINDOW(win));
 392
 393         /* Check first if the header view has the focus */
 394         if (MODEST_IS_MAIN_WINDOW (win)) {
 395                 header_view =
 396                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 397                                                              MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
 398                 if (!gtk_widget_is_focus (header_view))
 399                         return;
 400         }
 401
 402         /* Get the headers, either from the header view (if win is the main window),
 403          * or from the message view window: */
 404         header_list = get_selected_headers (win);
 405         if (!header_list) return;
 406
 407         /* Check if any of the headers are already opened, or in the process of being opened */
 408         if (MODEST_IS_MAIN_WINDOW (win)) {
 409                 gint opened_headers = 0;
 410
 411                 iter = tny_list_create_iterator (header_list);
 412                 mgr = modest_runtime_get_window_mgr ();
 413                 while (!tny_iterator_is_done (iter)) {
 414                         header = TNY_HEADER (tny_iterator_get_current (iter));
 415                         if (header) {
 416                                 if (modest_window_mgr_find_registered_header (mgr, header, NULL))
 417                                         opened_headers++;
 418                                 g_object_unref (header);
 419                         }
 420                         tny_iterator_next (iter);
 421                 }
 422                 g_object_unref (iter);
 423
 424                 if (opened_headers > 0) {
 425                         gchar *msg;
 426
 427                         msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"),
 428                                                opened_headers);
 429
 430                         modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
 431
 432                         g_free (msg);
 433                         g_object_unref (header_list);
 434                         return;
 435                 }
 436         }
 437
 438         /* Select message */
 439         if (tny_list_get_length(header_list) == 1) {
 440                 iter = tny_list_create_iterator (header_list);
 441                 header = TNY_HEADER (tny_iterator_get_current (iter));
 442                 if (header) {
 443                         desc = g_strdup_printf ("%s", tny_header_get_subject (header));
 444                         g_object_unref (header);
 445                 }
 446
 447                 g_object_unref (iter);
 448         }
 449         message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
 450                                            tny_list_get_length(header_list)), desc);
 451
 452         /* Confirmation dialog */
 453         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
 454                                                             message);
 455
 456
 457         if (response == GTK_RESPONSE_OK) {
 458                 ModestWindow *main_window = NULL;
 459                 ModestWindowMgr *mgr = NULL;
 460                 GtkTreeModel *model = NULL;
 461                 GtkTreeSelection *sel = NULL;
 462                 GList *sel_list = NULL, *tmp = NULL;
 463                 GtkTreeRowReference *next_row_reference = NULL;
 464                 GtkTreeRowReference *prev_row_reference = NULL;
 465                 GtkTreePath *next_path = NULL;
 466                 GtkTreePath *prev_path = NULL;
 467                 ModestMailOperation *mail_op = NULL;
 468
 469                 /* Find last selected row */
 470                 if (MODEST_IS_MAIN_WINDOW (win)) {
 471                         model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
 472                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 473                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 474                         for (tmp=sel_list; tmp; tmp=tmp->next) {
 475                                 if (tmp->next == NULL) {
 476                                         prev_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
 477                                         next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
 478
 479                                         gtk_tree_path_prev (prev_path);
 480                                         gtk_tree_path_next (next_path);
 481
 482                                         prev_row_reference = gtk_tree_row_reference_new (model, prev_path);
 483                                         next_row_reference = gtk_tree_row_reference_new (model, next_path);
 484                                 }
 485                         }
 486                 }
 487
 488                 /* Disable window dimming management */
 489                 modest_window_disable_dimming (MODEST_WINDOW(win));
 490
 491                 /* Remove each header. If it's a view window header_view == NULL */
 492                 mail_op = modest_mail_operation_new ((GObject *) win);
 493                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 494                                                  mail_op);
 495                 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
 496                 g_object_unref (mail_op);
 497
 498                 /* Enable window dimming management */
 499                 if (sel != NULL) {
 500                         gtk_tree_selection_unselect_all (sel);
 501                 }
 502                 modest_window_enable_dimming (MODEST_WINDOW(win));
 503
 504                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 505                         modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
 506
 507                         /* Get main window */
 508                         mgr = modest_runtime_get_window_mgr ();
 509                         main_window = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
 510                 } else {
 511                         /* Move cursor to next row */
 512                         main_window = win;
 513
 514                         /* Select next or previous row */
 515                         if (gtk_tree_row_reference_valid (next_row_reference)) {
 516 /*                              next_path = gtk_tree_row_reference_get_path (row_reference); */
 517                                 gtk_tree_selection_select_path (sel, next_path);
 518                         }
 519                         else if (gtk_tree_row_reference_valid (prev_row_reference)) {
 520                                 gtk_tree_selection_select_path (sel, prev_path);
 521                         }
 522
 523                         /* Free */
 524                         if (next_row_reference != NULL)
 525                                 gtk_tree_row_reference_free (next_row_reference);
 526                         if (next_path != NULL)
 527                                 gtk_tree_path_free (next_path);
 528                         if (prev_row_reference != NULL)
 529                                 gtk_tree_row_reference_free (prev_row_reference);
 530                         if (prev_path != NULL)
 531                                 gtk_tree_path_free (prev_path);
 532                 }
 533
 534                 /* Update toolbar dimming state */
 535                 if (main_window)
 536                         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
 537
 538                 /* Free */
 539                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 540                 g_list_free (sel_list);
 541         }
 542
 543         /* Free*/
 544         g_free(message);
 545         g_free(desc);
 546         g_object_unref (header_list);
 547 }
 548
 549
 550
 551
 552 /* delete either message or folder, based on where we are */
 553 void
 554 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
 555 {
 556         g_return_if_fail (MODEST_IS_WINDOW(win));
 557
 558         /* Check first if the header view has the focus */
 559         if (MODEST_IS_MAIN_WINDOW (win)) {
 560                 GtkWidget *w;
 561                 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 562                                                          MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
 563                 if (gtk_widget_is_focus (w)) {
 564                         modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
 565                         return;
 566                 }
 567         }
 568         modest_ui_actions_on_delete_message (action, win);
 569 }
 570
 571 void
 572 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
 573 {
 574         ModestWindowMgr *mgr = NULL;
 575
 576 #ifdef MODEST_PLATFORM_MAEMO
 577         modest_osso_save_state();
 578 #endif /* MODEST_PLATFORM_MAEMO */
 579
 580         g_debug ("closing down, clearing %d item(s) from operation queue",
 581                  modest_mail_operation_queue_num_elements
 582                  (modest_runtime_get_mail_operation_queue()));
 583
 584         /* cancel all outstanding operations */
 585         modest_mail_operation_queue_cancel_all
 586                 (modest_runtime_get_mail_operation_queue());
 587
 588         g_debug ("queue has been cleared");
 589
 590
 591         /* Check if there are opened editing windows */
 592         mgr = modest_runtime_get_window_mgr ();
 593         modest_window_mgr_close_all_windows (mgr);
 594
 595         /* note: when modest-tny-account-store is finalized,
 596            it will automatically set all network connections
 597            to offline */
 598
 599 /*      gtk_main_quit (); */
 600 }
 601
 602 void
 603 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
 604 {
 605         gboolean ret_value;
 606
 607         g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 608
 609 /*      if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
 610 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
 611 /*      } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
 612 /*              gboolean ret_value; */
 613 /*              g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
 614 /*      } else if (MODEST_IS_WINDOW (win)) { */
 615 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
 616 /*      } else { */
 617 /*              g_return_if_reached (); */
 618 /*      } */
 619 }
 620
 621 void
 622 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
 623 {
 624         GtkClipboard *clipboard = NULL;
 625         gchar *selection = NULL;
 626
 627         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 628         selection = gtk_clipboard_wait_for_text (clipboard);
 629
 630         /* Question: why is the clipboard being used here?
 631          * It doesn't really make a lot of sense. */
 632
 633         if (selection)
 634         {
 635                 modest_address_book_add_address (selection);
 636                 g_free (selection);
 637         }
 638 }
 639
 640 void
 641 modest_ui_actions_on_accounts (GtkAction *action,
 642                                ModestWindow *win)
 643 {
 644         /* This is currently only implemented for Maemo */
 645         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
 646                 if (!modest_ui_actions_run_account_setup_wizard (win))
 647                         g_debug ("%s: wizard was already running", __FUNCTION__);
 648
 649                 return;
 650         } else {
 651                 /* Show the list of accounts */
 652                 GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
 653                 gtk_window_set_transient_for (account_win, GTK_WINDOW (win));
 654
 655                 /* The accounts dialog must be modal */
 656                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), account_win);
 657                 modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
 658         }
 659 }
 660
 661 #ifdef MODEST_PLATFORM_MAEMO
 662 static void
 663 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
 664 {
 665         /* Save any changes. */
 666         modest_connection_specific_smtp_window_save_server_accounts (
 667                         MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window));
 668         gtk_widget_destroy (GTK_WIDGET (window));
 669 }
 670 #endif
 671
 672
 673 void
 674 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
 675 {
 676         /* This is currently only implemented for Maemo,
 677          * because it requires an API (libconic) to detect different connection
 678          * possiblities.
 679          */
 680 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 681
 682         /* Create the window if necessary: */
 683         GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
 684         modest_connection_specific_smtp_window_fill_with_connections (
 685                 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
 686                 modest_runtime_get_account_mgr());
 687
 688         /* Show the window: */
 689         gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
 690         gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
 691         gtk_widget_show (specific_window);
 692
 693         /* Save changes when the window is hidden: */
 694         g_signal_connect (specific_window, "hide",
 695                 G_CALLBACK (on_smtp_servers_window_hide), win);
 696 #endif /* MODEST_PLATFORM_MAEMO */
 697 }
 698
 699 void
 700 modest_ui_actions_compose_msg(ModestWindow *win,
 701                               const gchar *to_str,
 702                               const gchar *cc_str,
 703                               const gchar *bcc_str,
 704                               const gchar *subject_str,
 705                               const gchar *body_str,
 706                               GSList *attachments,
 707                               gboolean set_as_modified)
 708 {
 709         gchar *account_name = NULL;
 710         TnyMsg *msg = NULL;
 711         TnyAccount *account = NULL;
 712         TnyFolder *folder = NULL;
 713         gchar *from_str = NULL, *signature = NULL, *body = NULL;
 714         gboolean use_signature = FALSE;
 715         ModestWindow *msg_win = NULL;
 716         ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
 717         ModestTnyAccountStore *store = modest_runtime_get_account_store();
 718
 719         account_name = modest_account_mgr_get_default_account(mgr);
 720         if (!account_name) {
 721                 g_printerr ("modest: no account found\n");
 722                 goto cleanup;
 723         }
 724         account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
 725         if (!account) {
 726                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
 727                 goto cleanup;
 728         }
 729         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 730         if (!folder) {
 731                 g_printerr ("modest: failed to find Drafts folder\n");
 732                 goto cleanup;
 733         }
 734         from_str = modest_account_mgr_get_from_string (mgr, account_name);
 735         if (!from_str) {
 736                 g_printerr ("modest: failed get from string for '%s'\n", account_name);
 737                 goto cleanup;
 738         }
 739
 740         signature = modest_account_mgr_get_signature (mgr, account_name, &use_signature);
 741         if (body_str != NULL) {
 742                 body = use_signature ? g_strconcat(body_str, "\n", signature, NULL) : g_strdup(body_str);
 743         } else {
 744                 body = use_signature ? g_strconcat("\n", signature, NULL) : g_strdup("");
 745         }
 746
 747         msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, body, NULL);
 748         if (!msg) {
 749                 g_printerr ("modest: failed to create new msg\n");
 750                 goto cleanup;
 751         }
 752
 753         /* Create and register edit window */
 754         /* This is destroyed by TODO. */
 755         msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
 756         while (attachments) {
 757                 modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
 758                                                        attachments->data);
 759                 attachments = g_slist_next(attachments);
 760         }
 761         modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win);
 762         modest_msg_edit_window_set_modified (MODEST_MSG_EDIT_WINDOW (msg_win), set_as_modified);
 763
 764         gtk_widget_show_all (GTK_WIDGET (msg_win));
 765
 766 cleanup:
 767         g_free (from_str);
 768         g_free (signature);
 769         g_free (body);
 770         g_free (account_name);
 771         if (account) g_object_unref (G_OBJECT(account));
 772         if (folder) g_object_unref (G_OBJECT(folder));
 773         if (msg_win) g_object_unref (G_OBJECT(msg_win));
 774         if (msg) g_object_unref (G_OBJECT(msg));
 775 }
 776
 777 void
 778 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
 779 {
 780         /* if there are no accounts yet, just show the wizard */
 781         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
 782                 if (!modest_ui_actions_run_account_setup_wizard (win))
 783                         return;
 784
 785         modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL, FALSE);
 786 }
 787
 788
 789 gboolean
 790 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
 791                                        TnyHeader *header,
 792                                        TnyMsg *msg)
 793 {
 794         ModestMailOperationStatus status;
 795
 796         /* If there is no message or the operation was not successful */
 797         status = modest_mail_operation_get_status (mail_op);
 798         if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
 799
 800                 /* Remove the header from the preregistered uids */
 801                 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
 802                                                      header);
 803
 804                 return FALSE;
 805         }
 806
 807         return TRUE;
 808 }
 809
 810 typedef struct {
 811         guint idle_handler;
 812         gchar *message;
 813         GtkWidget *banner;
 814 } OpenMsgBannerInfo;
 815
 816 gboolean
 817 open_msg_banner_idle (gpointer userdata)
 818 {
 819         OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) userdata;
 820
 821         gdk_threads_enter ();
 822         banner_info->idle_handler = 0;
 823         banner_info->banner = modest_platform_animation_banner (NULL, NULL, banner_info->message);
 824         g_object_ref (banner_info->banner);
 825
 826         gdk_threads_leave ();
 827
 828         return FALSE;
 829
 830 }
 831
 832 static void
 833 open_msg_cb (ModestMailOperation *mail_op,
 834              TnyHeader *header,
 835              gboolean canceled,
 836              TnyMsg *msg,
 837              GError *err,
 838              gpointer user_data)
 839 {
 840         ModestWindowMgr *mgr = NULL;
 841         ModestWindow *parent_win = NULL;
 842         ModestWindow *win = NULL;
 843         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
 844         gchar *account = NULL;
 845         TnyFolder *folder;
 846         gboolean open_in_editor = FALSE;
 847         OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) user_data;
 848
 849         /* Do nothing if there was any problem with the mail
 850            operation. The error will be shown by the error_handler of
 851            the mail operation */
 852         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
 853                 goto banner_cleanup;
 854
 855         parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
 856         folder = tny_header_get_folder (header);
 857
 858         /* Mark header as read */
 859         headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
 860
 861         /* Gets folder type (OUTBOX headers will be opened in edit window */
 862         if (modest_tny_folder_is_local_folder (folder)) {
 863                 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
 864                 if (folder_type == TNY_FOLDER_TYPE_INVALID)
 865                         g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
 866         }
 867
 868
 869         if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
 870                 TnyTransportAccount *traccount = NULL;
 871                 ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
 872                 traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
 873                 if (traccount) {
 874                         ModestTnySendQueue *send_queue = NULL;
 875                         ModestTnySendQueueStatus status;
 876                         char *msg_id;
 877                         account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
 878                                                    TNY_ACCOUNT(traccount)));
 879                         send_queue = modest_runtime_get_send_queue(traccount);
 880                         msg_id = modest_tny_send_queue_get_msg_id (header);
 881                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
 882                         /* Only open messages in outbox with the editor if they are in Failed state */
 883                         if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
 884                                 open_in_editor = TRUE;
 885                         }
 886                         g_free(msg_id);
 887                         g_object_unref(traccount);
 888                 } else {
 889                         g_warning("Cannot get transport account for message in outbox!!");
 890                 }
 891         } else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
 892                 open_in_editor = TRUE; /* Open in editor if the message is in the Drafts folder */
 893         }
 894
 895         /* Get account */
 896         if (!account)
 897                 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
 898         if (!account)
 899                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 900
 901         if (open_in_editor) {
 902                 ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
 903                 const gchar *from_header = NULL;
 904
 905                 from_header = tny_header_get_from (header);
 906
 907                 /* we cannot edit without a valid account... */
 908                 if (!modest_account_mgr_has_accounts(mgr, TRUE)) {
 909                         if (!modest_ui_actions_run_account_setup_wizard(parent_win))
 910                                 goto cleanup;
 911                 }
 912
 913                 if (from_header) {
 914                         GSList *accounts = modest_account_mgr_account_names (mgr, TRUE);
 915                         GSList *node = NULL;
 916                         for (node = accounts; node != NULL; node = g_slist_next (node)) {
 917                                 gchar *from = modest_account_mgr_get_from_string (mgr, node->data);
 918
 919                                 if (from && (strcmp (from_header, from) == 0)) {
 920                                         g_free (account);
 921                                         account = g_strdup (node->data);
 922                                         g_free (from);
 923                                         break;
 924                                 }
 925                                 g_free (from);
 926                         }
 927                         g_slist_foreach (accounts, (GFunc) g_free, NULL);
 928                         g_slist_free (accounts);
 929                 }
 930
 931                 win = modest_msg_edit_window_new (msg, account, TRUE);
 932
 933
 934
 935         } else {
 936                 gchar *uid = modest_tny_folder_get_header_unique_id (header);
 937
 938                 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
 939                         GtkWidget *header_view;
 940                         GtkTreeSelection *sel;
 941                         GList *sel_list = NULL;
 942                         GtkTreeModel *model;
 943
 944                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
 945                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
 946
 947                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 948                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 949
 950                         if (sel_list != NULL) {
 951                                 GtkTreeRowReference *row_reference;
 952
 953                                 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
 954                                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 955                                 g_list_free (sel_list);
 956
 957                                 win = modest_msg_view_window_new_with_header_model (
 958                                                 msg, account, (const gchar*) uid,
 959                                                 model, row_reference);
 960                                 gtk_tree_row_reference_free (row_reference);
 961                         } else {
 962                                 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
 963                         }
 964                 } else {
 965                         win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
 966                 }
 967                 g_free (uid);
 968         }
 969
 970         /* Register and show new window */
 971         if (win != NULL) {
 972                 mgr = modest_runtime_get_window_mgr ();
 973                 modest_window_mgr_register_window (mgr, win);
 974                 g_object_unref (win);
 975                 gtk_widget_show_all (GTK_WIDGET(win));
 976         }
 977
 978         /* Update toolbar dimming state */
 979         if (MODEST_IS_MAIN_WINDOW (parent_win)) {
 980                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
 981         }
 982
 983 cleanup:
 984         /* Free */
 985         g_free(account);
 986         g_object_unref (parent_win);
 987         g_object_unref (folder);
 988 banner_cleanup:
 989         if (banner_info) {
 990                 g_free (banner_info->message);
 991                 if (banner_info->idle_handler > 0) {
 992                         g_source_remove (banner_info->idle_handler);
 993                         banner_info->idle_handler = 0;
 994                 }
 995                 if (banner_info->banner != NULL) {
 996                         gtk_widget_destroy (banner_info->banner);
 997                         g_object_unref (banner_info->banner);
 998                         banner_info->banner = NULL;
 999                 }
1000                 g_slice_free (OpenMsgBannerInfo, banner_info);
1001         }
1002 }
1003
1004 void
1005 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
1006                                                gpointer user_data)
1007 {
1008         const GError *error;
1009         GObject *win = NULL;
1010
1011         win = modest_mail_operation_get_source (mail_op);
1012         error = modest_mail_operation_get_error (mail_op);
1013
1014         /* Show error */
1015         if (error->code == TNY_SYSTEM_ERROR_MEMORY ||
1016             error->code == TNY_IO_ERROR_WRITE ||
1017             error->code == TNY_IO_ERROR_READ) {
1018                 ModestMailOperationStatus st = modest_mail_operation_get_status (mail_op);
1019                 /* If the mail op has been cancelled then it's not an error: don't show any message */
1020                 if (st != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
1021                         modest_platform_information_banner ((GtkWidget *) win,
1022                                                             NULL, dgettext("ke-recv",
1023                                                                            "cerm_device_memory_full"));
1024                 }
1025         } else if (user_data) {
1026                 modest_platform_information_banner ((GtkWidget *) win,
1027                                                     NULL, user_data);
1028         }
1029
1030         if (win)
1031                 g_object_unref (win);
1032 }
1033
1034 /**
1035  * Returns the account a list of headers belongs to. It returns a
1036  * *new* reference so don't forget to unref it
1037  */
1038 static TnyAccount*
1039 get_account_from_header_list (TnyList *headers)
1040 {
1041         TnyAccount *account = NULL;
1042
1043         if (tny_list_get_length (headers) > 0) {
1044                 TnyIterator *iter = tny_list_create_iterator (headers);
1045                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1046                 TnyFolder *folder = tny_header_get_folder (header);
1047                 account = tny_folder_get_account (folder);
1048                 g_object_unref (folder);
1049                 g_object_unref (header);
1050                 g_object_unref (iter);
1051         }
1052         return account;
1053 }
1054
1055 static void
1056 foreach_unregister_headers (gpointer data,
1057                             gpointer user_data)
1058 {
1059         ModestWindowMgr *mgr = (ModestWindowMgr *) user_data;
1060         TnyHeader *header = TNY_HEADER (data);
1061
1062         modest_window_mgr_unregister_header (mgr, header);
1063 }
1064
1065 static void
1066 open_msgs_performer(gboolean canceled,
1067                     GError *err,
1068                     GtkWindow *parent_window,
1069                     TnyAccount *account,
1070                     gpointer user_data)
1071 {
1072         ModestMailOperation *mail_op = NULL;
1073         const gchar *proto_name;
1074         gchar *error_msg;
1075         ModestTransportStoreProtocol proto;
1076         TnyList *not_opened_headers;
1077         TnyConnectionStatus status;
1078         gboolean show_open_draft = FALSE;
1079         OpenMsgBannerInfo *banner_info = NULL;
1080
1081         not_opened_headers = TNY_LIST (user_data);
1082
1083         status = tny_account_get_connection_status (account);
1084         if (err || canceled) {
1085                 /* Unregister the already registered headers */
1086                 tny_list_foreach (not_opened_headers, foreach_unregister_headers,
1087                                   modest_runtime_get_window_mgr ());
1088                 goto clean;
1089         }
1090
1091         /* Get the error message depending on the protocol */
1092         proto_name = tny_account_get_proto (account);
1093         if (proto_name != NULL) {
1094                 proto = modest_protocol_info_get_transport_store_protocol (proto_name);
1095         } else {
1096                 proto = MODEST_PROTOCOL_STORE_MAILDIR;
1097         }
1098
1099         /* Create the error messages */
1100         if (tny_list_get_length (not_opened_headers) == 1) {
1101                 if (proto == MODEST_PROTOCOL_STORE_POP) {
1102                         error_msg = g_strdup (_("emev_ni_ui_pop3_msg_recv_error"));
1103                 } else if (proto == MODEST_PROTOCOL_STORE_IMAP) {
1104                         TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
1105                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1106                         error_msg = g_strdup_printf (_("emev_ni_ui_imap_message_not_available_in_server"),
1107                                                      tny_header_get_subject (header));
1108                         g_object_unref (header);
1109                         g_object_unref (iter);
1110                 } else {
1111                         TnyHeader *header;
1112                         TnyFolder *folder;
1113                         TnyIterator *iter;
1114                         TnyFolderType folder_type;
1115
1116                         iter = tny_list_create_iterator (not_opened_headers);
1117                         header = TNY_HEADER (tny_iterator_get_current (iter));
1118                         folder = tny_header_get_folder (header);
1119                         folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1120                         show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
1121                         g_object_unref (folder);
1122                         g_object_unref (header);
1123                         g_object_unref (iter);
1124                         error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1125                 }
1126         } else {
1127                 error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1128         }
1129
1130         /* Create the mail operation */
1131         mail_op =
1132                 modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
1133                                                                modest_ui_actions_get_msgs_full_error_handler,
1134                                                                error_msg, g_free);
1135         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1136                                          mail_op);
1137
1138         if (show_open_draft) {
1139                 banner_info = g_slice_new (OpenMsgBannerInfo);
1140                 banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
1141                 banner_info->banner = NULL;
1142                 banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle, banner_info);
1143         }
1144
1145         modest_mail_operation_get_msgs_full (mail_op,
1146                                              not_opened_headers,
1147                                              open_msg_cb,
1148                                              banner_info,
1149                                              NULL);
1150
1151         /* Frees */
1152  clean:
1153         if (mail_op)
1154                 g_object_unref (mail_op);
1155         g_object_unref (not_opened_headers);
1156         g_object_unref (account);
1157 }
1158
1159 /*
1160  * This function is used by both modest_ui_actions_on_open and
1161  * modest_ui_actions_on_header_activated. This way we always do the
1162  * same when trying to open messages.
1163  */
1164 static void
1165 open_msgs_from_headers (TnyList *headers, ModestWindow *win)
1166 {
1167         ModestWindowMgr *mgr = NULL;
1168         TnyIterator *iter = NULL, *iter_not_opened = NULL;
1169         TnyList *not_opened_headers = NULL;
1170         TnyHeaderFlags flags = 0;
1171         TnyAccount *account;
1172         gint uncached_msgs = 0;
1173
1174         g_return_if_fail (headers != NULL);
1175
1176         /* Check that only one message is selected for opening */
1177         if (tny_list_get_length (headers) != 1) {
1178                 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1179                                                         _("mcen_ib_select_one_message"));
1180                 return;
1181         }
1182
1183         mgr = modest_runtime_get_window_mgr ();
1184         iter = tny_list_create_iterator (headers);
1185
1186         /* Get the account */
1187         account = get_account_from_header_list (headers);
1188
1189         /* Look if we already have a message view for each header. If
1190            true, then remove the header from the list of headers to
1191            open */
1192         not_opened_headers = tny_simple_list_new ();
1193         while (!tny_iterator_is_done (iter)) {
1194
1195                 ModestWindow *window = NULL;
1196                 TnyHeader *header = NULL;
1197                 gboolean found = FALSE;
1198
1199                 header = TNY_HEADER (tny_iterator_get_current (iter));
1200                 if (header)
1201                         flags = tny_header_get_flags (header);
1202
1203                 window = NULL;
1204                 found = modest_window_mgr_find_registered_header (mgr, header, &window);
1205
1206                 /* Do not open again the message and present the
1207                    window to the user */
1208                 if (found) {
1209                         if (window)
1210                                 gtk_window_present (GTK_WINDOW (window));
1211                         else
1212                                 /* the header has been registered already, we don't do
1213                                  * anything but wait for the window to come up*/
1214                                 g_debug ("header %p already registered, waiting for window", header);
1215                 } else {
1216                         tny_list_append (not_opened_headers, G_OBJECT (header));
1217                 }
1218
1219                 if (header)
1220                         g_object_unref (header);
1221
1222                 tny_iterator_next (iter);
1223         }
1224         g_object_unref (iter);
1225         iter = NULL;
1226
1227         /* Open each message */
1228         if (tny_list_get_length (not_opened_headers) == 0)
1229                 goto cleanup;
1230
1231         /* If some messages would have to be downloaded, ask the user to
1232          * make a connection. It's generally easier to do this here (in the mainloop)
1233          * than later in a thread:
1234          */
1235         if (tny_list_get_length (not_opened_headers) > 0) {
1236                 uncached_msgs = header_list_count_uncached_msgs (not_opened_headers);
1237
1238                 if (uncached_msgs > 0) {
1239                         /* Allways download if we are online. */
1240                         if (!tny_device_is_online (modest_runtime_get_device ())) {
1241                                 gint response;
1242
1243                                 /* If ask for user permission to download the messages */
1244                                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1245                                                                                     ngettext("mcen_nc_get_msg",
1246                                                                                              "mcen_nc_get_msgs",
1247                                                                                              uncached_msgs));
1248
1249                                 /* End if the user does not want to continue */
1250                                 if (response == GTK_RESPONSE_CANCEL)
1251                                         goto cleanup;
1252                         }
1253                 }
1254         }
1255
1256         /* Register the headers before actually creating the windows: */
1257         iter_not_opened = tny_list_create_iterator (not_opened_headers);
1258         while (!tny_iterator_is_done (iter_not_opened)) {
1259                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
1260                 if (header) {
1261                         modest_window_mgr_register_header (mgr, header, NULL);
1262                         g_object_unref (header);
1263                 }
1264                 tny_iterator_next (iter_not_opened);
1265         }
1266         g_object_unref (iter_not_opened);
1267         iter_not_opened = NULL;
1268
1269         /* Connect to the account and perform */
1270         if (uncached_msgs > 0) {
1271                 modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
1272                                                      open_msgs_performer, g_object_ref (not_opened_headers));
1273         } else {
1274                 /* Call directly the performer, do not need to connect */
1275                 open_msgs_performer (FALSE, NULL, (GtkWindow *) win, g_object_ref (account),
1276                                      g_object_ref (not_opened_headers));
1277         }
1278 cleanup:
1279         /* Clean */
1280         if (account)
1281                 g_object_unref (account);
1282         if (not_opened_headers)
1283                 g_object_unref (not_opened_headers);
1284 }
1285
1286 void
1287 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1288 {
1289         TnyList *headers;
1290
1291         /* Get headers */
1292         headers = get_selected_headers (win);
1293         if (!headers)
1294                 return;
1295
1296         /* Open them */
1297         open_msgs_from_headers (headers, win);
1298
1299         g_object_unref(headers);
1300 }
1301
1302
1303 static void
1304 free_reply_forward_helper (gpointer data)
1305 {
1306         ReplyForwardHelper *helper;
1307
1308         helper = (ReplyForwardHelper *) data;
1309         g_free (helper->account_name);
1310         g_slice_free (ReplyForwardHelper, helper);
1311 }
1312
1313 static void
1314 reply_forward_cb (ModestMailOperation *mail_op,
1315                   TnyHeader *header,
1316                   gboolean canceled,
1317                   TnyMsg *msg,
1318                   GError *err,
1319                   gpointer user_data)
1320 {
1321         TnyMsg *new_msg;
1322         ReplyForwardHelper *rf_helper;
1323         ModestWindow *msg_win = NULL;
1324         ModestEditType edit_type;
1325         gchar *from = NULL;
1326         TnyAccount *account = NULL;
1327         ModestWindowMgr *mgr = NULL;
1328         gchar *signature = NULL;
1329         gboolean use_signature;
1330
1331         /* If there was any error. The mail operation could be NULL,
1332            this means that we already have the message downloaded and
1333            that we didn't do a mail operation to retrieve it */
1334         if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1335                 return;
1336
1337         g_return_if_fail (user_data != NULL);
1338         rf_helper = (ReplyForwardHelper *) user_data;
1339
1340         from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1341                                                    rf_helper->account_name);
1342         signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr(),
1343                                                       rf_helper->account_name,
1344                                                       &use_signature);
1345
1346         /* Create reply mail */
1347         switch (rf_helper->action) {
1348         case ACTION_REPLY:
1349                 new_msg =
1350                         modest_tny_msg_create_reply_msg (msg, header, from,
1351                                                          (use_signature) ? signature : NULL,
1352                                                          rf_helper->reply_forward_type,
1353                                                          MODEST_TNY_MSG_REPLY_MODE_SENDER);
1354                 break;
1355         case ACTION_REPLY_TO_ALL:
1356                 new_msg =
1357                         modest_tny_msg_create_reply_msg (msg, header, from,
1358                                                          (use_signature) ? signature : NULL,
1359                                                          rf_helper->reply_forward_type,
1360                                                          MODEST_TNY_MSG_REPLY_MODE_ALL);
1361                 edit_type = MODEST_EDIT_TYPE_REPLY;
1362                 break;
1363         case ACTION_FORWARD:
1364                 new_msg =
1365                         modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL,
1366                                                            rf_helper->reply_forward_type);
1367                 edit_type = MODEST_EDIT_TYPE_FORWARD;
1368                 break;
1369         default:
1370                 g_return_if_reached ();
1371                 return;
1372         }
1373
1374         g_free (signature);
1375
1376         if (!new_msg) {
1377                 g_printerr ("modest: failed to create message\n");
1378                 goto cleanup;
1379         }
1380
1381         account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1382                                                                        rf_helper->account_name,
1383                                                                        TNY_ACCOUNT_TYPE_STORE);
1384         if (!account) {
1385                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1386                 goto cleanup;
1387         }
1388
1389         /* Create and register the windows */
1390         msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
1391         mgr = modest_runtime_get_window_mgr ();
1392         modest_window_mgr_register_window (mgr, msg_win);
1393
1394         if (rf_helper->parent_window != NULL) {
1395                 gdouble parent_zoom;
1396
1397                 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1398                 modest_window_set_zoom (msg_win, parent_zoom);
1399         }
1400
1401         /* Show edit window */
1402         gtk_widget_show_all (GTK_WIDGET (msg_win));
1403
1404 cleanup:
1405         if (msg_win)
1406                 g_object_unref (msg_win);
1407         if (new_msg)
1408                 g_object_unref (G_OBJECT (new_msg));
1409         if (account)
1410                 g_object_unref (G_OBJECT (account));
1411 /*      g_object_unref (msg); */
1412         free_reply_forward_helper (rf_helper);
1413 }
1414
1415 /* Checks a list of headers. If any of them are not currently
1416  * downloaded (CACHED) then returns TRUE else returns FALSE.
1417  */
1418 static gint
1419 header_list_count_uncached_msgs (TnyList *header_list)
1420 {
1421         TnyIterator *iter;
1422         gint uncached_messages = 0;
1423
1424         iter = tny_list_create_iterator (header_list);
1425         while (!tny_iterator_is_done (iter)) {
1426                 TnyHeader *header;
1427
1428                 header = TNY_HEADER (tny_iterator_get_current (iter));
1429                 if (header) {
1430                         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1431                                 uncached_messages ++;
1432                         g_object_unref (header);
1433                 }
1434
1435                 tny_iterator_next (iter);
1436         }
1437         g_object_unref (iter);
1438
1439         return uncached_messages;
1440 }
1441
1442 /* Returns FALSE if the user does not want to download the
1443  * messages. Returns TRUE if the user allowed the download.
1444  */
1445 static gboolean
1446 connect_to_get_msg (ModestWindow *win,
1447                     gint num_of_uncached_msgs,
1448                     TnyAccount *account)
1449 {
1450         GtkResponseType response;
1451
1452         /* Allways download if we are online. */
1453         if (tny_device_is_online (modest_runtime_get_device ()))
1454                 return TRUE;
1455
1456         /* If offline, then ask for user permission to download the messages */
1457         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1458                         ngettext("mcen_nc_get_msg",
1459                         "mcen_nc_get_msgs",
1460                         num_of_uncached_msgs));
1461
1462         if (response == GTK_RESPONSE_CANCEL)
1463                 return FALSE;
1464
1465         return modest_platform_connect_and_wait((GtkWindow *) win, account);
1466 }
1467
1468 /*
1469  * Common code for the reply and forward actions
1470  */
1471 static void
1472 reply_forward (ReplyForwardAction action, ModestWindow *win)
1473 {
1474         ModestMailOperation *mail_op = NULL;
1475         TnyList *header_list = NULL;
1476         ReplyForwardHelper *rf_helper = NULL;
1477         guint reply_forward_type;
1478         gboolean continue_download = TRUE;
1479         gboolean do_retrieve = TRUE;
1480
1481         g_return_if_fail (MODEST_IS_WINDOW(win));
1482
1483         /* we need an account when editing */
1484         if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1485                 if (!modest_ui_actions_run_account_setup_wizard (win))
1486                         return;
1487         }
1488
1489         header_list = get_selected_headers (win);
1490         if (!header_list)
1491                 return;
1492
1493         reply_forward_type =
1494                 modest_conf_get_int (modest_runtime_get_conf (),
1495                                      (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1496                                      NULL);
1497
1498         /* check if we need to download msg before asking about it */
1499         do_retrieve = (action == ACTION_FORWARD) ||
1500                         (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1501
1502         if (do_retrieve){
1503                 gint num_of_unc_msgs;
1504
1505                 /* check that the messages have been previously downloaded */
1506                 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
1507                 /* If there are any uncached message ask the user
1508                  * whether he/she wants to download them. */
1509                 if (num_of_unc_msgs) {
1510                         TnyAccount *account = get_account_from_header_list (header_list);
1511                         continue_download = connect_to_get_msg (win, num_of_unc_msgs, account);
1512                         g_object_unref (account);
1513                 }
1514         }
1515
1516         if (!continue_download) {
1517                 g_object_unref (header_list);
1518                 return;
1519         }
1520
1521         /* We assume that we can only select messages of the
1522            same folder and that we reply all of them from the
1523            same account. In fact the interface currently only
1524            allows single selection */
1525
1526         /* Fill helpers */
1527         rf_helper = g_slice_new0 (ReplyForwardHelper);
1528         rf_helper->reply_forward_type = reply_forward_type;
1529         rf_helper->action = action;
1530         rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1531
1532         if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1533                 rf_helper->parent_window = GTK_WIDGET (win);
1534         if (!rf_helper->account_name)
1535                 rf_helper->account_name =
1536                         modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1537
1538         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1539                 TnyMsg *msg;
1540                 TnyHeader *header;
1541                 /* Get header and message. Do not free them here, the
1542                    reply_forward_cb must do it */
1543                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1544                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1545                 if (!msg || !header) {
1546                         if (msg)
1547                                 g_object_unref (msg);
1548                         g_printerr ("modest: no message found\n");
1549                         return;
1550                 } else {
1551                         reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
1552                 }
1553                 if (header)
1554                         g_object_unref (header);
1555         } else {
1556                 TnyHeader *header;
1557                 TnyIterator *iter;
1558
1559                 /* Only reply/forward to one message */
1560                 iter = tny_list_create_iterator (header_list);
1561                 header = TNY_HEADER (tny_iterator_get_current (iter));
1562                 g_object_unref (iter);
1563
1564                 if (header) {
1565                         /* Retrieve messages */
1566                         if (do_retrieve) {
1567                                 mail_op =
1568                                         modest_mail_operation_new_with_error_handling (G_OBJECT(win),
1569                                                                                        modest_ui_actions_get_msgs_full_error_handler,
1570                                                                                        NULL, NULL);
1571                                 modest_mail_operation_queue_add (
1572                                         modest_runtime_get_mail_operation_queue (), mail_op);
1573
1574                                 modest_mail_operation_get_msg (mail_op,
1575                                                                header,
1576                                                                reply_forward_cb,
1577                                                                rf_helper);
1578                                 /* Clean */
1579                                 g_object_unref(mail_op);
1580                         } else {
1581                                 /* we put a ref here to prevent double unref as the reply
1582                                  * forward callback unrefs the header at its end */
1583                                 reply_forward_cb (NULL, header, FALSE, NULL, NULL, rf_helper);
1584                         }
1585
1586
1587                         g_object_unref (header);
1588                 }
1589
1590         }
1591
1592         /* Free */
1593         g_object_unref (header_list);
1594 }
1595
1596 void
1597 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1598 {
1599         g_return_if_fail (MODEST_IS_WINDOW(win));
1600
1601         reply_forward (ACTION_REPLY, win);
1602 }
1603
1604 void
1605 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1606 {
1607         g_return_if_fail (MODEST_IS_WINDOW(win));
1608
1609         reply_forward (ACTION_FORWARD, win);
1610 }
1611
1612 void
1613 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1614 {
1615         g_return_if_fail (MODEST_IS_WINDOW(win));
1616
1617         reply_forward (ACTION_REPLY_TO_ALL, win);
1618 }
1619
1620 void
1621 modest_ui_actions_on_next (GtkAction *action,
1622                            ModestWindow *window)
1623 {
1624         if (MODEST_IS_MAIN_WINDOW (window)) {
1625                 GtkWidget *header_view;
1626
1627                 header_view = modest_main_window_get_child_widget (
1628                                 MODEST_MAIN_WINDOW(window),
1629                                 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1630                 if (!header_view)
1631                         return;
1632
1633                 modest_header_view_select_next (
1634                                 MODEST_HEADER_VIEW(header_view));
1635         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1636                 modest_msg_view_window_select_next_message (
1637                                 MODEST_MSG_VIEW_WINDOW (window));
1638         } else {
1639                 g_return_if_reached ();
1640         }
1641 }
1642
1643 void
1644 modest_ui_actions_on_prev (GtkAction *action,
1645                            ModestWindow *window)
1646 {
1647         g_return_if_fail (MODEST_IS_WINDOW(window));
1648
1649         if (MODEST_IS_MAIN_WINDOW (window)) {
1650                 GtkWidget *header_view;
1651                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1652                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1653                 if (!header_view)
1654                         return;
1655
1656                 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1657         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1658                 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1659         } else {
1660                 g_return_if_reached ();
1661         }
1662 }
1663
1664 void
1665 modest_ui_actions_on_sort (GtkAction *action,
1666                            ModestWindow *window)
1667 {
1668         g_return_if_fail (MODEST_IS_WINDOW(window));
1669
1670         if (MODEST_IS_MAIN_WINDOW (window)) {
1671                 GtkWidget *header_view;
1672                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1673                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1674                 if (!header_view) {
1675                         modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1676
1677                         return;
1678                 }
1679
1680                 /* Show sorting dialog */
1681                 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1682         }
1683 }
1684
1685 static void
1686 new_messages_arrived (ModestMailOperation *self,
1687                       TnyList *new_headers,
1688                       gpointer user_data)
1689 {
1690         GObject *source;
1691         gboolean show_visual_notifications;
1692
1693         source = modest_mail_operation_get_source (self);
1694         show_visual_notifications = (source) ? FALSE : TRUE;
1695         if (source)
1696                 g_object_unref (source);
1697
1698         /* Notify new messages have been downloaded. If the
1699            send&receive was invoked by the user then do not show any
1700            visual notification, only play a sound and activate the LED
1701            (for the Maemo version) */
1702         if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0)
1703                 modest_platform_on_new_headers_received (new_headers,
1704                                                          show_visual_notifications);
1705
1706 }
1707
1708 gboolean
1709 retrieve_all_messages_cb (GObject *source,
1710                           guint num_msgs,
1711                           guint retrieve_limit)
1712 {
1713         GtkWindow *window;
1714         gchar *msg;
1715         gint response;
1716
1717         window = GTK_WINDOW (source);
1718         msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"),
1719                                num_msgs, retrieve_limit);
1720
1721         /* Ask the user if they want to retrieve all the messages */
1722         response =
1723                 modest_platform_run_confirmation_dialog_with_buttons (window, msg,
1724                                                                       _("mcen_bd_get_all"),
1725                                                                       _("mcen_bd_newest_only"));
1726         /* Free and return */
1727         g_free (msg);
1728         return (response == GTK_RESPONSE_ACCEPT) ? TRUE : FALSE;
1729 }
1730
1731 typedef struct {
1732         TnyAccount *account;
1733         ModestWindow *win;
1734         gchar *account_name;
1735 } SendReceiveInfo;
1736
1737 static void
1738 do_send_receive_performer (gboolean canceled,
1739                            GError *err,
1740                            GtkWindow *parent_window,
1741                            TnyAccount *account,
1742                            gpointer user_data)
1743 {
1744         ModestMailOperation *mail_op;
1745         SendReceiveInfo *info;
1746
1747         info = (SendReceiveInfo *) user_data;
1748
1749         if (err || canceled) {
1750                 goto clean;
1751         }
1752
1753         /* Set send/receive operation in progress */
1754         if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
1755                 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
1756         }
1757
1758         mail_op = modest_mail_operation_new_with_error_handling ((info->win) ? G_OBJECT (info->win) : NULL,
1759                                                                  modest_ui_actions_send_receive_error_handler,
1760                                                                  NULL, NULL);
1761
1762         if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
1763                 g_signal_connect (G_OBJECT(mail_op), "operation-finished",
1764                                   G_CALLBACK (on_send_receive_finished),
1765                                   info->win);
1766
1767         /* Send & receive. */
1768         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1769         modest_mail_operation_update_account (mail_op, info->account_name, (info->win) ? FALSE : TRUE,
1770                                               (info->win) ? retrieve_all_messages_cb : NULL,
1771                                               new_messages_arrived, info->win);
1772         g_object_unref (G_OBJECT (mail_op));
1773
1774  clean:
1775         /* Frees */
1776         if (info->account_name)
1777                 g_free (info->account_name);
1778         if (info->win)
1779                 g_object_unref (info->win);
1780         if (info->account)
1781                 g_object_unref (info->account);
1782         g_slice_free (SendReceiveInfo, info);
1783 }
1784
1785 /*
1786  * This function performs the send & receive required actions. The
1787  * window is used to create the mail operation. Typically it should
1788  * always be the main window, but we pass it as argument in order to
1789  * be more flexible.
1790  */
1791 void
1792 modest_ui_actions_do_send_receive (const gchar *account_name,
1793                                    gboolean force_connection,
1794                                    ModestWindow *win)
1795 {
1796         gchar *acc_name = NULL;
1797         SendReceiveInfo *info;
1798         ModestTnyAccountStore *acc_store;
1799
1800         /* If no account name was provided then get the current account, and if
1801            there is no current account then pick the default one: */
1802         if (!account_name) {
1803                 if (win)
1804                         acc_name = g_strdup (modest_window_get_active_account (win));
1805                 if (!acc_name)
1806                         acc_name  = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1807                 if (!acc_name) {
1808                         g_printerr ("modest: cannot get default account\n");
1809                         return;
1810                 }
1811         } else {
1812                 acc_name = g_strdup (account_name);
1813         }
1814
1815         acc_store = modest_runtime_get_account_store ();
1816
1817         /* Create the info for the connect and perform */
1818         info = g_slice_new (SendReceiveInfo);
1819         info->account_name = acc_name;
1820         info->win = (win) ? g_object_ref (win) : NULL;
1821         info->account = modest_tny_account_store_get_server_account (acc_store, acc_name,
1822                                                                      TNY_ACCOUNT_TYPE_STORE);
1823
1824         /* Invoke the connect and perform */
1825         modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
1826                                              force_connection, info->account,
1827                                              do_send_receive_performer, info);
1828 }
1829
1830
1831 static void
1832 modest_ui_actions_do_cancel_send (const gchar *account_name,
1833                                   ModestWindow *win)
1834 {
1835         TnyTransportAccount *transport_account;
1836         TnySendQueue *send_queue = NULL;
1837         GError *error = NULL;
1838
1839         /* Get transport account */
1840         transport_account =
1841                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1842                                       (modest_runtime_get_account_store(),
1843                                        account_name,
1844                                        TNY_ACCOUNT_TYPE_TRANSPORT));
1845         if (!transport_account) {
1846                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1847                 goto frees;
1848         }
1849
1850         /* Get send queue*/
1851         send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1852         if (!TNY_IS_SEND_QUEUE(send_queue)) {
1853                 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1854                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1855                              "modest: could not find send queue for account\n");
1856         } else {
1857                 /* Cancel the current send */
1858                 tny_account_cancel (TNY_ACCOUNT (transport_account));
1859
1860                 /* Suspend all pending messages */
1861                 tny_send_queue_cancel (send_queue, TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, &error);
1862         }
1863
1864  frees:
1865         if (transport_account != NULL)
1866                 g_object_unref (G_OBJECT (transport_account));
1867 }
1868
1869 static void
1870 modest_ui_actions_cancel_send_all (ModestWindow *win)
1871 {
1872         GSList *account_names, *iter;
1873
1874         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1875                                                           TRUE);
1876
1877         iter = account_names;
1878         while (iter) {
1879                 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1880                 iter = g_slist_next (iter);
1881         }
1882
1883         modest_account_mgr_free_account_names (account_names);
1884         account_names = NULL;
1885 }
1886
1887 void
1888 modest_ui_actions_cancel_send (GtkAction *action,  ModestWindow *win)
1889
1890 {
1891         /* Check if accounts exist */
1892         gboolean accounts_exist =
1893                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1894
1895         /* If not, allow the user to create an account before trying to send/receive. */
1896         if (!accounts_exist)
1897                 modest_ui_actions_on_accounts (NULL, win);
1898
1899         /* Cancel all sending operaitons */
1900         modest_ui_actions_cancel_send_all (win);
1901 }
1902
1903 /*
1904  * Refreshes all accounts. This function will be used by automatic
1905  * updates
1906  */
1907 void
1908 modest_ui_actions_do_send_receive_all (ModestWindow *win,
1909                                        gboolean force_connection)
1910 {
1911         GSList *account_names, *iter;
1912
1913         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1914                                                           TRUE);
1915
1916         iter = account_names;
1917         while (iter) {
1918                 modest_ui_actions_do_send_receive ((const char*) iter->data, force_connection, win);
1919                 iter = g_slist_next (iter);
1920         }
1921
1922         modest_account_mgr_free_account_names (account_names);
1923         account_names = NULL;
1924 }
1925
1926 /*
1927  * Handler of the click on Send&Receive button in the main toolbar
1928  */
1929 void
1930 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1931 {
1932         /* Check if accounts exist */
1933         gboolean accounts_exist;
1934
1935         accounts_exist =
1936                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1937
1938         /* If not, allow the user to create an account before trying to send/receive. */
1939         if (!accounts_exist)
1940                 modest_ui_actions_on_accounts (NULL, win);
1941
1942         /* Refresh the current folder. The if is always TRUE it's just an extra check */
1943         if (MODEST_IS_MAIN_WINDOW (win)) {
1944                 GtkWidget *folder_view;
1945                 TnyFolderStore *folder_store;
1946
1947                 folder_view =
1948                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1949                                                              MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
1950                 if (!folder_view)
1951                         return;
1952
1953                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1954
1955                 if (folder_store)
1956                         g_object_unref (folder_store);
1957         }
1958
1959         /* Refresh the active account. Force the connection if needed */
1960         modest_ui_actions_do_send_receive (NULL, TRUE, win);
1961 }
1962
1963
1964 void
1965 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1966 {
1967         ModestConf *conf;
1968         GtkWidget *header_view;
1969
1970         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1971
1972         header_view = modest_main_window_get_child_widget (main_window,
1973                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1974         if (!header_view)
1975                 return;
1976
1977         conf = modest_runtime_get_conf ();
1978
1979         /* what is saved/restored is depending on the style; thus; we save with
1980          * old style, then update the style, and restore for this new style
1981          */
1982         modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1983
1984         if (modest_header_view_get_style
1985             (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1986                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1987                                               MODEST_HEADER_VIEW_STYLE_TWOLINES);
1988         else
1989                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1990                                               MODEST_HEADER_VIEW_STYLE_DETAILS);
1991
1992         modest_widget_memory_restore (conf, G_OBJECT(header_view),
1993                                       MODEST_CONF_HEADER_VIEW_KEY);
1994 }
1995
1996
1997 void
1998 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1999                                       TnyHeader *header,
2000                                       ModestMainWindow *main_window)
2001 {
2002         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2003         g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2004
2005         /* in the case the folder is empty, show the empty folder message and focus
2006          * folder view */
2007         if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
2008                 if (modest_header_view_is_empty (header_view)) {
2009                         TnyFolder *folder = modest_header_view_get_folder (header_view);
2010                         GtkWidget *folder_view =
2011                                 modest_main_window_get_child_widget (main_window,
2012                                                                      MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2013                         if (folder != NULL)
2014                                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
2015                         gtk_widget_grab_focus (GTK_WIDGET (folder_view));
2016                         return;
2017                 }
2018         }
2019         /* If no header has been selected then exit */
2020         if (!header)
2021                 return;
2022
2023         /* Update focus */
2024         if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
2025             gtk_widget_grab_focus (GTK_WIDGET(header_view));
2026
2027         /* Update toolbar dimming state */
2028         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2029 }
2030
2031 void
2032 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
2033                                        TnyHeader *header,
2034                                        ModestMainWindow *main_window)
2035 {
2036         TnyList *headers;
2037
2038         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2039
2040         if (!header)
2041                 return;
2042
2043         if (modest_header_view_count_selected_headers (header_view) > 1) {
2044                 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
2045                 return;
2046         }
2047
2048
2049 /*      headers = tny_simple_list_new (); */
2050 /*      tny_list_prepend (headers, G_OBJECT (header)); */
2051         headers = modest_header_view_get_selected_headers (header_view);
2052
2053         open_msgs_from_headers (headers, MODEST_WINDOW (main_window));
2054
2055         g_object_unref (headers);
2056 }
2057
2058 static void
2059 set_active_account_from_tny_account (TnyAccount *account,
2060                                      ModestWindow *window)
2061 {
2062         const gchar *server_acc_name = tny_account_get_id (account);
2063
2064         /* We need the TnyAccount provided by the
2065            account store because that is the one that
2066            knows the name of the Modest account */
2067         TnyAccount *modest_server_account = modest_server_account =
2068                 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
2069                                                              MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
2070                                                              server_acc_name);
2071         if (!modest_server_account) {
2072                 g_warning ("%s: could not get tny account\n", __FUNCTION__);
2073                 return;
2074         }
2075
2076         /* Update active account, but only if it's not a pseudo-account */
2077         if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
2078             (!modest_tny_account_is_memory_card_account(modest_server_account))) {
2079                 const gchar *modest_acc_name =
2080                         modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
2081                 if (modest_acc_name)
2082                         modest_window_set_active_account (window, modest_acc_name);
2083         }
2084
2085         g_object_unref (modest_server_account);
2086 }
2087
2088
2089 static void
2090 folder_refreshed_cb (ModestMailOperation *mail_op,
2091                      TnyFolder *folder,
2092                      gpointer user_data)
2093 {
2094         ModestMainWindow *win = NULL;
2095         GtkWidget *header_view;
2096
2097         g_return_if_fail (TNY_IS_FOLDER (folder));
2098
2099         win = MODEST_MAIN_WINDOW (user_data);
2100         header_view =
2101                 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2102
2103         if (header_view) {
2104                 TnyFolder *current_folder;
2105
2106                 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
2107                 if (current_folder != NULL && folder != current_folder) {
2108                         g_object_unref (current_folder);
2109                         return;
2110                 } else if (current_folder)
2111                         g_object_unref (current_folder);
2112         }
2113
2114         /* Check if folder is empty and set headers view contents style */
2115         if (tny_folder_get_all_count (folder) == 0)
2116                 modest_main_window_set_contents_style (win,
2117                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2118 }
2119
2120 void
2121 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2122                                                TnyFolderStore *folder_store,
2123                                                gboolean selected,
2124                                                ModestMainWindow *main_window)
2125 {
2126         ModestConf *conf;
2127         GtkWidget *header_view;
2128
2129         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2130
2131         header_view = modest_main_window_get_child_widget(main_window,
2132                                                           MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2133         if (!header_view)
2134                 return;
2135
2136         conf = modest_runtime_get_conf ();
2137
2138         if (TNY_IS_ACCOUNT (folder_store)) {
2139                 if (selected) {
2140                         set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2141
2142                         /* Show account details */
2143                         modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2144                 }
2145         } else {
2146                 if (TNY_IS_FOLDER (folder_store) && selected) {
2147
2148                         /* Update the active account */
2149                         TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2150                         if (account) {
2151                                 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2152                                 g_object_unref (account);
2153                                 account = NULL;
2154                         }
2155
2156                         /* Set the header style by default, it could
2157                            be changed later by the refresh callback to
2158                            empty */
2159                         modest_main_window_set_contents_style (main_window,
2160                                                                MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2161
2162                         /* Set folder on header view. This function
2163                            will call tny_folder_refresh_async so we
2164                            pass a callback that will be called when
2165                            finished. We use that callback to set the
2166                            empty view if there are no messages */
2167                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2168                                                        TNY_FOLDER (folder_store),
2169                                                        folder_refreshed_cb,
2170                                                        main_window);
2171
2172                         /* Restore configuration. We need to do this
2173                            *after* the set_folder because the widget
2174                            memory asks the header view about its
2175                            folder  */
2176                         modest_widget_memory_restore (modest_runtime_get_conf (),
2177                                                       G_OBJECT(header_view),
2178                                                       MODEST_CONF_HEADER_VIEW_KEY);
2179                 } else {
2180                         /* Update the active account */
2181                         //modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
2182                         /* Save only if we're seeing headers */
2183                         if (modest_main_window_get_contents_style (main_window) ==
2184                             MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2185                                 modest_widget_memory_save (conf, G_OBJECT (header_view),
2186                                                            MODEST_CONF_HEADER_VIEW_KEY);
2187                         modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2188                 }
2189         }
2190
2191         /* Update toolbar dimming state */
2192         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2193 }
2194
2195 void
2196 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2197                                      ModestWindow *win)
2198 {
2199         GtkWidget *dialog;
2200         gchar *txt, *item;
2201         gboolean online;
2202
2203         item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2204
2205         online = tny_device_is_online (modest_runtime_get_device());
2206
2207         if (online) {
2208                 /* already online -- the item is simply not there... */
2209                 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2210                                                  GTK_DIALOG_MODAL,
2211                                                  GTK_MESSAGE_WARNING,
2212                                                  GTK_BUTTONS_NONE,
2213                                                  _("The %s you selected cannot be found"),
2214                                                  item);
2215                 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2216                 gtk_dialog_run (GTK_DIALOG(dialog));
2217         } else {
2218                 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2219                                                       GTK_WINDOW (win),
2220                                                       GTK_DIALOG_MODAL,
2221                                                       _("mcen_bd_dialog_cancel"),
2222                                                       GTK_RESPONSE_REJECT,
2223                                                       _("mcen_bd_dialog_ok"),
2224                                                       GTK_RESPONSE_ACCEPT,
2225                                                       NULL);
2226                 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2227                                          "Do you want to get online?"), item);
2228                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
2229                                     gtk_label_new (txt), FALSE, FALSE, 0);
2230                 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2231                 g_free (txt);
2232
2233                 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2234                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2235                         /* TODO: Comment about why is this commented out: */
2236                         /* modest_platform_connect_and_wait (); */
2237                 }
2238         }
2239         gtk_widget_destroy (dialog);
2240 }
2241
2242 void
2243 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2244                                      ModestWindow *win)
2245 {
2246         /* g_message ("%s %s", __FUNCTION__, link); */
2247 }
2248
2249
2250 void
2251 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2252                                         ModestWindow *win)
2253 {
2254         modest_platform_activate_uri (link);
2255 }
2256
2257 void
2258 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2259                                           ModestWindow *win)
2260 {
2261         modest_platform_show_uri_popup (link);
2262 }
2263
2264 void
2265 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2266                                              ModestWindow *win)
2267 {
2268         modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2269 }
2270
2271 void
2272 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2273                                           const gchar *address,
2274                                           ModestWindow *win)
2275 {
2276         /* g_message ("%s %s", __FUNCTION__, address); */
2277 }
2278
2279 static void
2280 on_save_to_drafts_cb (ModestMailOperation *mail_op,
2281                       TnyMsg *saved_draft,
2282                       gpointer user_data)
2283 {
2284         ModestMsgEditWindow *edit_window;
2285         ModestMainWindow *win;
2286
2287         /* FIXME. Make the header view sensitive again. This is a
2288          * temporary hack. See modest_ui_actions_on_save_to_drafts()
2289          * for details */
2290         win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2291                                          modest_runtime_get_window_mgr(), FALSE));
2292         if (win != NULL) {
2293                 GtkWidget *hdrview = modest_main_window_get_child_widget(
2294                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2295                 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2296         }
2297
2298         edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2299
2300         /* It might not be a good idea to do nothing if there was an error,
2301          * so let's at least show a generic error banner. */
2302         /* TODO error while saving attachment, show "Saving draft failed" banner */
2303         if (modest_mail_operation_get_error (mail_op) != NULL) {
2304                 g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_op))->message);
2305                 modest_platform_information_banner (NULL, NULL, _("mail_ib_file_operation_failed"));
2306         } else {
2307                 modest_msg_edit_window_set_draft (edit_window, saved_draft);
2308         }
2309         g_object_unref(edit_window);
2310 }
2311
2312 gboolean
2313 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2314 {
2315         TnyTransportAccount *transport_account;
2316         ModestMailOperation *mail_operation;
2317         MsgData *data;
2318         gchar *account_name, *from;
2319         ModestAccountMgr *account_mgr;
2320 /*      char *info_text; */
2321         gboolean had_error = FALSE;
2322         guint64 available_disk, expected_size;
2323         gint parts_count;
2324         guint64 parts_size;
2325         ModestMainWindow *win;
2326
2327         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
2328
2329         data = modest_msg_edit_window_get_msg_data (edit_window);
2330
2331         /* Check size */
2332         available_disk = modest_folder_available_space (NULL);
2333         modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2334         expected_size = modest_tny_msg_estimate_size (data->plain_body,
2335                                                  data->html_body,
2336                                                  parts_count,
2337                                                  parts_size);
2338
2339         if ((available_disk != -1) && expected_size > available_disk) {
2340                 modest_msg_edit_window_free_msg_data (edit_window, data);
2341
2342                 modest_platform_information_banner (NULL, NULL, dgettext("ke-recv", "cerm_device_memory_full"));
2343                 return FALSE;
2344         }
2345
2346         account_name = g_strdup (data->account_name);
2347         account_mgr = modest_runtime_get_account_mgr();
2348         if (!account_name)
2349                 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2350         if (!account_name)
2351                 account_name = modest_account_mgr_get_default_account (account_mgr);
2352         if (!account_name) {
2353                 g_printerr ("modest: no account found\n");
2354                 modest_msg_edit_window_free_msg_data (edit_window, data);
2355                 return FALSE;
2356         }
2357
2358         if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2359                 account_name = g_strdup (data->account_name);
2360         }
2361
2362         transport_account =
2363                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2364                                       (modest_runtime_get_account_store(),
2365                                        account_name,
2366                                        TNY_ACCOUNT_TYPE_TRANSPORT));
2367         if (!transport_account) {
2368                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2369                 g_free (account_name);
2370                 modest_msg_edit_window_free_msg_data (edit_window, data);
2371                 return FALSE;
2372         }
2373         from = modest_account_mgr_get_from_string (account_mgr, account_name);
2374
2375         /* Create the mail operation */
2376         mail_operation = modest_mail_operation_new (NULL);
2377         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2378
2379         modest_mail_operation_save_to_drafts (mail_operation,
2380                                               transport_account,
2381                                               data->draft_msg,
2382                                               from,
2383                                               data->to,
2384                                               data->cc,
2385                                               data->bcc,
2386                                               data->subject,
2387                                               data->plain_body,
2388                                               data->html_body,
2389                                               data->attachments,
2390                                               data->images,
2391                                               data->priority_flags,
2392                                               on_save_to_drafts_cb,
2393                                               g_object_ref(edit_window));
2394
2395         /* Use the main window as the parent of the banner, if the
2396            main window does not exist it won't be shown, if the parent
2397            window exists then it's properly shown. We don't use the
2398            editor window because it could be closed (save to drafts
2399            could happen after closing the window */
2400         win = (ModestMainWindow *)
2401                 modest_window_mgr_get_main_window( modest_runtime_get_window_mgr(), FALSE);
2402         if (win) {
2403                 modest_platform_information_banner (GTK_WIDGET (win),
2404                                                     NULL, _CS("sfil_ib_saving"));
2405         }
2406         modest_msg_edit_window_set_modified (edit_window, FALSE);
2407
2408         /* Frees */
2409         g_free (from);
2410         g_free (account_name);
2411         g_object_unref (G_OBJECT (transport_account));
2412         g_object_unref (G_OBJECT (mail_operation));
2413
2414         modest_msg_edit_window_free_msg_data (edit_window, data);
2415
2416         /* ** FIXME **
2417          * If the drafts folder is selected then make the header view
2418          * insensitive while the message is being saved to drafts
2419          * (it'll be sensitive again in on_save_to_drafts_cb()). This
2420          * is not very clean but it avoids letting the drafts folder
2421          * in an inconsistent state: the user could edit the message
2422          * being saved and undesirable things would happen.
2423          * In the average case the user won't notice anything at
2424          * all. In the worst case (the user is editing a really big
2425          * file from Drafts) the header view will be insensitive
2426          * during the saving process (10 or 20 seconds, depending on
2427          * the message). Anyway this is just a quick workaround: once
2428          * we find a better solution it should be removed
2429          * See NB#65125 (commend #18) for details.
2430          */
2431         if (!had_error && win != NULL) {
2432                 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
2433                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
2434                 if (view != NULL) {
2435                         TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
2436                         if (folder) {
2437                                 if (modest_tny_folder_is_local_folder(folder)) {
2438                                         TnyFolderType folder_type;
2439                                         folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
2440                                         if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
2441                                                 GtkWidget *hdrview = modest_main_window_get_child_widget(
2442                                                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2443                                                 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
2444                                         }
2445                                 }
2446                         }
2447                         if (folder != NULL) g_object_unref(folder);
2448                 }
2449         }
2450
2451         return !had_error;
2452 }
2453
2454 /* For instance, when clicking the Send toolbar button when editing a message: */
2455 gboolean
2456 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2457 {
2458         TnyTransportAccount *transport_account = NULL;
2459         gboolean had_error = FALSE;
2460         guint64 available_disk, expected_size;
2461         gint parts_count;
2462         guint64 parts_size;
2463
2464         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
2465
2466         if (!modest_msg_edit_window_check_names (edit_window, TRUE))
2467                 return TRUE;
2468
2469         /* FIXME: Code added just for testing. The final version will
2470            use the send queue provided by tinymail and some
2471            classifier */
2472         MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
2473
2474         /* Check size */
2475         available_disk = modest_folder_available_space (NULL);
2476         modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2477         expected_size = modest_tny_msg_estimate_size (data->plain_body,
2478                                                  data->html_body,
2479                                                  parts_count,
2480                                                  parts_size);
2481
2482         if ((available_disk != -1) && expected_size > available_disk) {
2483                 modest_msg_edit_window_free_msg_data (edit_window, data);
2484
2485                 modest_platform_information_banner (NULL, NULL, dgettext("ke-recv", "cerm_device_memory_full"));
2486                 return FALSE;
2487         }
2488
2489         ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
2490         gchar *account_name = g_strdup (data->account_name);
2491         if (!account_name)
2492                 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2493
2494         if (!account_name)
2495                 account_name = modest_account_mgr_get_default_account (account_mgr);
2496
2497         if (!account_name) {
2498                 modest_msg_edit_window_free_msg_data (edit_window, data);
2499                 /* Run account setup wizard */
2500                 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window))) {
2501                         return TRUE;
2502                 }
2503         }
2504
2505         /* Get the currently-active transport account for this modest account: */
2506         if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
2507                 transport_account = TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2508                                                           (modest_runtime_get_account_store(),
2509                                                            account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
2510         }
2511
2512         if (!transport_account) {
2513                 modest_msg_edit_window_free_msg_data (edit_window, data);
2514                 /* Run account setup wizard */
2515                 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
2516                         return TRUE;
2517         }
2518
2519         gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
2520
2521         /* Create the mail operation */
2522         ModestMailOperation *mail_operation = modest_mail_operation_new (NULL);
2523         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2524
2525         modest_mail_operation_send_new_mail (mail_operation,
2526                                              transport_account,
2527                                              data->draft_msg,
2528                                              from,
2529                                              data->to,
2530                                              data->cc,
2531                                              data->bcc,
2532                                              data->subject,
2533                                              data->plain_body,
2534                                              data->html_body,
2535                                              data->attachments,
2536                                              data->images,
2537                                              data->priority_flags);
2538
2539         if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
2540                 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
2541
2542
2543         if (modest_mail_operation_get_error (mail_operation) != NULL) {
2544                 const GError *error = modest_mail_operation_get_error (mail_operation);
2545                 if (error->code == MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED) {
2546                         g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_operation))->message);
2547                         modest_platform_information_banner (NULL, NULL, _CS("sfil_ni_not_enough_memory"));
2548                         had_error = TRUE;
2549                 }
2550         }
2551
2552         /* Free data: */
2553         g_free (from);
2554         g_free (account_name);
2555         g_object_unref (G_OBJECT (transport_account));
2556         g_object_unref (G_OBJECT (mail_operation));
2557
2558         modest_msg_edit_window_free_msg_data (edit_window, data);
2559
2560         if (!had_error) {
2561                 modest_msg_edit_window_set_sent (edit_window, TRUE);
2562
2563                 /* Save settings and close the window: */
2564                 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2565         }
2566
2567         return !had_error;
2568 }
2569
2570 void
2571 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2572                                   ModestMsgEditWindow *window)
2573 {
2574         ModestMsgEditFormatState *format_state = NULL;
2575
2576         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2577         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2578
2579         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2580                 return;
2581
2582         format_state = modest_msg_edit_window_get_format_state (window);
2583         g_return_if_fail (format_state != NULL);
2584
2585         format_state->bold = gtk_toggle_action_get_active (action);
2586         modest_msg_edit_window_set_format_state (window, format_state);
2587         g_free (format_state);
2588
2589 }
2590
2591 void
2592 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2593                                      ModestMsgEditWindow *window)
2594 {
2595         ModestMsgEditFormatState *format_state = NULL;
2596
2597         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2598         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2599
2600         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2601                 return;
2602
2603         format_state = modest_msg_edit_window_get_format_state (window);
2604         g_return_if_fail (format_state != NULL);
2605
2606         format_state->italics = gtk_toggle_action_get_active (action);
2607         modest_msg_edit_window_set_format_state (window, format_state);
2608         g_free (format_state);
2609
2610 }
2611
2612 void
2613 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2614                                      ModestMsgEditWindow *window)
2615 {
2616         ModestMsgEditFormatState *format_state = NULL;
2617
2618         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2619         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2620
2621         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2622                 return;
2623
2624         format_state = modest_msg_edit_window_get_format_state (window);
2625         g_return_if_fail (format_state != NULL);
2626
2627         format_state->bullet = gtk_toggle_action_get_active (action);
2628         modest_msg_edit_window_set_format_state (window, format_state);
2629         g_free (format_state);
2630
2631 }
2632
2633 void
2634 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2635                                      GtkRadioAction *selected,
2636                                      ModestMsgEditWindow *window)
2637 {
2638         ModestMsgEditFormatState *format_state = NULL;
2639         GtkJustification value;
2640
2641         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2642
2643         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2644                 return;
2645
2646         value = gtk_radio_action_get_current_value (selected);
2647
2648         format_state = modest_msg_edit_window_get_format_state (window);
2649         g_return_if_fail (format_state != NULL);
2650
2651         format_state->justification = value;
2652         modest_msg_edit_window_set_format_state (window, format_state);
2653         g_free (format_state);
2654 }
2655
2656 void
2657 modest_ui_actions_on_select_editor_color (GtkAction *action,
2658                                           ModestMsgEditWindow *window)
2659 {
2660         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2661         g_return_if_fail (GTK_IS_ACTION (action));
2662
2663         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2664                 return;
2665
2666         modest_msg_edit_window_select_color (window);
2667 }
2668
2669 void
2670 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2671                                                      ModestMsgEditWindow *window)
2672 {
2673         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2674         g_return_if_fail (GTK_IS_ACTION (action));
2675
2676         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2677                 return;
2678
2679         modest_msg_edit_window_select_background_color (window);
2680 }
2681
2682 void
2683 modest_ui_actions_on_insert_image (GtkAction *action,
2684                                    ModestMsgEditWindow *window)
2685 {
2686         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2687         g_return_if_fail (GTK_IS_ACTION (action));
2688
2689         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2690                 return;
2691
2692         modest_msg_edit_window_insert_image (window);
2693 }
2694
2695 void
2696 modest_ui_actions_on_attach_file (GtkAction *action,
2697                                   ModestMsgEditWindow *window)
2698 {
2699         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2700         g_return_if_fail (GTK_IS_ACTION (action));
2701
2702         modest_msg_edit_window_offer_attach_file (window);
2703 }
2704
2705 void
2706 modest_ui_actions_on_remove_attachments (GtkAction *action,
2707                                          ModestMsgEditWindow *window)
2708 {
2709         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2710         g_return_if_fail (GTK_IS_ACTION (action));
2711
2712         modest_msg_edit_window_remove_attachments (window, NULL);
2713 }
2714
2715 static void
2716 do_create_folder_cb (ModestMailOperation *mail_op,
2717                      TnyFolderStore *parent_folder,
2718                      TnyFolder *new_folder,
2719                      gpointer user_data)
2720 {
2721         gchar *suggested_name = (gchar *) user_data;
2722         GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
2723
2724         if (modest_mail_operation_get_error (mail_op)) {
2725                 /* Show an error */
2726                 modest_platform_information_banner (GTK_WIDGET (source_win), NULL,
2727                                                     _("mail_in_ui_folder_create_error"));
2728
2729                 /* Try again */
2730                 do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
2731         } else {
2732                 /* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
2733                  * FIXME: any other? */
2734                 GtkWidget *folder_view;
2735
2736                 if (MODEST_IS_MAIN_WINDOW(source_win))
2737                         folder_view =
2738                                 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
2739                                                                      MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2740                 else
2741                         folder_view =
2742                                 get_folder_view_from_move_to_dialog (GTK_WIDGET(source_win));
2743
2744                 /* Select the newly created folder */
2745                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
2746                                                   new_folder, FALSE);
2747                 g_object_unref (new_folder);
2748         }
2749         /* Free. Note that the first time it'll be NULL so noop */
2750         g_free (suggested_name);
2751         g_object_unref (source_win);
2752 }
2753
2754 static void
2755 do_create_folder (GtkWindow *parent_window,
2756                   TnyFolderStore *parent_folder,
2757                   const gchar *suggested_name)
2758 {
2759         gint result;
2760         gchar *folder_name = NULL;
2761
2762         result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2763                                                         parent_folder,
2764                                                         (gchar *) suggested_name,
2765                                                         &folder_name);
2766
2767         if (result == GTK_RESPONSE_ACCEPT) {
2768                 ModestMailOperation *mail_op;
2769
2770                 mail_op  = modest_mail_operation_new (G_OBJECT(parent_window));
2771
2772                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2773                                                  mail_op);
2774                 modest_mail_operation_create_folder (mail_op,
2775                                                      parent_folder,
2776                                                      (const gchar *) folder_name,
2777                                                      do_create_folder_cb,
2778                                                      folder_name);
2779                 g_object_unref (mail_op);
2780         }
2781 }
2782
2783 static void
2784 create_folder_performer (gboolean canceled,
2785                          GError *err,
2786                          GtkWindow *parent_window,
2787                          TnyAccount *account,
2788                          gpointer user_data)
2789 {
2790         TnyFolderStore *parent_folder = TNY_FOLDER_STORE (user_data);
2791
2792         if (canceled || err) {
2793                 goto frees;
2794         }
2795
2796         /* Run the new folder dialog */
2797         do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
2798
2799  frees:
2800         g_object_unref (parent_folder);
2801 }
2802
2803 static void
2804 modest_ui_actions_create_folder(GtkWidget *parent_window,
2805                                 GtkWidget *folder_view)
2806 {
2807         TnyFolderStore *parent_folder;
2808
2809         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2810
2811         if (parent_folder) {
2812                 /* The parent folder will be freed in the callback */
2813                 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
2814                                                                TRUE,
2815                                                                parent_folder,
2816                                                                create_folder_performer,
2817                                                                parent_folder);
2818         }
2819 }
2820
2821 void
2822 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2823 {
2824         GtkWidget *folder_view;
2825
2826         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2827
2828         folder_view = modest_main_window_get_child_widget (main_window,
2829                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2830         if (!folder_view)
2831                 return;
2832
2833         modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2834 }
2835
2836 static void
2837 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2838                                                gpointer user_data)
2839 {
2840         ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2841         const GError *error = NULL;
2842         const gchar *message = NULL;
2843
2844         /* Get error message */
2845         error = modest_mail_operation_get_error (mail_op);
2846         if (!error)
2847                 g_return_if_reached ();
2848
2849         switch (error->code) {
2850         case MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS:
2851                 message = _CS("ckdg_ib_folder_already_exists");
2852                 break;
2853         default:
2854                 g_warning ("%s: BUG: unexpected error:[%d]: %s", __FUNCTION__,
2855                            error->code, error->message);
2856                 return;
2857         }
2858
2859         modest_platform_information_banner (GTK_WIDGET (window), NULL, message);
2860 }
2861
2862 typedef struct {
2863         TnyFolderStore *folder;
2864         gchar *new_name;
2865 } RenameFolderInfo;
2866
2867 static void
2868 on_rename_folder_cb (ModestMailOperation *mail_op,
2869                      TnyFolder *new_folder,
2870                      gpointer user_data)
2871 {
2872         /* Select now */
2873         modest_folder_view_select_folder (MODEST_FOLDER_VIEW (user_data),
2874                                           new_folder, FALSE);
2875 }
2876
2877 static void
2878 on_rename_folder_performer (gboolean canceled,
2879                             GError *err,
2880                             GtkWindow *parent_window,
2881                             TnyAccount *account,
2882                             gpointer user_data)
2883 {
2884         ModestMailOperation *mail_op = NULL;
2885         GtkTreeSelection *sel = NULL;
2886         GtkWidget *folder_view = NULL;
2887         RenameFolderInfo *data = (RenameFolderInfo*)user_data;
2888
2889         if (!canceled && (err == NULL) && MODEST_IS_MAIN_WINDOW(parent_window)) {
2890
2891                 folder_view = modest_main_window_get_child_widget (
2892                                 MODEST_MAIN_WINDOW (parent_window),
2893                                 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2894
2895                 mail_op =
2896                         modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
2897                                         modest_ui_actions_rename_folder_error_handler,
2898                                         parent_window, NULL);
2899
2900                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2901                                 mail_op);
2902
2903                 /* Clear the headers view */
2904                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2905                 gtk_tree_selection_unselect_all (sel);
2906
2907                 /* Actually rename the folder */
2908                 modest_mail_operation_rename_folder (mail_op,
2909                                                      TNY_FOLDER (data->folder),
2910                                                      (const gchar *) (data->new_name),
2911                                                      on_rename_folder_cb,
2912                                                      folder_view);
2913         }
2914
2915         g_object_unref (mail_op);
2916         g_free (data->new_name);
2917         g_free (data);
2918 }
2919
2920 void
2921 modest_ui_actions_on_rename_folder (GtkAction *action,
2922                                      ModestMainWindow *main_window)
2923 {
2924         TnyFolderStore *folder;
2925         GtkWidget *folder_view;
2926         GtkWidget *header_view;
2927
2928         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2929
2930         folder_view = modest_main_window_get_child_widget (main_window,
2931                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2932         if (!folder_view)
2933                 return;
2934
2935         header_view = modest_main_window_get_child_widget (main_window,
2936                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2937
2938         if (!header_view)
2939                 return;
2940
2941         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2942
2943         if (!folder)
2944                 return;
2945
2946         if (TNY_IS_FOLDER (folder)) {
2947                 gchar *folder_name;
2948                 gint response;
2949                 const gchar *current_name;
2950                 TnyFolderStore *parent;
2951                 gboolean do_rename = TRUE;
2952
2953                 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2954                 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
2955                 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window),
2956                                                                      parent, current_name,
2957                                                                      &folder_name);
2958                 g_object_unref (parent);
2959
2960                 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
2961                         do_rename = FALSE;
2962                 } else {
2963                         RenameFolderInfo *rename_folder_data = g_new0 (RenameFolderInfo, 1);
2964                         rename_folder_data->folder = folder;
2965                         rename_folder_data->new_name = folder_name;
2966                         modest_platform_connect_if_remote_and_perform (GTK_WINDOW(main_window), TRUE,
2967                                         folder, on_rename_folder_performer, rename_folder_data);
2968                 }
2969         }
2970         g_object_unref (folder);
2971 }
2972
2973 static void
2974 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2975                                                gpointer user_data)
2976 {
2977         GObject *win = modest_mail_operation_get_source (mail_op);
2978
2979         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2980                                                 _("mail_in_ui_folder_delete_error"));
2981         g_object_unref (win);
2982 }
2983
2984 typedef struct {
2985         TnyFolderStore *folder;
2986         gboolean move_to_trash;
2987 } DeleteFolderInfo;
2988
2989 static void
2990 on_delete_folder_cb (gboolean canceled,
2991                   GError *err,
2992                   GtkWindow *parent_window,
2993                   TnyAccount *account,
2994                   gpointer user_data)
2995 {
2996         DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
2997         GtkWidget *folder_view;
2998         ModestMailOperation *mail_op;
2999         GtkTreeSelection *sel;
3000
3001         if (!MODEST_IS_MAIN_WINDOW(parent_window) || canceled || (err!=NULL)) {
3002                 g_object_unref (G_OBJECT (info->folder));
3003                 g_free (info);
3004                 return;
3005         }
3006
3007         folder_view = modest_main_window_get_child_widget (
3008                         MODEST_MAIN_WINDOW (parent_window),
3009                         MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3010
3011         /* Unselect the folder before deleting it to free the headers */
3012         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3013         gtk_tree_selection_unselect_all (sel);
3014
3015         /* Create the mail operation */
3016         mail_op =
3017                 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3018                                 modest_ui_actions_delete_folder_error_handler,
3019                                 NULL, NULL);
3020
3021         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3022                         mail_op);
3023         modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
3024
3025         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
3026
3027         g_object_unref (G_OBJECT (mail_op));
3028         g_object_unref (G_OBJECT (info->folder));
3029         g_free (info);
3030 }
3031
3032 static void
3033 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
3034 {
3035         TnyFolderStore *folder;
3036         GtkWidget *folder_view;
3037         gint response;
3038         gchar *message;
3039
3040         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3041
3042         folder_view = modest_main_window_get_child_widget (main_window,
3043                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3044         if (!folder_view)
3045                 return;
3046
3047         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3048
3049         /* Show an error if it's an account */
3050         if (!TNY_IS_FOLDER (folder)) {
3051                 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
3052                                                         _("mail_in_ui_folder_delete_error"));
3053                 g_object_unref (G_OBJECT (folder));
3054                 return;
3055         }
3056
3057         /* Ask the user */
3058         message =  g_strdup_printf (_("mcen_nc_delete_folder_text"),
3059                                     tny_folder_get_name (TNY_FOLDER (folder)));
3060         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
3061                                                             (const gchar *) message);
3062         g_free (message);
3063
3064         if (response == GTK_RESPONSE_OK) {
3065                 DeleteFolderInfo *info;
3066                 info = g_new0(DeleteFolderInfo, 1);
3067                 info->folder = folder;
3068                 info->move_to_trash = move_to_trash;
3069                 g_object_ref (G_OBJECT (info->folder));
3070                 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder));
3071                 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (main_window),
3072                                                                TRUE,
3073                                                                TNY_FOLDER_STORE (account),
3074                                                                on_delete_folder_cb, info);
3075                 g_object_unref (account);
3076         }
3077         g_object_unref (G_OBJECT (folder));
3078 }
3079
3080 void
3081 modest_ui_actions_on_delete_folder (GtkAction *action,
3082                                      ModestMainWindow *main_window)
3083 {
3084         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3085
3086         delete_folder (main_window, FALSE);
3087 }
3088
3089 void
3090 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
3091 {
3092         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3093
3094         delete_folder (main_window, TRUE);
3095 }
3096
3097
3098 void
3099 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
3100                                          const gchar* server_account_name,
3101                                          gchar **username,
3102                                          gchar **password,
3103                                          gboolean *cancel,
3104                                          gboolean *remember,
3105                                          ModestMainWindow *main_window)
3106 {
3107         g_return_if_fail(server_account_name);
3108         gboolean completed = FALSE;
3109
3110         /* Initalize output parameters: */
3111         if (cancel)
3112                 *cancel = FALSE;
3113
3114         if (remember)
3115                 *remember = TRUE;
3116
3117 #ifdef MODEST_PLATFORM_MAEMO
3118         /* Maemo uses a different (awkward) button order,
3119          * It should probably just use gtk_alternative_dialog_button_order ().
3120          */
3121         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3122                                               NULL,
3123                                               GTK_DIALOG_MODAL,
3124                                               _("mcen_bd_dialog_ok"),
3125                                               GTK_RESPONSE_ACCEPT,
3126                                               _("mcen_bd_dialog_cancel"),
3127                                               GTK_RESPONSE_REJECT,
3128                                               NULL);
3129 #else
3130         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3131                                               NULL,
3132                                               GTK_DIALOG_MODAL,
3133                                               GTK_STOCK_CANCEL,
3134                                               GTK_RESPONSE_REJECT,
3135                                               GTK_STOCK_OK,
3136                                               GTK_RESPONSE_ACCEPT,
3137                                               NULL);
3138 #endif /* MODEST_PLATFORM_MAEMO */
3139
3140         modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog));
3141
3142         gchar *server_name = modest_account_mgr_get_server_account_hostname (
3143                 modest_runtime_get_account_mgr(), server_account_name);
3144         if (!server_name) {/* This happened once, though I don't know why. murrayc. */
3145                 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
3146                 if (cancel)
3147                         *cancel = TRUE;
3148                 return;
3149         }
3150
3151         /* This causes a warning because the logical ID has no %s in it,
3152          * though the translation does, but there is not much we can do about that: */
3153         gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
3154         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
3155                             FALSE, FALSE, 0);
3156         g_free (txt);
3157         g_free (server_name);
3158         server_name = NULL;
3159
3160         /* username: */
3161         gchar *initial_username = modest_account_mgr_get_server_account_username (
3162                 modest_runtime_get_account_mgr(), server_account_name);
3163
3164         GtkWidget *entry_username = gtk_entry_new ();
3165         if (initial_username)
3166                 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
3167         /* Dim this if a connection has ever succeeded with this username,
3168          * as per the UI spec: */
3169         const gboolean username_known =
3170                 modest_account_mgr_get_server_account_username_has_succeeded(
3171                         modest_runtime_get_account_mgr(), server_account_name);
3172         gtk_widget_set_sensitive (entry_username, !username_known);
3173
3174 #ifdef MODEST_PLATFORM_MAEMO
3175         /* Auto-capitalization is the default, so let's turn it off: */
3176         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
3177
3178         /* Create a size group to be used by all captions.
3179          * Note that HildonCaption does not create a default size group if we do not specify one.
3180          * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
3181         GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
3182
3183         GtkWidget *caption = hildon_caption_new (sizegroup,
3184                 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
3185         gtk_widget_show (entry_username);
3186         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
3187                 FALSE, FALSE, MODEST_MARGIN_HALF);
3188         gtk_widget_show (caption);
3189 #else
3190         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
3191                             TRUE, FALSE, 0);
3192 #endif /* MODEST_PLATFORM_MAEMO */
3193
3194         /* password: */
3195         GtkWidget *entry_password = gtk_entry_new ();
3196         gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
3197         /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
3198
3199 #ifdef MODEST_PLATFORM_MAEMO
3200         /* Auto-capitalization is the default, so let's turn it off: */
3201         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
3202                 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
3203
3204         caption = hildon_caption_new (sizegroup,
3205                 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
3206         gtk_widget_show (entry_password);
3207         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
3208                 FALSE, FALSE, MODEST_MARGIN_HALF);
3209         gtk_widget_show (caption);
3210         g_object_unref (sizegroup);
3211 #else
3212         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
3213                             TRUE, FALSE, 0);
3214 #endif /* MODEST_PLATFORM_MAEMO */
3215
3216         if (initial_username != NULL)
3217                 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
3218
3219 /* This is not in the Maemo UI spec:
3220         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
3221         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
3222                             TRUE, FALSE, 0);
3223 */
3224
3225         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3226
3227         while (!completed) {
3228
3229                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
3230                         if (username) {
3231                                 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
3232
3233                                 /* Note that an empty field becomes the "" string */
3234                                 if (*username && strlen (*username) > 0) {
3235                                         modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
3236                                                                                         server_account_name,
3237                                                                                         *username);
3238                                         completed = TRUE;
3239
3240                                         const gboolean username_was_changed =
3241                                                 (strcmp (*username, initial_username) != 0);
3242                                         if (username_was_changed) {
3243                                                 g_warning ("%s: tinymail does not yet support changing the "
3244                                                            "username in the get_password() callback.\n", __FUNCTION__);
3245                                         }
3246                                 } else {
3247                                         /* Show error */
3248                                         modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
3249                                                                             _("mcen_ib_username_pw_incorrect"));
3250                                         completed = FALSE;
3251                                 }
3252                         }
3253
3254                         if (password) {
3255                                 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
3256
3257                                 /* We do not save the password in the configuration,
3258                                  * because this function is only called for passwords that should
3259                                  * not be remembered:
3260                                  modest_server_account_set_password (
3261                                  modest_runtime_get_account_mgr(), server_account_name,
3262                                  *password);
3263                                  */
3264                         }
3265                         if (cancel)
3266                                 *cancel   = FALSE;
3267                 } else {
3268                         modest_platform_information_banner(GTK_WIDGET (dialog),
3269                                                            NULL, _("mail_ib_login_cancelled"));
3270                         completed = TRUE;
3271                         if (username)
3272                                 *username = NULL;
3273                         if (password)
3274                                 *password = NULL;
3275                         if (cancel)
3276                                 *cancel   = TRUE;
3277                 }
3278         }
3279
3280 /* This is not in the Maemo UI spec:
3281         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
3282                 *remember = TRUE;
3283         else
3284                 *remember = FALSE;
3285 */
3286
3287         gtk_widget_destroy (dialog);
3288
3289         /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
3290 }
3291
3292 void
3293 modest_ui_actions_on_cut (GtkAction *action,
3294                           ModestWindow *window)
3295 {
3296         GtkWidget *focused_widget;
3297         GtkClipboard *clipboard;
3298
3299         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3300         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3301         if (GTK_IS_EDITABLE (focused_widget)) {
3302                 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
3303                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3304                 gtk_clipboard_store (clipboard);
3305         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3306                 GtkTextBuffer *buffer;
3307
3308                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3309                 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
3310                         gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
3311                         gtk_clipboard_set_can_store (clipboard, NULL, 0);
3312                         gtk_clipboard_store (clipboard);
3313                 }
3314         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
3315                 TnyList *header_list = modest_header_view_get_selected_headers (
3316                                 MODEST_HEADER_VIEW (focused_widget));
3317                 gboolean continue_download = FALSE;
3318                 gint num_of_unc_msgs;
3319
3320                 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
3321
3322                 if (num_of_unc_msgs) {
3323                         TnyAccount *account = get_account_from_header_list (header_list);
3324                         continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
3325                         g_object_unref (account);
3326                 }
3327
3328                 if (num_of_unc_msgs == 0 || continue_download) {
3329 /*                      modest_platform_information_banner (
3330                                         NULL, NULL, _CS("mcen_ib_getting_items"));*/
3331                         modest_header_view_cut_selection (
3332                                         MODEST_HEADER_VIEW (focused_widget));
3333                 }
3334
3335                 g_object_unref (header_list);
3336         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3337                 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
3338         }
3339 }
3340
3341 void
3342 modest_ui_actions_on_copy (GtkAction *action,
3343                            ModestWindow *window)
3344 {
3345         GtkClipboard *clipboard;
3346         GtkWidget *focused_widget;
3347         gboolean copied = TRUE;
3348
3349         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3350         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3351
3352         if (GTK_IS_LABEL (focused_widget)) {
3353                 gchar *selection;
3354                 selection = modest_text_utils_label_get_selection (GTK_LABEL (focused_widget));
3355                 gtk_clipboard_set_text (clipboard, selection, -1);
3356                 g_free (selection);
3357                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3358                 gtk_clipboard_store (clipboard);
3359         } else if (GTK_IS_EDITABLE (focused_widget)) {
3360                 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
3361                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3362                 gtk_clipboard_store (clipboard);
3363         } else if (GTK_IS_HTML (focused_widget)) {
3364                 gtk_html_copy (GTK_HTML (focused_widget));
3365                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3366                 gtk_clipboard_store (clipboard);
3367         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3368                 GtkTextBuffer *buffer;
3369                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3370                 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
3371                         gtk_text_buffer_copy_clipboard (buffer, clipboard);
3372                         gtk_clipboard_set_can_store (clipboard, NULL, 0);
3373                         gtk_clipboard_store (clipboard);
3374                 }
3375         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
3376                 TnyList *header_list = modest_header_view_get_selected_headers (
3377                                 MODEST_HEADER_VIEW (focused_widget));
3378                 gboolean continue_download = FALSE;
3379                 gint num_of_unc_msgs;
3380
3381                 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
3382
3383                 if (num_of_unc_msgs) {
3384                         TnyAccount *account = get_account_from_header_list (header_list);
3385                         continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
3386                         g_object_unref (account);
3387                 }
3388
3389                 if (num_of_unc_msgs == 0 || continue_download) {
3390                         modest_platform_information_banner (
3391                                         NULL, NULL, _CS("mcen_ib_getting_items"));
3392                         modest_header_view_copy_selection (
3393                                         MODEST_HEADER_VIEW (focused_widget));
3394                 } else
3395                         copied = FALSE;
3396
3397                 g_object_unref (header_list);
3398
3399         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3400                 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
3401         }
3402
3403         /* Show information banner if there was a copy to clipboard */
3404         if(copied)
3405                 modest_platform_information_banner (
3406                                 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
3407 }
3408
3409 void
3410 modest_ui_actions_on_undo (GtkAction *action,
3411                            ModestWindow *window)
3412 {
3413         ModestEmailClipboard *clipboard = NULL;
3414
3415         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3416                 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
3417         } else if (MODEST_IS_MAIN_WINDOW (window)) {
3418                 /* Clear clipboard source */
3419                 clipboard = modest_runtime_get_email_clipboard ();
3420                 modest_email_clipboard_clear (clipboard);
3421         }
3422         else {
3423                 g_return_if_reached ();
3424         }
3425 }
3426
3427 void
3428 modest_ui_actions_on_redo (GtkAction *action,
3429                            ModestWindow *window)
3430 {
3431         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3432                 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
3433         }
3434         else {
3435                 g_return_if_reached ();
3436         }
3437 }
3438
3439
3440 static void
3441 destroy_information_note (ModestMailOperation *mail_op,
3442                           gpointer user_data)
3443 {
3444         /* destroy information note */
3445         gtk_widget_destroy (GTK_WIDGET(user_data));
3446 }
3447
3448 static void
3449 destroy_folder_information_note (ModestMailOperation *mail_op,
3450                                  TnyFolder *new_folder,
3451                                  gpointer user_data)
3452 {
3453         /* destroy information note */
3454         gtk_widget_destroy (GTK_WIDGET(user_data));
3455 }
3456
3457
3458 static void
3459 paste_as_attachment_free (gpointer data)
3460 {
3461         PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
3462
3463         gtk_widget_destroy (helper->banner);
3464         g_object_unref (helper->banner);
3465         g_free (helper);
3466 }
3467
3468 static void
3469 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
3470                             TnyHeader *header,
3471                             TnyMsg *msg,
3472                             gpointer userdata)
3473 {
3474         PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
3475         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
3476
3477         if (msg == NULL)
3478                 return;
3479
3480         modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
3481
3482 }
3483
3484 void
3485 modest_ui_actions_on_paste (GtkAction *action,
3486                             ModestWindow *window)
3487 {
3488         GtkWidget *focused_widget = NULL;
3489         GtkWidget *inf_note = NULL;
3490         ModestMailOperation *mail_op = NULL;
3491
3492         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3493         if (GTK_IS_EDITABLE (focused_widget)) {
3494                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
3495         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3496                 ModestEmailClipboard *e_clipboard = NULL;
3497                 e_clipboard = modest_runtime_get_email_clipboard ();
3498                 if (modest_email_clipboard_cleared (e_clipboard)) {
3499                         GtkTextBuffer *buffer;
3500                         GtkClipboard *clipboard;
3501
3502                         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3503                         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3504                         gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
3505                 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3506                         ModestMailOperation *mail_op;
3507                         TnyFolder *src_folder;
3508                         TnyList *data;
3509                         gboolean delete;
3510                         PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
3511                         helper->window = MODEST_MSG_EDIT_WINDOW (window);
3512                         helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3513                                                                            _CS("ckct_nw_pasting"));
3514                         modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
3515                         mail_op = modest_mail_operation_new (G_OBJECT (window));
3516                         if (helper->banner != NULL) {
3517                                 g_object_ref (G_OBJECT (helper->banner));
3518                                 gtk_window_set_modal (GTK_WINDOW (helper->banner), FALSE);
3519                                 gtk_widget_show (GTK_WIDGET (helper->banner));
3520                         }
3521
3522                         if (data != NULL) {
3523                                 modest_mail_operation_get_msgs_full (mail_op,
3524                                                                      data,
3525                                                                      (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
3526                                                                      helper,
3527                                                                      paste_as_attachment_free);
3528                         }
3529                 }
3530         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3531                 ModestEmailClipboard *clipboard = NULL;
3532                 TnyFolder *src_folder = NULL;
3533                 TnyFolderStore *folder_store = NULL;
3534                 TnyList *data = NULL;
3535                 gboolean delete = FALSE;
3536
3537                 /* Check clipboard source */
3538                 clipboard = modest_runtime_get_email_clipboard ();
3539                 if (modest_email_clipboard_cleared (clipboard))
3540                         return;
3541
3542                 /* Get elements to paste */
3543                 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
3544
3545                 /* Create a new mail operation */
3546                 mail_op = modest_mail_operation_new (G_OBJECT(window));
3547
3548                 /* Get destination folder */
3549                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
3550
3551                 /* transfer messages  */
3552                 if (data != NULL) {
3553                         gint response = 0;
3554
3555                         /* Ask for user confirmation */
3556                         response =
3557                                 modest_ui_actions_msgs_move_to_confirmation (window,
3558                                                                              TNY_FOLDER (folder_store),
3559                                                                              delete,
3560                                                                              data);
3561
3562                         if (response == GTK_RESPONSE_OK) {
3563                                 /* Launch notification */
3564                                 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3565                                                                              _CS("ckct_nw_pasting"));
3566                                 if (inf_note != NULL)  {
3567                                         gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3568                                         gtk_widget_show (GTK_WIDGET(inf_note));
3569                                 }
3570
3571                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3572                                 modest_mail_operation_xfer_msgs (mail_op,
3573                                                                  data,
3574                                                                  TNY_FOLDER (folder_store),
3575                                                                  delete,
3576                                                                  destroy_information_note,
3577                                                                  inf_note);
3578                         } else {
3579                                 g_object_unref (mail_op);
3580                         }
3581
3582                 } else if (src_folder != NULL) {
3583                         /* Launch notification */
3584                         inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3585                                                                      _CS("ckct_nw_pasting"));
3586                         if (inf_note != NULL)  {
3587                                 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3588                                 gtk_widget_show (GTK_WIDGET(inf_note));
3589                         }
3590
3591                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3592                         modest_mail_operation_xfer_folder (mail_op,
3593                                                            src_folder,
3594                                                            folder_store,
3595                                                            delete,
3596                                                            destroy_folder_information_note,
3597                                                            inf_note);
3598                 }
3599
3600                 /* Free */
3601                 if (data != NULL)
3602                         g_object_unref (data);
3603                 if (src_folder != NULL)
3604                         g_object_unref (src_folder);
3605                 if (folder_store != NULL)
3606                         g_object_unref (folder_store);
3607         }
3608 }
3609
3610
3611 void
3612 modest_ui_actions_on_select_all (GtkAction *action,
3613                                  ModestWindow *window)
3614 {
3615         GtkWidget *focused_widget;
3616
3617         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3618         if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
3619                 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
3620         } else if (GTK_IS_LABEL (focused_widget)) {
3621                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
3622         } else if (GTK_IS_EDITABLE (focused_widget)) {
3623                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
3624         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3625                 GtkTextBuffer *buffer;
3626                 GtkTextIter start, end;
3627
3628                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3629                 gtk_text_buffer_get_start_iter (buffer, &start);
3630                 gtk_text_buffer_get_end_iter (buffer, &end);
3631                 gtk_text_buffer_select_range (buffer, &start, &end);
3632         } else if (GTK_IS_HTML (focused_widget)) {
3633                 gtk_html_select_all (GTK_HTML (focused_widget));
3634         } else if (MODEST_IS_MAIN_WINDOW (window)) {
3635                 GtkWidget *header_view = focused_widget;
3636                 GtkTreeSelection *selection = NULL;
3637
3638                 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
3639                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3640                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3641                 }
3642
3643                 /* Disable window dimming management */
3644                 modest_window_disable_dimming (MODEST_WINDOW(window));
3645
3646                 /* Select all messages */
3647                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
3648                 gtk_tree_selection_select_all (selection);
3649
3650                 /* Set focuse on header view */
3651                 gtk_widget_grab_focus (header_view);
3652
3653
3654                 /* Enable window dimming management */
3655                 modest_window_enable_dimming (MODEST_WINDOW(window));
3656                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
3657         }
3658
3659 }
3660
3661 void
3662 modest_ui_actions_on_mark_as_read (GtkAction *action,
3663                                    ModestWindow *window)
3664 {
3665         g_return_if_fail (MODEST_IS_WINDOW(window));
3666
3667         /* Mark each header as read */
3668         do_headers_action (window, headers_action_mark_as_read, NULL);
3669 }
3670
3671 void
3672 modest_ui_actions_on_mark_as_unread (GtkAction *action,
3673                                      ModestWindow *window)
3674 {
3675         g_return_if_fail (MODEST_IS_WINDOW(window));
3676
3677         /* Mark each header as read */
3678         do_headers_action (window, headers_action_mark_as_unread, NULL);
3679 }
3680
3681 void
3682 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
3683                                   GtkRadioAction *selected,
3684                                   ModestWindow *window)
3685 {
3686         gint value;
3687
3688         value = gtk_radio_action_get_current_value (selected);
3689         if (MODEST_IS_WINDOW (window)) {
3690                 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
3691         }
3692 }
3693
3694 void
3695 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
3696                                                GtkRadioAction *selected,
3697                                                ModestWindow *window)
3698 {
3699         TnyHeaderFlags flags;
3700         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3701
3702         flags = gtk_radio_action_get_current_value (selected);
3703         modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
3704 }
3705
3706 void
3707 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
3708                                                   GtkRadioAction *selected,
3709                                                   ModestWindow *window)
3710 {
3711         gint file_format;
3712
3713         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3714
3715         file_format = gtk_radio_action_get_current_value (selected);
3716         modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
3717 }
3718
3719
3720 void
3721 modest_ui_actions_on_zoom_plus (GtkAction *action,
3722                                 ModestWindow *window)
3723 {
3724         g_return_if_fail (MODEST_IS_WINDOW (window));
3725
3726         modest_window_zoom_plus (MODEST_WINDOW (window));
3727 }
3728
3729 void
3730 modest_ui_actions_on_zoom_minus (GtkAction *action,
3731                                  ModestWindow *window)
3732 {
3733         g_return_if_fail (MODEST_IS_WINDOW (window));
3734
3735         modest_window_zoom_minus (MODEST_WINDOW (window));
3736 }
3737
3738 void
3739 modest_ui_actions_on_toggle_fullscreen    (GtkToggleAction *toggle,
3740                                            ModestWindow *window)
3741 {
3742         ModestWindowMgr *mgr;
3743         gboolean fullscreen, active;
3744         g_return_if_fail (MODEST_IS_WINDOW (window));
3745
3746         mgr = modest_runtime_get_window_mgr ();
3747
3748         active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
3749         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3750
3751         if (active != fullscreen) {
3752                 modest_window_mgr_set_fullscreen_mode (mgr, active);
3753                 gtk_window_present (GTK_WINDOW (window));
3754         }
3755 }
3756
3757 void
3758 modest_ui_actions_on_change_fullscreen (GtkAction *action,
3759                                         ModestWindow *window)
3760 {
3761         ModestWindowMgr *mgr;
3762         gboolean fullscreen;
3763
3764         g_return_if_fail (MODEST_IS_WINDOW (window));
3765
3766         mgr = modest_runtime_get_window_mgr ();
3767         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3768         modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
3769
3770         gtk_window_present (GTK_WINDOW (window));
3771 }
3772
3773 /*
3774  * Used by modest_ui_actions_on_details to call do_headers_action
3775  */
3776 static void
3777 headers_action_show_details (TnyHeader *header,
3778                              ModestWindow *window,
3779                              gpointer user_data)
3780
3781 {
3782         GtkWidget *dialog;
3783
3784         /* Create dialog */
3785         dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
3786
3787         /* Run dialog */
3788         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3789         gtk_widget_show_all (dialog);
3790         gtk_dialog_run (GTK_DIALOG (dialog));
3791
3792         gtk_widget_destroy (dialog);
3793 }
3794
3795 /*
3796  * Show the folder details in a ModestDetailsDialog widget
3797  */
3798 static void
3799 show_folder_details (TnyFolder *folder,
3800                      GtkWindow *window)
3801 {
3802         GtkWidget *dialog;
3803
3804         /* Create dialog */
3805         dialog = modest_details_dialog_new_with_folder (window, folder);
3806
3807         /* Run dialog */
3808         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3809         gtk_widget_show_all (dialog);
3810         gtk_dialog_run (GTK_DIALOG (dialog));
3811
3812         gtk_widget_destroy (dialog);
3813 }
3814
3815 /*
3816  * Show the header details in a ModestDetailsDialog widget
3817  */
3818 void
3819 modest_ui_actions_on_details (GtkAction *action,
3820                               ModestWindow *win)
3821 {
3822         TnyList * headers_list;
3823         TnyIterator *iter;
3824         TnyHeader *header;
3825
3826         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3827                 TnyMsg *msg;
3828
3829                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3830                 if (!msg)
3831                         return;
3832                 g_object_unref (msg);
3833
3834                 headers_list = get_selected_headers (win);
3835                 if (!headers_list)
3836                         return;
3837
3838                 iter = tny_list_create_iterator (headers_list);
3839
3840                 header = TNY_HEADER (tny_iterator_get_current (iter));
3841                 if (header) {
3842                         headers_action_show_details (header, win, NULL);
3843                         g_object_unref (header);
3844                 }
3845
3846                 g_object_unref (iter);
3847                 g_object_unref (headers_list);
3848
3849         } else if (MODEST_IS_MAIN_WINDOW (win)) {
3850                 GtkWidget *folder_view, *header_view;
3851
3852                 /* Check which widget has the focus */
3853                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3854                                                                     MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3855                 if (gtk_widget_is_focus (folder_view)) {
3856                         TnyFolderStore *folder_store
3857                                 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3858                         if (!folder_store) {
3859                                 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3860                                 return;
3861                         }
3862                         /* Show only when it's a folder */
3863                         /* This function should not be called for account items,
3864                          * because we dim the menu item for them. */
3865                         if (TNY_IS_FOLDER (folder_store)) {
3866                                 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3867                         }
3868
3869                         g_object_unref (folder_store);
3870
3871                 } else {
3872                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3873                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3874                         /* Show details of each header */
3875                         do_headers_action (win, headers_action_show_details, header_view);
3876                 }
3877         }
3878 }
3879
3880 void
3881 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3882                                      ModestMsgEditWindow *window)
3883 {
3884         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3885
3886         modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3887 }
3888
3889 void
3890 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3891                                       ModestMsgEditWindow *window)
3892 {
3893         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3894
3895         modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3896 }
3897
3898 void
3899 modest_ui_actions_toggle_folders_view (GtkAction *action,
3900                                        ModestMainWindow *main_window)
3901 {
3902         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3903
3904         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3905                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3906         else
3907                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3908 }
3909
3910 void
3911 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3912                                      ModestWindow *window)
3913 {
3914         gboolean active, fullscreen = FALSE;
3915         ModestWindowMgr *mgr;
3916
3917         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3918
3919         /* Check if we want to toggle the toolbar vuew in fullscreen
3920            or normal mode */
3921         if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3922                      "ViewShowToolbarFullScreen")) {
3923                 fullscreen = TRUE;
3924         }
3925
3926         /* Toggle toolbar */
3927         mgr = modest_runtime_get_window_mgr ();
3928         modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
3929 }
3930
3931 void
3932 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3933                                            ModestMsgEditWindow *window)
3934 {
3935         modest_msg_edit_window_select_font (window);
3936 }
3937
3938
3939 void
3940 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3941                                                   const gchar *display_name,
3942                                                   GtkWindow *window)
3943 {
3944         /* don't update the display name if it was already set;
3945          * updating the display name apparently is expensive */
3946         const gchar* old_name = gtk_window_get_title (window);
3947
3948         if (display_name == NULL)
3949                 display_name = " ";
3950
3951         if (old_name && display_name && strcmp (old_name, display_name) == 0)
3952                 return; /* don't do anything */
3953
3954         /* This is usually used to change the title of the main window, which
3955          * is the one that holds the folder view. Note that this change can
3956          * happen even when the widget doesn't have the focus. */
3957         gtk_window_set_title (window, display_name);
3958
3959 }
3960
3961 void
3962 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3963 {
3964         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3965         modest_msg_edit_window_select_contacts (window);
3966 }
3967
3968 void
3969 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3970 {
3971         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3972         modest_msg_edit_window_check_names (window, FALSE);
3973 }
3974
3975 static void
3976 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3977 {
3978         modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3979                                          GTK_WIDGET (user_data));
3980 }
3981
3982 /*
3983  * This function is used to track changes in the selection of the
3984  * folder view that is inside the "move to" dialog to enable/disable
3985  * the OK button because we do not want the user to select a disallowed
3986  * destination for a folder.
3987  * The user also not desired to be able to use NEW button on items where
3988  * folder creation is not possibel.
3989  */
3990 static void
3991 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
3992                                             TnyFolderStore *folder_store,
3993                                             gboolean selected,
3994                                             gpointer user_data)
3995 {
3996         GtkWidget *dialog = NULL;
3997         GtkWidget *ok_button = NULL, *new_button = NULL;
3998         GList *children = NULL;
3999         gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
4000         gboolean moving_folder = FALSE;
4001         gboolean is_local_account = TRUE;
4002         GtkWidget *folder_view = NULL;
4003         ModestTnyFolderRules rules;
4004
4005         g_return_if_fail (MODEST_IS_FOLDER_VIEW(self));
4006
4007         if (!selected)
4008                 return;
4009
4010         /* Get the OK button */
4011         dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
4012         if (!dialog)
4013                 return;
4014
4015         children = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
4016         ok_button = GTK_WIDGET (children->next->next->data);
4017         new_button = GTK_WIDGET (children->next->data);
4018         g_list_free (children);
4019
4020         /* check if folder_store is an remote account */
4021         if (TNY_IS_ACCOUNT (folder_store)) {
4022                 TnyAccount *local_account = NULL;
4023                 TnyAccount *mmc_account = NULL;
4024                 ModestTnyAccountStore *account_store = NULL;
4025
4026                 account_store = modest_runtime_get_account_store ();
4027                 local_account = modest_tny_account_store_get_local_folders_account (account_store);
4028                 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
4029
4030                 if ((gpointer) local_account != (gpointer) folder_store &&
4031                     (gpointer) mmc_account != (gpointer) folder_store) {
4032                         const char *proto_name = tny_account_get_proto (TNY_ACCOUNT (folder_store));
4033                         ModestTransportStoreProtocol proto = MODEST_PROTOCOL_STORE_MAILDIR;
4034                         if (proto_name != NULL) {
4035                                 proto = modest_protocol_info_get_transport_store_protocol (proto_name);
4036                         }
4037                         is_local_account = FALSE;
4038                         /* New button should be dimmed on remote
4039                            POP account root */
4040                         new_sensitive = (proto != MODEST_PROTOCOL_STORE_POP);
4041                 }
4042                 g_object_unref (local_account);
4043         }
4044
4045         /* Check the target folder rules */
4046         if (TNY_IS_FOLDER (folder_store)) {
4047                 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
4048                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
4049                         ok_sensitive = FALSE;
4050                         new_sensitive = FALSE;
4051                         goto end;
4052                 }
4053         }
4054
4055         /* Check if we're moving a folder */
4056         if (MODEST_IS_MAIN_WINDOW (user_data)) {
4057                 /* Get the widgets */
4058                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
4059                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4060                 if (gtk_widget_is_focus (folder_view))
4061                         moving_folder = TRUE;
4062         }
4063
4064         if (moving_folder) {
4065                 TnyFolderStore *moved_folder = NULL, *parent = NULL;
4066
4067                 /* Get the folder to move */
4068                 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4069
4070                 /* Check that we're not moving to the same folder */
4071                 if (TNY_IS_FOLDER (moved_folder)) {
4072                         parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
4073                         if (parent == folder_store)
4074                                 ok_sensitive = FALSE;
4075                         g_object_unref (parent);
4076                 }
4077
4078                 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
4079                         /* Do not allow to move to an account unless it's the
4080                            local folders account */
4081                         if (!is_local_account)
4082                                 ok_sensitive = FALSE;
4083                 }
4084
4085                 if (ok_sensitive && (moved_folder == folder_store)) {
4086                         /* Do not allow to move to itself */
4087                         ok_sensitive = FALSE;
4088                 }
4089                 g_object_unref (moved_folder);
4090         } else {
4091                 TnyFolder *src_folder = NULL;
4092
4093                 /* Moving a message */
4094                 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
4095
4096                         TnyHeader *header = NULL;
4097                         header = modest_msg_view_window_get_header
4098                                 (MODEST_MSG_VIEW_WINDOW (user_data));
4099                         if (!TNY_IS_HEADER(header))
4100                                 g_warning ("%s: could not get source header", __FUNCTION__);
4101                         else
4102                                 src_folder = tny_header_get_folder (header);
4103
4104                         if (header)
4105                                 g_object_unref (header);
4106                 } else {
4107                         src_folder =
4108                                 TNY_FOLDER (modest_folder_view_get_selected
4109                                             (MODEST_FOLDER_VIEW (folder_view)));
4110                 }
4111
4112                 if (TNY_IS_FOLDER(src_folder)) {
4113                         /* Do not allow to move the msg to the same folder */
4114                         /* Do not allow to move the msg to an account */
4115                         if ((gpointer) src_folder == (gpointer) folder_store ||
4116                             TNY_IS_ACCOUNT (folder_store))
4117                                 ok_sensitive = FALSE;
4118                         g_object_unref (src_folder);
4119                 } else
4120                         g_warning ("%s: could not get source folder", __FUNCTION__);
4121         }
4122
4123  end:
4124         /* Set sensitivity of the OK button */
4125         gtk_widget_set_sensitive (ok_button, ok_sensitive);
4126         /* Set sensitivity of the NEW button */
4127         gtk_widget_set_sensitive (new_button, new_sensitive);
4128 }
4129
4130
4131 #define MODEST_MOVE_TO_DIALOG_FOLDER_VIEW "move-to-dialog-folder-view"
4132
4133 static GtkWidget*
4134 get_folder_view_from_move_to_dialog (GtkWidget *move_to_dialog)
4135 {
4136         return GTK_WIDGET(g_object_get_data (G_OBJECT(move_to_dialog),
4137                                              MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
4138 }
4139
4140 static GtkWidget*
4141 create_move_to_dialog (GtkWindow *win,
4142                        GtkWidget *folder_view,
4143                        GtkWidget **tree_view)
4144 {
4145         GtkWidget *dialog, *scroll;
4146         GtkWidget *new_button;
4147
4148         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
4149                                               GTK_WINDOW (win),
4150                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
4151                                               NULL);
4152
4153         gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
4154         /* We do this manually so GTK+ does not associate a response ID for
4155          * the button. */
4156         new_button = gtk_button_new_from_stock (_("mcen_bd_new"));
4157         gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
4158         gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_cancel"), GTK_RESPONSE_REJECT);
4159
4160         /* Create scrolled window */
4161         scroll = gtk_scrolled_window_new (NULL, NULL);
4162         gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scroll),
4163                                          GTK_POLICY_AUTOMATIC,
4164                                          GTK_POLICY_AUTOMATIC);
4165
4166         /* Create folder view */
4167         *tree_view = modest_platform_create_folder_view (NULL);
4168
4169         /* Track changes in the selection to
4170          * disable the OK button whenever "Move to" is not possible
4171          * disbale NEW button whenever New is not possible */
4172         g_signal_connect (*tree_view,
4173                           "folder_selection_changed",
4174                           G_CALLBACK (on_move_to_dialog_folder_selection_changed),
4175                           win);
4176
4177         /* Listen to clicks on New button */
4178         g_signal_connect (G_OBJECT (new_button),
4179                           "clicked",
4180                           G_CALLBACK(create_move_to_dialog_on_new_folder),
4181                           *tree_view);
4182
4183         /* It could happen that we're trying to move a message from a
4184            window (msg window for example) after the main window was
4185            closed, so we can not just get the model of the folder
4186            view */
4187         if (MODEST_IS_FOLDER_VIEW (folder_view)) {
4188                 const gchar *visible_id = NULL;
4189
4190                 modest_folder_view_set_style (MODEST_FOLDER_VIEW (*tree_view),
4191                                               MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
4192                 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
4193                                                MODEST_FOLDER_VIEW(*tree_view));
4194
4195                 visible_id =
4196                         modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
4197
4198                 /* Show the same account than the one that is shown in the main window */
4199                 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(*tree_view),
4200                                                                              visible_id);
4201         } else {
4202                 const gchar *active_account_name = NULL;
4203                 ModestAccountMgr *mgr = NULL;
4204                 ModestAccountSettings *settings = NULL;
4205                 ModestServerAccountSettings *store_settings = NULL;
4206
4207                 modest_folder_view_set_style (MODEST_FOLDER_VIEW (*tree_view),
4208                                               MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
4209                 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
4210                                                  TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
4211
4212                 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
4213                 mgr = modest_runtime_get_account_mgr ();
4214                 settings = modest_account_mgr_load_account_settings (mgr, active_account_name);
4215
4216                 if (settings) {
4217                         const gchar *store_account_name;
4218                         store_settings = modest_account_settings_get_store_settings (settings);
4219                         store_account_name = modest_server_account_settings_get_account_name (store_settings);
4220
4221                         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (*tree_view),
4222                                                                                      store_account_name);
4223                         g_object_unref (store_settings);
4224                         g_object_unref (settings);
4225                 }
4226         }
4227
4228         /* we keep a pointer to the embedded folder view, so we can retrieve it with
4229          *   get_folder_view_from_move_to_dialog
4230          * (see above) later (needed for focus handling)
4231          */
4232         g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, *tree_view);
4233
4234
4235         /* Hide special folders */
4236         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
4237
4238         gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
4239
4240         /* Add scroll to dialog */
4241         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
4242                             scroll, TRUE, TRUE, 0);
4243
4244         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
4245         gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
4246
4247         return dialog;
4248 }
4249
4250 /*
4251  * Returns TRUE if at least one of the headers of the list belongs to
4252  * a message that has been fully retrieved.
4253  */
4254 #if 0 /* no longer in use. delete in 2007.10 */
4255 static gboolean
4256 has_retrieved_msgs (TnyList *list)
4257 {
4258         TnyIterator *iter;
4259         gboolean found = FALSE;
4260
4261         iter = tny_list_create_iterator (list);
4262         while (!tny_iterator_is_done (iter) && !found) {
4263                 TnyHeader *header;
4264                 TnyHeaderFlags flags = 0;
4265
4266                 header = TNY_HEADER (tny_iterator_get_current (iter));
4267                 if (header) {
4268                         flags = tny_header_get_flags (header);
4269                         if (flags & TNY_HEADER_FLAG_CACHED)
4270 /*                      if (!(flags & TNY_HEADER_FLAG_PARTIAL)) */
4271                                 found = TRUE;
4272
4273                         g_object_unref (header);
4274                 }
4275
4276                 if (!found)
4277                         tny_iterator_next (iter);
4278         }
4279         g_object_unref (iter);
4280
4281         return found;
4282 }
4283 #endif /* 0 */
4284
4285
4286 /*
4287  * Shows a confirmation dialog to the user when we're moving messages
4288  * from a remote server to the local storage. Returns the dialog
4289  * response. If it's other kind of movement then it always returns
4290  * GTK_RESPONSE_OK
4291  *
4292  * This one is used by the next functions:
4293  *      modest_ui_actions_on_paste                      - commented out
4294  *      drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
4295  */
4296 gint
4297 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
4298                                              TnyFolder *dest_folder,
4299                                              gboolean delete,
4300                                              TnyList *headers)
4301 {
4302         gint response = GTK_RESPONSE_OK;
4303         TnyAccount *account = NULL;
4304         TnyFolder *src_folder = NULL;
4305         TnyIterator *iter = NULL;
4306         TnyHeader *header = NULL;
4307
4308         /* return with OK if the destination is a remote folder */
4309         if (modest_tny_folder_is_remote_folder (dest_folder))
4310                 return GTK_RESPONSE_OK;
4311
4312         /* Get source folder */
4313         iter = tny_list_create_iterator (headers);
4314         header = TNY_HEADER (tny_iterator_get_current (iter));
4315         if (header) {
4316                 src_folder = tny_header_get_folder (header);
4317                 g_object_unref (header);
4318         }
4319         g_object_unref (iter);
4320
4321         /* if no src_folder, message may be an attahcment */
4322         if (src_folder == NULL)
4323                 return GTK_RESPONSE_CANCEL;
4324
4325         /* If the source is a local or MMC folder */
4326         if (!modest_tny_folder_is_remote_folder (src_folder)) {
4327                 g_object_unref (src_folder);
4328                 return GTK_RESPONSE_OK;
4329         }
4330
4331         /* Get the account */
4332         account = tny_folder_get_account (src_folder);
4333
4334         /* now if offline we ask the user */
4335         if(connect_to_get_msg (win, tny_list_get_length (headers), account))
4336                 response = GTK_RESPONSE_OK;
4337         else
4338                 response = GTK_RESPONSE_CANCEL;
4339
4340         /* Frees */
4341         g_object_unref (src_folder);
4342         g_object_unref (account);
4343
4344         return response;
4345 }
4346
4347 static void
4348 move_to_cb (ModestMailOperation *mail_op,
4349             gpointer user_data)
4350 {
4351         MoveToHelper *helper = (MoveToHelper *) user_data;
4352
4353         /* Note that the operation could have failed, in that case do
4354            nothing */
4355         if (modest_mail_operation_get_status (mail_op) ==
4356             MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
4357
4358                 GObject *object = modest_mail_operation_get_source (mail_op);
4359                 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
4360                         ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
4361
4362                         if (!modest_msg_view_window_select_next_message (self) &&
4363                             !modest_msg_view_window_select_previous_message (self)) {
4364                                 /* No more messages to view, so close this window */
4365                                 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
4366                         }
4367                 } else if (MODEST_IS_MAIN_WINDOW (object) && helper->reference != NULL) {
4368                         GtkWidget *header_view;
4369                         GtkTreePath *path;
4370                         GtkTreeSelection *sel;
4371
4372                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
4373                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4374                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
4375                         path = gtk_tree_row_reference_get_path (helper->reference);
4376                         gtk_tree_selection_select_path (sel, path);
4377                         gtk_tree_path_free (path);
4378                 }
4379                 g_object_unref (object);
4380         }
4381
4382         /* Close the "Pasting" information banner */
4383         gtk_widget_destroy (GTK_WIDGET(helper->banner));
4384         if (helper->reference != NULL)
4385                 gtk_tree_row_reference_free (helper->reference);
4386         g_free (helper);
4387 }
4388
4389 static void
4390 folder_move_to_cb (ModestMailOperation *mail_op,
4391                    TnyFolder *new_folder,
4392                    gpointer user_data)
4393 {
4394         GtkWidget *folder_view;
4395         GObject *object;
4396
4397         object = modest_mail_operation_get_source (mail_op);
4398         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
4399                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4400         g_object_ref (folder_view);
4401         g_object_unref (object);
4402         move_to_cb (mail_op, user_data);
4403         modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), new_folder, FALSE);
4404         g_object_unref (folder_view);
4405 }
4406
4407 static void
4408 msgs_move_to_cb (ModestMailOperation *mail_op,
4409                  gpointer user_data)
4410 {
4411         move_to_cb (mail_op, user_data);
4412 }
4413
4414 void
4415 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
4416                                              gpointer user_data)
4417 {
4418         ModestWindow *main_window = NULL;
4419         GObject *win = NULL;
4420
4421         /* Disable next automatic folder selection */
4422         main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
4423                                                          FALSE); /* don't create */
4424         if (main_window) {
4425                 GtkWidget *folder_view = NULL;
4426
4427                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
4428                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4429                 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
4430
4431                 if (user_data && TNY_IS_FOLDER (user_data)) {
4432                         modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
4433                                                           TNY_FOLDER (user_data), FALSE);
4434                 }
4435         }
4436
4437         /* Show notification dialog */
4438         win = modest_mail_operation_get_source (mail_op);
4439         modest_platform_run_information_dialog ((GtkWindow *) win, _("mail_in_ui_folder_move_target_error"));
4440         if (win)
4441                 g_object_unref (win);
4442 }
4443
4444 void
4445 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
4446                                               gpointer user_data)
4447 {
4448         GObject *win = modest_mail_operation_get_source (mail_op);
4449         const GError *error = modest_mail_operation_get_error (mail_op);
4450
4451         g_return_if_fail (error != NULL);
4452         if (error->message != NULL)
4453                 g_printerr ("modest: %s\n", error->message);
4454         else
4455                 g_printerr ("modest: unkonw error on send&receive operation");
4456
4457         /* Show error message */
4458 /*      if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
4459 /*              modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
4460 /*                                                      _CS("sfil_ib_unable_to_receive")); */
4461 /*      else  */
4462 /*              modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
4463 /*                                                      _CS("sfil_ib_unable_to_send")); */
4464         g_object_unref (win);
4465 }
4466
4467 static void
4468 open_msg_for_purge_cb (ModestMailOperation *mail_op,
4469                        TnyHeader *header,
4470                        gboolean canceled,
4471                        TnyMsg *msg,
4472                        GError *err,
4473                        gpointer user_data)
4474 {
4475         TnyList *parts;
4476         TnyIterator *iter;
4477         gint pending_purges = 0;
4478         gboolean some_purged = FALSE;
4479         ModestWindow *win = MODEST_WINDOW (user_data);
4480         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
4481
4482         /* If there was any error */
4483         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
4484                 modest_window_mgr_unregister_header (mgr, header);
4485                 return;
4486         }
4487
4488         /* Once the message has been retrieved for purging, we check if
4489          * it's all ok for purging */
4490
4491         parts = tny_simple_list_new ();
4492         tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
4493         iter = tny_list_create_iterator (parts);
4494
4495         while (!tny_iterator_is_done (iter)) {
4496                 TnyMimePart *part;
4497                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
4498                 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
4499                         if (tny_mime_part_is_purged (part))
4500                                 some_purged = TRUE;
4501                         else
4502                                 pending_purges++;
4503                 }
4504
4505                 if (part)
4506                         g_object_unref (part);
4507
4508                 tny_iterator_next (iter);
4509         }
4510         g_object_unref (iter);
4511
4512
4513         if (pending_purges>0) {
4514                 gint response;
4515                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
4516
4517                 if (response == GTK_RESPONSE_OK) {
4518                         modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
4519                         iter = tny_list_create_iterator (parts);
4520                         while (!tny_iterator_is_done (iter)) {
4521                                 TnyMimePart *part;
4522
4523                                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
4524                                 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
4525                                         tny_mime_part_set_purged (part);
4526
4527                                 if (part)
4528                                         g_object_unref (part);
4529
4530                                 tny_iterator_next (iter);
4531                         }
4532                         g_object_unref (iter);
4533
4534                         tny_msg_rewrite_cache (msg);
4535                 }
4536      /* } else { */
4537                 /* This string no longer exists, refer to NB#75415 for more info */
4538                 /* modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged")); */
4539         }
4540
4541         modest_window_mgr_unregister_header (mgr, header);
4542
4543         g_object_unref (parts);
4544 }
4545
4546 static void
4547 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
4548                                                      ModestMainWindow *win)
4549 {
4550         GtkWidget *header_view;
4551         TnyList *header_list;
4552         TnyHeader *header;
4553         TnyHeaderFlags flags;
4554         ModestWindow *msg_view_window =  NULL;
4555         gboolean found;
4556
4557         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
4558
4559         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4560                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4561
4562         header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
4563         if (!header_list) {
4564                 g_warning ("%s: no header selected", __FUNCTION__);
4565                 return;
4566         }
4567
4568         if (tny_list_get_length (header_list) == 1) {
4569                 TnyIterator *iter = tny_list_create_iterator (header_list);
4570                 header = TNY_HEADER (tny_iterator_get_current (iter));
4571                 g_object_unref (iter);
4572         } else
4573                 return;
4574
4575         if (!header || !TNY_IS_HEADER(header)) {
4576                 g_warning ("%s: header is not valid", __FUNCTION__);
4577                 return;
4578         }
4579
4580         found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
4581                                                           header, &msg_view_window);
4582         flags = tny_header_get_flags (header);
4583         if (!(flags & TNY_HEADER_FLAG_CACHED))
4584                 return;
4585         if (found) {
4586                 if (msg_view_window != NULL)
4587                         modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
4588                 else {
4589                         /* do nothing; uid was registered before, so window is probably on it's way */
4590                         g_warning ("debug: header %p has already been registered", header);
4591                 }
4592         } else {
4593                 ModestMailOperation *mail_op = NULL;
4594                 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
4595                 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
4596                                                                          modest_ui_actions_get_msgs_full_error_handler,
4597                                                                          NULL, NULL);
4598                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4599                 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
4600
4601                 g_object_unref (mail_op);
4602         }
4603         if (header)
4604                 g_object_unref (header);
4605         if (header_list)
4606                 g_object_unref (header_list);
4607 }
4608
4609 /*
4610  * Checks if we need a connection to do the transfer and if the user
4611  * wants to connect to complete it
4612  */
4613 void
4614 modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
4615                                        TnyFolderStore *src_folder,
4616                                        TnyList *headers,
4617                                        TnyFolder *dst_folder,
4618                                        gboolean delete_originals,
4619                                        gboolean *need_connection,
4620                                        gboolean *do_xfer)
4621 {
4622         TnyAccount *src_account;
4623         gint uncached_msgs = 0;
4624
4625         uncached_msgs = header_list_count_uncached_msgs (headers);
4626
4627         /* We don't need any further check if
4628          *
4629          * 1- the source folder is local OR
4630          * 2- the device is already online
4631          */
4632         if (!modest_tny_folder_store_is_remote (src_folder) ||
4633             tny_device_is_online (modest_runtime_get_device())) {
4634                 *need_connection = FALSE;
4635                 *do_xfer = TRUE;
4636                 return;
4637         }
4638
4639         /* We must ask for a connection when
4640          *
4641          *   - the message(s) is not already cached   OR
4642          *   - the message(s) is cached but the leave_on_server setting
4643          * is FALSE (because we need to sync the source folder to
4644          * delete the message from the server (for IMAP we could do it
4645          * offline, it'll take place the next time we get a
4646          * connection)
4647          */
4648         src_account = get_account_from_folder_store (src_folder);
4649         if (uncached_msgs > 0) {
4650                 guint num_headers;
4651                 const gchar *msg;
4652
4653                 *need_connection = TRUE;
4654                 num_headers = tny_list_get_length (headers);
4655                 msg = ngettext ("mcen_nc_get_msg", "mcen_nc_get_msgs", num_headers);
4656
4657                 if (modest_platform_run_confirmation_dialog (parent_window, msg) ==
4658                     GTK_RESPONSE_CANCEL) {
4659                         *do_xfer = FALSE;
4660                 } else {
4661                         *do_xfer = TRUE;
4662                 }
4663         } else {
4664                 /* The transfer is possible and the user wants to */
4665                 *do_xfer = TRUE;
4666
4667                 if (remote_folder_is_pop (src_folder) && delete_originals) {
4668                         const gchar *account_name;
4669                         gboolean leave_on_server;
4670
4671                         account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
4672                         leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
4673                                                                                   account_name);
4674
4675                         if (leave_on_server == TRUE) {
4676                                 *need_connection = FALSE;
4677                         } else {
4678                                 *need_connection = TRUE;
4679                         }
4680                 } else {
4681                         *need_connection = FALSE;
4682                 }
4683         }
4684
4685         /* Frees */
4686         g_object_unref (src_account);
4687 }
4688
4689
4690 /**
4691  * Utility function that transfer messages from both the main window
4692  * and the msg view window when using the "Move to" dialog
4693  */
4694 static void
4695 xfer_messages_performer  (gboolean canceled,
4696                           GError *err,
4697                           GtkWindow *parent_window,
4698                           TnyAccount *account,
4699                           gpointer user_data)
4700 {
4701         TnyFolderStore *dst_folder = TNY_FOLDER_STORE (user_data);
4702         ModestWindow *win = MODEST_WINDOW (parent_window);
4703         TnyList *headers = NULL;
4704         TnyAccount *dst_account = NULL;
4705         const gchar *proto_str = NULL;
4706         gboolean dst_is_pop = FALSE;
4707
4708         if (canceled || err) {
4709                 /* Show the proper error message */
4710                 modest_ui_actions_on_account_connection_error (parent_window, account);
4711                 g_object_unref (dst_folder);
4712                 return;
4713         }
4714
4715         dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
4716         proto_str = tny_account_get_proto (dst_account);
4717
4718         /* tinymail will return NULL for local folders it seems */
4719         dst_is_pop = proto_str &&
4720                 (modest_protocol_info_get_transport_store_protocol (proto_str) ==
4721                  MODEST_PROTOCOL_STORE_POP);
4722
4723         g_object_unref (dst_account);
4724
4725         /* Get selected headers */
4726         headers = get_selected_headers (MODEST_WINDOW (win));
4727         if (!headers) {
4728                 g_warning ("%s: no headers selected", __FUNCTION__);
4729                 return;
4730         }
4731
4732
4733         if (dst_is_pop) {
4734                 modest_platform_information_banner (GTK_WIDGET (win),
4735                                                     NULL,
4736                                                     ngettext("mail_in_ui_folder_move_target_error",
4737                                                              "mail_in_ui_folder_move_targets_error",
4738                                                              tny_list_get_length (headers)));
4739                 g_object_unref (headers);
4740                 return;
4741         }
4742
4743         MoveToHelper *helper = g_new0 (MoveToHelper, 1);
4744         helper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
4745                                                            _CS("ckct_nw_pasting"));
4746         if (helper->banner != NULL)  {
4747                 gtk_window_set_modal (GTK_WINDOW(helper->banner), FALSE);
4748                 gtk_widget_show (GTK_WIDGET(helper->banner));
4749         }
4750
4751         if (MODEST_IS_MAIN_WINDOW (win)) {
4752                 GtkWidget *header_view =
4753                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
4754                                                              MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4755                 helper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
4756         }
4757
4758         ModestMailOperation *mail_op =
4759                 modest_mail_operation_new_with_error_handling (G_OBJECT(win),
4760                                                                modest_ui_actions_move_folder_error_handler,
4761                                                                NULL, NULL);
4762         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4763                                          mail_op);
4764
4765         modest_mail_operation_xfer_msgs (mail_op,
4766                                          headers,
4767                                          TNY_FOLDER (dst_folder),
4768                                          TRUE,
4769                                          msgs_move_to_cb,
4770                                          helper);
4771
4772         g_object_unref (G_OBJECT (mail_op));
4773         g_object_unref (headers);
4774         g_object_unref (dst_folder);
4775 }
4776
4777 typedef struct {
4778         TnyFolder *src_folder;
4779         TnyFolderStore *dst_folder;
4780         gboolean delete_original;
4781         GtkWidget *folder_view;
4782 } MoveFolderInfo;
4783
4784 static void
4785 on_move_folder_cb (gboolean canceled, GError *err, GtkWindow *parent_window,
4786                 TnyAccount *account, gpointer user_data)
4787 {
4788         MoveFolderInfo *info = (MoveFolderInfo*)user_data;
4789         GtkTreeSelection *sel;
4790         ModestMailOperation *mail_op = NULL;
4791
4792         if (canceled || err || !MODEST_IS_MAIN_WINDOW (parent_window)) {
4793                 g_object_unref (G_OBJECT (info->src_folder));
4794                 g_object_unref (G_OBJECT (info->dst_folder));
4795                 g_free (info);
4796                 return;
4797         }
4798
4799         MoveToHelper *helper = g_new0 (MoveToHelper, 1);
4800         helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
4801                         _CS("ckct_nw_pasting"));
4802         if (helper->banner != NULL)  {
4803                 gtk_window_set_modal (GTK_WINDOW(helper->banner), FALSE);
4804                 gtk_widget_show (GTK_WIDGET(helper->banner));
4805         }
4806         /* Clean folder on header view before moving it */
4807         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
4808         gtk_tree_selection_unselect_all (sel);
4809
4810         /* Let gtk events run. We need that the folder
4811            view frees its reference to the source
4812            folder *before* issuing the mail operation
4813            so we need the signal handler of selection
4814            changed to happen before the mail
4815            operation
4816         while (gtk_events_pending ())
4817                 gtk_main_iteration ();   */
4818
4819         mail_op =
4820                 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
4821                                 modest_ui_actions_move_folder_error_handler,
4822                                 info->src_folder, NULL);
4823         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4824                         mail_op);
4825
4826         /* Select *after* the changes */
4827         /* TODO: this function hangs UI after transfer */
4828         /*                      modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view), */
4829         /*                                                        TNY_FOLDER (src_folder), TRUE); */
4830
4831         modest_mail_operation_xfer_folder (mail_op,
4832                         TNY_FOLDER (info->src_folder),
4833                         info->dst_folder,
4834                         info->delete_original,
4835                         folder_move_to_cb,
4836                         helper);
4837
4838         if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
4839                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
4840                                                   TNY_FOLDER (info->dst_folder), TRUE);
4841         }
4842
4843         /* Unref mail operation */
4844         g_object_unref (G_OBJECT (mail_op));
4845         g_object_unref (G_OBJECT (info->src_folder));
4846         g_object_unref (G_OBJECT (info->dst_folder));
4847         g_free (user_data);
4848 }
4849
4850 static TnyAccount *
4851 get_account_from_folder_store (TnyFolderStore *folder_store)
4852 {
4853         if (TNY_IS_ACCOUNT (folder_store))
4854                 return g_object_ref (folder_store);
4855         else
4856                 return tny_folder_get_account (TNY_FOLDER (folder_store));
4857 }
4858
4859 /*
4860  * UI handler for the "Move to" action when invoked from the
4861  * ModestMainWindow
4862  */
4863 static void
4864 modest_ui_actions_on_main_window_move_to (GtkAction *action,
4865                                           GtkWidget *folder_view,
4866                                           TnyFolderStore *dst_folder,
4867                                           ModestMainWindow *win)
4868 {
4869         ModestHeaderView *header_view = NULL;
4870         TnyFolderStore *src_folder = NULL;
4871
4872         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
4873
4874         /* Get the source folder */
4875         src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4876
4877         /* Get header view */
4878         header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW));
4879
4880         /* Get folder or messages to transfer */
4881         if (gtk_widget_is_focus (folder_view)) {
4882                 gboolean do_xfer = TRUE;
4883
4884                 /* Allow only to transfer folders to the local root folder */
4885                 if (TNY_IS_ACCOUNT (dst_folder) &&
4886                     !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
4887                     !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
4888                         do_xfer = FALSE;
4889                 } else if (!TNY_IS_FOLDER (src_folder)) {
4890                         g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
4891                         do_xfer = FALSE;
4892                 }
4893
4894                 if (do_xfer) {
4895                         MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
4896                         DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
4897
4898                         info->src_folder = g_object_ref (src_folder);
4899                         info->dst_folder = g_object_ref (dst_folder);
4900                         info->delete_original = TRUE;
4901                         info->folder_view = folder_view;
4902
4903                         connect_info->callback = on_move_folder_cb;
4904                         connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
4905                         connect_info->data = info;
4906
4907                         modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
4908                                                                    TNY_FOLDER_STORE (src_folder),
4909                                                                    connect_info);
4910                 }
4911         } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
4912                 TnyList *headers;
4913
4914                 headers = modest_header_view_get_selected_headers(header_view);
4915
4916                 /* Transfer the messages */
4917                 transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
4918                                           headers, TNY_FOLDER (dst_folder));
4919
4920                 g_object_unref (headers);
4921         }
4922
4923         /* Frees */
4924         g_object_unref (src_folder);
4925 }
4926
4927
4928 static void
4929 transfer_messages_helper (GtkWindow *win,
4930                           TnyFolder *src_folder,
4931                           TnyList *headers,
4932                           TnyFolder *dst_folder)
4933 {
4934         gboolean need_connection = TRUE;
4935         gboolean do_xfer = TRUE;
4936
4937         modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
4938                                                headers, TNY_FOLDER (dst_folder),
4939                                                TRUE, &need_connection,
4940                                                &do_xfer);
4941
4942         /* If we don't want to transfer just return */
4943         if (!do_xfer)
4944                 return;
4945
4946         if (need_connection) {
4947                 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
4948                 connect_info->callback = xfer_messages_performer;
4949                 connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
4950                 connect_info->data = g_object_ref (dst_folder);
4951
4952                 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
4953                                                            TNY_FOLDER_STORE (src_folder),
4954                                                            connect_info);
4955         } else {
4956                 TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
4957                 xfer_messages_performer (FALSE, NULL, GTK_WINDOW (win),
4958                                          src_account,
4959                                          g_object_ref (dst_folder));
4960                 g_object_unref (src_account);
4961         }
4962 }
4963
4964 /*
4965  * UI handler for the "Move to" action when invoked from the
4966  * ModestMsgViewWindow
4967  */
4968 static void
4969 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
4970                                               TnyFolderStore *dst_folder,
4971                                               ModestMsgViewWindow *win)
4972 {
4973         TnyList *headers = NULL;
4974         TnyHeader *header = NULL;
4975         TnyFolder *src_folder = NULL;
4976
4977         g_return_if_fail (TNY_IS_FOLDER (dst_folder));
4978
4979         /* Create header list */
4980         header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
4981         src_folder = TNY_FOLDER (tny_header_get_folder(header));
4982         headers = tny_simple_list_new ();
4983         tny_list_append (headers, G_OBJECT (header));
4984
4985         /* Transfer the messages */
4986         transfer_messages_helper (GTK_WINDOW (win), src_folder, headers,
4987                                   TNY_FOLDER (dst_folder));
4988
4989         /* Frees */
4990         g_object_unref (header);
4991         g_object_unref (headers);
4992 }
4993
4994 void
4995 modest_ui_actions_on_move_to (GtkAction *action,
4996                               ModestWindow *win)
4997 {
4998         GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
4999         gint result = 0;
5000         TnyFolderStore *dst_folder = NULL;
5001         ModestMainWindow *main_window;
5002
5003         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
5004                           MODEST_IS_MSG_VIEW_WINDOW (win));
5005
5006         /* Get the main window if exists */
5007         if (MODEST_IS_MAIN_WINDOW (win))
5008                 main_window = MODEST_MAIN_WINDOW (win);
5009         else
5010                 main_window =
5011                         MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
5012                                                                                FALSE)); /* don't create */
5013
5014         /* Get the folder view widget if exists */
5015         if (main_window)
5016                 folder_view = modest_main_window_get_child_widget (main_window,
5017                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5018         else
5019                 folder_view = NULL;
5020
5021         /* Create and run the dialog */
5022         dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
5023         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
5024         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
5025         result = gtk_dialog_run (GTK_DIALOG(dialog));
5026         g_object_ref (tree_view);
5027         gtk_widget_destroy (dialog);
5028
5029         if (result != GTK_RESPONSE_ACCEPT)
5030                 return;
5031
5032         dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
5033         /* Do window specific stuff */
5034         if (MODEST_IS_MAIN_WINDOW (win)) {
5035                 modest_ui_actions_on_main_window_move_to (action,
5036                                 folder_view,
5037                                 dst_folder,
5038                                 MODEST_MAIN_WINDOW (win));
5039         } else {
5040                 modest_ui_actions_on_msg_view_window_move_to (action,
5041                                 dst_folder,
5042                                 MODEST_MSG_VIEW_WINDOW (win));
5043         }
5044
5045         if (dst_folder)
5046                 g_object_unref (dst_folder);
5047 }
5048
5049 /*
5050  * Calls #HeadersFunc for each header already selected in the main
5051  * window or the message currently being shown in the msg view window
5052  */
5053 static void
5054 do_headers_action (ModestWindow *win,
5055                    HeadersFunc func,
5056                    gpointer user_data)
5057 {
5058         TnyList *headers_list = NULL;
5059         TnyIterator *iter = NULL;
5060         TnyHeader *header = NULL;
5061         TnyFolder *folder = NULL;
5062
5063         /* Get headers */
5064         headers_list = get_selected_headers (win);
5065         if (!headers_list)
5066                 return;
5067
5068         /* Get the folder */
5069         iter = tny_list_create_iterator (headers_list);
5070         header = TNY_HEADER (tny_iterator_get_current (iter));
5071         if (header) {
5072                 folder = tny_header_get_folder (header);
5073                 g_object_unref (header);
5074         }
5075
5076         /* Call the function for each header */
5077         while (!tny_iterator_is_done (iter)) {
5078                 header = TNY_HEADER (tny_iterator_get_current (iter));
5079                 func (header, win, user_data);
5080                 g_object_unref (header);
5081                 tny_iterator_next (iter);
5082         }
5083
5084         /* Trick: do a poke status in order to speed up the signaling
5085            of observers */
5086         tny_folder_poke_status (folder);
5087
5088         /* Frees */
5089         g_object_unref (folder);
5090         g_object_unref (iter);
5091         g_object_unref (headers_list);
5092 }
5093
5094 void
5095 modest_ui_actions_view_attachment (GtkAction *action,
5096                                    ModestWindow *window)
5097 {
5098         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
5099                 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
5100         } else {
5101                 /* not supported window for this action */
5102                 g_return_if_reached ();
5103         }
5104 }
5105
5106 void
5107 modest_ui_actions_save_attachments (GtkAction *action,
5108                                     ModestWindow *window)
5109 {
5110         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
5111                 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
5112         } else {
5113                 /* not supported window for this action */
5114                 g_return_if_reached ();
5115         }
5116 }
5117
5118 void
5119 modest_ui_actions_remove_attachments (GtkAction *action,
5120                                       ModestWindow *window)
5121 {
5122         if (MODEST_IS_MAIN_WINDOW (window)) {
5123                 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
5124         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
5125                 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
5126         } else {
5127                 /* not supported window for this action */
5128                 g_return_if_reached ();
5129         }
5130 }
5131
5132 void
5133 modest_ui_actions_on_settings (GtkAction *action,
5134                                ModestWindow *win)
5135 {
5136         GtkWidget *dialog;
5137
5138         dialog = modest_platform_get_global_settings_dialog ();
5139         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
5140         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
5141         gtk_widget_show_all (dialog);
5142
5143         gtk_dialog_run (GTK_DIALOG (dialog));
5144
5145         gtk_widget_destroy (dialog);
5146 }
5147
5148 void
5149 modest_ui_actions_on_help (GtkAction *action,
5150                            GtkWindow *win)
5151 {
5152         const gchar *help_id;
5153
5154         g_return_if_fail (action);
5155         g_return_if_fail (win && GTK_IS_WINDOW(win));
5156
5157         help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
5158
5159         if (help_id)
5160                 modest_platform_show_help (GTK_WINDOW (win), help_id);
5161         else
5162                 g_warning ("%s: no help for window %p", __FUNCTION__, win);
5163 }
5164
5165 static void
5166 retrieve_msg_contents_performer (gboolean canceled,
5167                                  GError *err,
5168                                  GtkWindow *parent_window,
5169                                  TnyAccount *account,
5170                                  gpointer user_data)
5171 {
5172         ModestMailOperation *mail_op;
5173         TnyList *headers = TNY_LIST (user_data);
5174
5175         if (err || canceled) {
5176                 goto out;
5177         }
5178
5179         /* Create mail operation */
5180         mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
5181                                                                  modest_ui_actions_get_msgs_full_error_handler,
5182                                                                  NULL, NULL);
5183         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
5184         modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
5185
5186         /* Frees */
5187         g_object_unref (mail_op);
5188  out:
5189         g_object_unref (headers);
5190         g_object_unref (account);
5191 }
5192
5193 void
5194 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
5195                                             ModestWindow *window)
5196 {
5197         TnyList *headers = NULL;
5198         TnyAccount *account = NULL;
5199         TnyIterator *iter = NULL;
5200         TnyHeader *header = NULL;
5201         TnyFolder *folder = NULL;
5202
5203         /* Get headers */
5204         headers = get_selected_headers (window);
5205         if (!headers)
5206                 return;
5207
5208         /* Pick the account */
5209         iter = tny_list_create_iterator (headers);
5210         header = TNY_HEADER (tny_iterator_get_current (iter));
5211         folder = tny_header_get_folder (header);
5212         account = tny_folder_get_account (folder);
5213         g_object_unref (folder);
5214         g_object_unref (header);
5215         g_object_unref (iter);
5216
5217         /* Connect and perform the message retrieval */
5218         modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
5219                                              g_object_ref (account),
5220                                              retrieve_msg_contents_performer,
5221                                              g_object_ref (headers));
5222
5223         /* Frees */
5224         g_object_unref (account);
5225         g_object_unref (headers);
5226 }
5227
5228 void
5229 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
5230 {
5231         g_return_if_fail (MODEST_IS_WINDOW (window));
5232
5233         /* Update dimmed */
5234         modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_TOOLBAR);
5235 }
5236
5237 void
5238 modest_ui_actions_check_menu_dimming_rules (ModestWindow *window)
5239 {
5240         g_return_if_fail (MODEST_IS_WINDOW (window));
5241
5242         /* Update dimmed */
5243         modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_MENU);
5244 }
5245
5246 void
5247 modest_ui_actions_on_email_menu_activated (GtkAction *action,
5248                                           ModestWindow *window)
5249 {
5250         g_return_if_fail (MODEST_IS_WINDOW (window));
5251
5252         /* Update dimmed */
5253         modest_ui_actions_check_menu_dimming_rules (window);
5254 }
5255
5256 void
5257 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
5258                                           ModestWindow *window)
5259 {
5260         g_return_if_fail (MODEST_IS_WINDOW (window));
5261
5262         /* Update dimmed */
5263         modest_ui_actions_check_menu_dimming_rules (window);
5264 }
5265
5266 void
5267 modest_ui_actions_on_view_menu_activated (GtkAction *action,
5268                                           ModestWindow *window)
5269 {
5270         g_return_if_fail (MODEST_IS_WINDOW (window));
5271
5272         /* Update dimmed */
5273         modest_ui_actions_check_menu_dimming_rules (window);
5274 }
5275
5276 void
5277 modest_ui_actions_on_format_menu_activated (GtkAction *action,
5278                                             ModestWindow *window)
5279 {
5280         g_return_if_fail (MODEST_IS_WINDOW (window));
5281
5282         /* Update dimmed */
5283         modest_ui_actions_check_menu_dimming_rules (window);
5284 }
5285
5286 void
5287 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
5288                                           ModestWindow *window)
5289 {
5290         g_return_if_fail (MODEST_IS_WINDOW (window));
5291
5292         /* Update dimmed */
5293         modest_ui_actions_check_menu_dimming_rules (window);
5294 }
5295
5296 void
5297 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
5298                                           ModestWindow *window)
5299 {
5300         g_return_if_fail (MODEST_IS_WINDOW (window));
5301
5302         /* Update dimmed */
5303         modest_ui_actions_check_menu_dimming_rules (window);
5304 }
5305
5306 void
5307 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
5308                                                  ModestWindow *window)
5309 {
5310         g_return_if_fail (MODEST_IS_WINDOW (window));
5311
5312         /* Update dimmed */
5313         modest_ui_actions_check_menu_dimming_rules (window);
5314 }
5315
5316 void
5317 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
5318                                                      ModestWindow *window)
5319 {
5320         g_return_if_fail (MODEST_IS_WINDOW (window));
5321
5322         /* Update dimmed */
5323         modest_ui_actions_check_menu_dimming_rules (window);
5324 }
5325
5326 void
5327 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
5328                                                      ModestWindow *window)
5329 {
5330         g_return_if_fail (MODEST_IS_WINDOW (window));
5331
5332         /* Update dimmed */
5333         modest_ui_actions_check_menu_dimming_rules (window);
5334 }
5335
5336 void
5337 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
5338 {
5339         g_return_if_fail (MODEST_IS_WINDOW (window));
5340
5341         modest_platform_show_search_messages (GTK_WINDOW (window));
5342 }
5343
5344 void
5345 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
5346 {
5347         g_return_if_fail (MODEST_IS_WINDOW (win));
5348         modest_platform_show_addressbook (GTK_WINDOW (win));
5349 }
5350
5351
5352 void
5353 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
5354                                           ModestWindow *window)
5355 {
5356         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
5357
5358         modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
5359 }
5360
5361 static void
5362 on_send_receive_finished (ModestMailOperation  *mail_op,
5363                            gpointer user_data)
5364 {
5365         GtkWidget *header_view, *folder_view;
5366         TnyFolderStore *folder_store;
5367         ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
5368
5369         /* Set send/receive operation finished */
5370         modest_main_window_notify_send_receive_completed (main_win);
5371
5372         /* Don't refresh the current folder if there were any errors */
5373         if (modest_mail_operation_get_status (mail_op) !=
5374             MODEST_MAIL_OPERATION_STATUS_SUCCESS)
5375                 return;
5376
5377         /* Refresh the current folder if we're viewing a window. We do
5378            this because the user won't be able to see the new mails in
5379            the selected folder after a Send&Receive because it only
5380            performs a poke_status, i.e, only the number of read/unread
5381            messages is updated, but the new headers are not
5382            downloaded */
5383         folder_view = modest_main_window_get_child_widget (main_win,
5384                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5385         if (!folder_view)
5386                 return;
5387
5388         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5389
5390         /* Do not need to refresh INBOX again because the
5391            update_account does it always automatically */
5392         if (folder_store && TNY_IS_FOLDER (folder_store) &&
5393             tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
5394                 ModestMailOperation *refresh_op;
5395
5396                 header_view = modest_main_window_get_child_widget (main_win,
5397                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5398
5399                 /* We do not need to set the contents style
5400                    because it hasn't changed. We also do not
5401                    need to save the widget status. Just force
5402                    a refresh */
5403                 refresh_op = modest_mail_operation_new (G_OBJECT (main_win));
5404                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), refresh_op);
5405                 modest_mail_operation_refresh_folder (refresh_op, TNY_FOLDER (folder_store),
5406                                                       folder_refreshed_cb, main_win);
5407                 g_object_unref (refresh_op);
5408         }
5409
5410         if (folder_store)
5411                 g_object_unref (folder_store);
5412 }
5413
5414
5415 void
5416 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
5417                                                 TnyHeader *header,
5418                                                 TnyMsg *msg,
5419                                                 GError *err,
5420                                                 gpointer user_data)
5421 {
5422         const gchar* server_name = NULL;
5423         TnyTransportAccount *server_account;
5424         gchar *message = NULL;
5425
5426         /* Don't show anything if the user cancelled something */
5427         if (err->code == TNY_SYSTEM_ERROR_CANCEL)
5428                 return;
5429
5430         /* Get the server name: */
5431         server_account =
5432                 TNY_TRANSPORT_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self)));
5433         if (server_account) {
5434                 server_name = tny_account_get_hostname (TNY_ACCOUNT (server_account));
5435
5436                 g_object_unref (server_account);
5437                 server_account = NULL;
5438         }
5439
5440         g_return_if_fail (server_name);
5441
5442         /* Show the appropriate message text for the GError: */
5443         switch (err->code) {
5444         case TNY_SERVICE_ERROR_CONNECT:
5445                 message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
5446                 break;
5447         case TNY_SERVICE_ERROR_AUTHENTICATE:
5448                 message = g_strdup_printf (_("emev_ni_ui_smtp_authentication_fail_error"), server_name);
5449                 break;
5450         case TNY_SERVICE_ERROR_SEND:
5451                 message = g_strdup (_("emev_ib_ui_smtp_send_error"));
5452                 break;
5453         case TNY_SERVICE_ERROR_UNAVAILABLE:
5454                 message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
5455                 break;
5456         default:
5457                 g_warning ("%s: unexpected ERROR %d",
5458                            __FUNCTION__, err->code);
5459                 message = g_strdup (_("emev_ib_ui_smtp_send_error"));
5460                 break;
5461         }
5462
5463         /* TODO if the username or the password where not defined we
5464            should show the Accounts Settings dialog or the Connection
5465            specific SMTP server window */
5466
5467         modest_platform_run_information_dialog (NULL, message);
5468         g_free (message);
5469 }
5470
5471 void
5472 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
5473                                                 gchar *msg_id,
5474                                                 guint status,
5475                                                 gpointer user_data)
5476 {
5477         ModestMainWindow *main_window = NULL;
5478         ModestWindowMgr *mgr = NULL;
5479         GtkWidget *folder_view = NULL, *header_view = NULL;
5480         TnyFolderStore *selected_folder = NULL;
5481         TnyFolderType folder_type;
5482
5483         mgr = modest_runtime_get_window_mgr ();
5484         main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (mgr,
5485                                                                              FALSE));/* don't create */
5486         if (!main_window)
5487                 return;
5488
5489         /* Check if selected folder is OUTBOX */
5490         folder_view = modest_main_window_get_child_widget (main_window,
5491                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5492         header_view = modest_main_window_get_child_widget (main_window,
5493                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5494
5495         selected_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5496         if (!TNY_IS_FOLDER (selected_folder))
5497                 goto frees;
5498
5499         /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
5500 #if GTK_CHECK_VERSION(2, 8, 0)
5501         folder_type = modest_tny_folder_guess_folder_type (TNY_FOLDER (selected_folder));
5502         if (folder_type ==  TNY_FOLDER_TYPE_OUTBOX) {
5503                 GtkTreeViewColumn *tree_column;
5504
5505                 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
5506                                                         TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
5507                 gtk_tree_view_column_queue_resize (tree_column);
5508         }
5509 #else
5510         gtk_widget_queue_draw (header_view);
5511 #endif
5512
5513         /* Rerun dimming rules, because the message could become deletable for example */
5514         modest_window_check_dimming_rules_group (MODEST_WINDOW (main_window),
5515                                                  MODEST_DIMMING_RULES_TOOLBAR);
5516
5517         /* Free */
5518  frees:
5519         if (selected_folder != NULL)
5520                 g_object_unref (selected_folder);
5521 }
5522
5523 void
5524 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
5525                                                TnyAccount *account)
5526 {
5527         ModestTransportStoreProtocol proto;
5528         const gchar *proto_name;
5529         gchar *error_note = NULL;
5530
5531         proto_name = tny_account_get_proto (account);
5532         proto = modest_protocol_info_get_transport_store_protocol (proto_name);
5533
5534         switch (proto) {
5535         case MODEST_PROTOCOL_STORE_POP:
5536                 error_note = g_strdup_printf (_("emev_ni_ui_pop3_msg_connect_error"),
5537                                               tny_account_get_hostname (account));
5538                 break;
5539         case MODEST_PROTOCOL_STORE_IMAP:
5540                 error_note = g_strdup_printf (_("emev_ni_ui_imap_connect_server_error"),
5541                                               tny_account_get_hostname (account));
5542                 break;
5543         case MODEST_PROTOCOL_STORE_MAILDIR:
5544         case MODEST_PROTOCOL_STORE_MBOX:
5545                 error_note = g_strdup (_("emev_nc_mailbox_notavailable"));
5546                 break;
5547         default:
5548                 g_warning ("%s: This should not be reached", __FUNCTION__);
5549         }
5550
5551         if (error_note) {
5552                 modest_platform_run_information_dialog (parent_window, error_note);
5553                 g_free (error_note);
5554         }
5555 }
5556
5557 gchar *
5558 modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
5559 {
5560         gchar *msg = NULL;
5561         TnyFolderStore *folder = NULL;
5562         TnyAccount *account = NULL;
5563         ModestTransportStoreProtocol proto;
5564         TnyHeader *header = NULL;
5565
5566         if (MODEST_IS_MAIN_WINDOW (win)) {
5567                 GtkWidget *header_view;
5568                 TnyList* headers = NULL;
5569                 TnyIterator *iter;
5570                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
5571                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5572                 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
5573                 if (!headers || tny_list_get_length (headers) == 0) {
5574                         if (headers)
5575                                 g_object_unref (headers);
5576                         return NULL;
5577                 }
5578                 iter = tny_list_create_iterator (headers);
5579                 header = TNY_HEADER (tny_iterator_get_current (iter));
5580                 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
5581                 g_object_unref (iter);
5582                 g_object_unref (headers);
5583         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
5584                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
5585                 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
5586         }
5587
5588         /* Get the account type */
5589         account = tny_folder_get_account (TNY_FOLDER (folder));
5590         proto = modest_protocol_info_get_transport_store_protocol (tny_account_get_proto (account));
5591         if (proto == MODEST_PROTOCOL_STORE_POP) {
5592                 msg = g_strdup (_("emev_ni_ui_pop3_msg_recv_error"));
5593         } else if (proto == MODEST_PROTOCOL_STORE_IMAP) {
5594                 msg = g_strdup_printf (_("emev_ni_ui_imap_message_not_available_in_server"),
5595                                        tny_header_get_subject (header));
5596         } else {
5597                 msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
5598         }
5599
5600         /* Frees */
5601         g_object_unref (account);
5602         g_object_unref (folder);
5603         g_object_unref (header);
5604
5605         return msg;
5606 }