git.maemo.org Git - modest/blob - src/modest-ui-actions.c

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