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