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
  48 #ifdef MODEST_PLATFORM_MAEMO
  49 #include "maemo/modest-osso-state-saving.h"
  50 #endif /* MODEST_PLATFORM_MAEMO */
  51
  52 #include "widgets/modest-ui-constants.h"
  53 #include <widgets/modest-main-window.h>
  54 #include <widgets/modest-msg-view-window.h>
  55 #include <widgets/modest-account-view-window.h>
  56 #include <widgets/modest-details-dialog.h>
  57 #include <widgets/modest-attachments-view.h>
  58 #include "widgets/modest-folder-view.h"
  59 #include "widgets/modest-global-settings-dialog.h"
  60 #include "modest-connection-specific-smtp-window.h"
  61 #include "modest-account-mgr-helpers.h"
  62 #include "modest-mail-operation.h"
  63 #include "modest-text-utils.h"
  64
  65 #ifdef MODEST_HAVE_EASYSETUP
  66 #include "easysetup/modest-easysetup-wizard.h"
  67 #endif /* MODEST_HAVE_EASYSETUP */
  68
  69 #include <modest-widget-memory.h>
  70 #include <tny-error.h>
  71 #include <tny-simple-list.h>
  72 #include <tny-msg-view.h>
  73 #include <tny-device.h>
  74 #include <tny-merge-folder.h>
  75
  76 #include <gtkhtml/gtkhtml.h>
  77
  78 typedef struct _GetMsgAsyncHelper {
  79         ModestWindow *window;
  80         ModestMailOperation *mail_op;
  81         TnyIterator *iter;
  82         guint num_ops;
  83         GFunc func;
  84         gpointer user_data;
  85 } GetMsgAsyncHelper;
  86
  87 typedef enum _ReplyForwardAction {
  88         ACTION_REPLY,
  89         ACTION_REPLY_TO_ALL,
  90         ACTION_FORWARD
  91 } ReplyForwardAction;
  92
  93 typedef struct _ReplyForwardHelper {
  94         guint reply_forward_type;
  95         ReplyForwardAction action;
  96         gchar *account_name;
  97         GtkWidget *parent_window;
  98 } ReplyForwardHelper;
  99
 100
 101 /*
 102  * The do_headers_action uses this kind of functions to perform some
 103  * action to each member of a list of headers
 104  */
 105 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
 106
 107 static void
 108 do_headers_action (ModestWindow *win,
 109                    HeadersFunc func,
 110                    gpointer user_data);
 111
 112
 113 static void     open_msg_cb            (ModestMailOperation *mail_op,
 114                                         TnyHeader *header,
 115                                         TnyMsg *msg,
 116                                         gpointer user_data);
 117
 118 static void     reply_forward_cb       (ModestMailOperation *mail_op,
 119                                         TnyHeader *header,
 120                                         TnyMsg *msg,
 121                                         gpointer user_data);
 122
 123 static void     reply_forward          (ReplyForwardAction action, ModestWindow *win);
 124
 125
 126 static void     _on_send_receive_progress_changed (ModestMailOperation  *mail_op,
 127                                                    ModestMailOperationState *state,
 128                                                    gpointer user_data);
 129
 130
 131
 132 static void
 133 run_account_setup_wizard (ModestWindow *win)
 134 {
 135         ModestEasysetupWizardDialog *wizard;
 136
 137         g_return_if_fail (MODEST_IS_WINDOW(win));
 138
 139         wizard = modest_easysetup_wizard_dialog_new ();
 140         gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
 141         gtk_dialog_run (GTK_DIALOG (wizard));
 142         gtk_widget_destroy (GTK_WIDGET (wizard));
 143 }
 144
 145
 146 void
 147 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
 148 {
 149         GtkWidget *about;
 150         const gchar *authors[] = {
 151                 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
 152                 NULL
 153         };
 154         about = gtk_about_dialog_new ();
 155         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
 156         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
 157         gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
 158                                         _("Copyright (c) 2006, Nokia Corporation\n"
 159                                           "All rights reserved."));
 160         gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
 161                                        _("a modest e-mail client\n\n"
 162                                          "design and implementation: Dirk-Jan C. Binnema\n"
 163                                          "contributions from the fine people at KC and Ig\n"
 164                                          "uses the tinymail email framework written by Philip van Hoof"));
 165         gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
 166         gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
 167
 168         gtk_dialog_run (GTK_DIALOG (about));
 169         gtk_widget_destroy(about);
 170 }
 171
 172 /*
 173  * Gets the list of currently selected messages. If the win is the
 174  * main window, then it returns a newly allocated list of the headers
 175  * selected in the header view. If win is the msg view window, then
 176  * the value returned is a list with just a single header.
 177  *
 178  * The caller of this funcion must free the list.
 179  */
 180 static TnyList *
 181 get_selected_headers (ModestWindow *win)
 182 {
 183         if (MODEST_IS_MAIN_WINDOW(win)) {
 184                 GtkWidget *header_view;
 185
 186                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 187                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 188                 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 189
 190         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 191                 /* for MsgViewWindows, we simply return a list with one element */
 192                 TnyHeader *header;
 193                 TnyList *list = NULL;
 194
 195                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
 196                 if (header != NULL) {
 197                         list = tny_simple_list_new ();
 198                         tny_list_prepend (list, G_OBJECT(header));
 199                         g_object_unref (G_OBJECT(header));
 200                 }
 201
 202                 return list;
 203
 204         } else
 205                 return NULL;
 206 }
 207
 208 static void
 209 headers_action_mark_as_read (TnyHeader *header,
 210                              ModestWindow *win,
 211                              gpointer user_data)
 212 {
 213         TnyHeaderFlags flags;
 214
 215         g_return_if_fail (TNY_IS_HEADER(header));
 216
 217         flags = tny_header_get_flags (header);
 218         if (flags & TNY_HEADER_FLAG_SEEN) return;
 219         tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
 220 }
 221
 222 static void
 223 headers_action_mark_as_unread (TnyHeader *header,
 224                                ModestWindow *win,
 225                                gpointer user_data)
 226 {
 227         TnyHeaderFlags flags;
 228
 229         g_return_if_fail (TNY_IS_HEADER(header));
 230
 231         flags = tny_header_get_flags (header);
 232         if (flags & TNY_HEADER_FLAG_SEEN)  {
 233                 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
 234         }
 235 }
 236
 237
 238 static void
 239 headers_action_delete (TnyHeader *header,
 240                        ModestWindow *win,
 241                        gpointer user_data)
 242 {
 243         ModestMailOperation *mail_op = NULL;
 244
 245         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
 246         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 247                                          mail_op);
 248
 249         /* Always delete. TODO: Move to trash still not supported */
 250         modest_mail_operation_remove_msg (mail_op, header, FALSE);
 251         g_object_unref (G_OBJECT (mail_op));
 252 }
 253
 254 void
 255 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
 256 {
 257         TnyList *header_list = NULL;
 258         TnyIterator *iter = NULL;
 259         TnyHeader *header = NULL;
 260         gchar *message = NULL;
 261         gchar *desc = NULL;
 262         gint response;
 263         gboolean found;
 264         ModestWindowMgr *mgr;
 265         GtkWidget *header_view;
 266
 267         g_return_if_fail (MODEST_IS_WINDOW(win));
 268
 269         /* Check first if the header view has the focus */
 270         if (MODEST_IS_MAIN_WINDOW (win)) {
 271                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 272                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 273                 if (!gtk_widget_is_focus (header_view))
 274                         return;
 275         }
 276
 277         header_list = get_selected_headers (win);
 278         if (!header_list) return;
 279
 280         /* Check if any of the headers is already opened */
 281         iter = tny_list_create_iterator (header_list);
 282         found = FALSE;
 283         mgr = modest_runtime_get_window_mgr ();
 284         while (!tny_iterator_is_done (iter) && !found) {
 285                 header = TNY_HEADER (tny_iterator_get_current (iter));
 286                 if (modest_window_mgr_find_window_by_header (mgr, header))
 287                         found = TRUE;
 288                 g_object_unref (header);
 289                 tny_iterator_next (iter);
 290         }
 291         g_object_unref (iter);
 292
 293         if (found) {
 294                 gchar *num, *msg;
 295
 296                 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
 297                 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
 298
 299                 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
 300
 301                 g_free (msg);
 302                 g_free (num);
 303                 g_object_unref (header_list);
 304                 return;
 305         }
 306
 307         /* Select message */
 308         if (tny_list_get_length(header_list) == 1) {
 309                 iter = tny_list_create_iterator (header_list);
 310                 header = TNY_HEADER (tny_iterator_get_current (iter));
 311                 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
 312                 g_object_unref (header);
 313                 g_object_unref (iter);
 314         }
 315         message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
 316                                            tny_list_get_length(header_list)), desc);
 317
 318         /* Confirmation dialog */
 319         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
 320                                                             message);
 321
 322
 323         if (response == GTK_RESPONSE_OK) {
 324                 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
 325                         gboolean ret_value;
 326                         g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 327                         return;
 328                 }
 329
 330                 /* Remove each header */
 331                 do_headers_action (win, headers_action_delete, NULL);
 332
 333                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 334                         gtk_widget_destroy (GTK_WIDGET(win));
 335                 }
 336         }
 337
 338         /* free */
 339         g_free(message);
 340         g_free(desc);
 341         g_object_unref (header_list);
 342 }
 343
 344
 345 void
 346 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
 347 {
 348 #ifdef MODEST_PLATFORM_MAEMO
 349         modest_osso_save_state();
 350 #endif /* MODEST_PLATFORM_MAEMO */
 351
 352         /* FIXME: we need to cancel all actions/threads here,
 353          so we really quit */
 354
 355         gtk_main_quit ();
 356 }
 357
 358 void
 359 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
 360 {
 361         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 362                 gtk_widget_destroy (GTK_WIDGET (win));
 363         } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
 364                 gboolean ret_value;
 365                 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 366         } else if (MODEST_IS_WINDOW (win)) {
 367                 gtk_widget_destroy (GTK_WIDGET (win));
 368         } else {
 369                 g_return_if_reached ();
 370         }
 371 }
 372
 373 void
 374 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
 375 {
 376         GtkClipboard *clipboard = NULL;
 377         gchar *selection = NULL;
 378
 379         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 380         selection = gtk_clipboard_wait_for_text (clipboard);
 381
 382         /* Question: why is the clipboard being used here?
 383          * It doesn't really make a lot of sense. */
 384
 385         if (selection)
 386         {
 387                 modest_address_book_add_address (selection);
 388                 g_free (selection);
 389         }
 390 }
 391
 392 void
 393 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
 394 {
 395         /* This is currently only implemented for Maemo */
 396 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 397         if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
 398                 run_account_setup_wizard (win);
 399                 return;
 400         } else  {
 401                 /* Show the list of accounts: */
 402                 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
 403                 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
 404                 gtk_dialog_run (account_win);
 405                 gtk_widget_destroy (GTK_WIDGET(account_win));
 406         }
 407 #else
 408         GtkWidget *dialog, *label;
 409
 410         /* Create the widgets */
 411
 412         dialog = gtk_dialog_new_with_buttons ("Message",
 413                                               GTK_WINDOW(win),
 414                                               GTK_DIALOG_DESTROY_WITH_PARENT,
 415                                               GTK_STOCK_OK,
 416                                               GTK_RESPONSE_NONE,
 417                                               NULL);
 418         label = gtk_label_new ("Hello World!");
 419
 420         /* Ensure that the dialog box is destroyed when the user responds. */
 421
 422         g_signal_connect_swapped (dialog, "response",
 423                                   G_CALLBACK (gtk_widget_destroy),
 424                                   dialog);
 425
 426         /* Add the label, and show everything we've added to the dialog. */
 427
 428         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
 429                            label);
 430         gtk_widget_show_all (dialog);
 431 #endif /* MODEST_PLATFORM_MAEMO */
 432 }
 433
 434 static void
 435 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
 436 {
 437         ModestWindow *main_window = MODEST_WINDOW (user_data);
 438
 439         /* Save any changes. */
 440         modest_connection_specific_smtp_window_save_server_accounts (
 441                         MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
 442                         modest_window_get_active_account (main_window));
 443         gtk_widget_destroy (GTK_WIDGET (window));
 444 }
 445
 446
 447
 448 void
 449 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
 450 {
 451         /* This is currently only implemented for Maemo,
 452          * because it requires an API (libconic) to detect different connection
 453          * possiblities.
 454          */
 455 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 456
 457         /* Create the window if necessary: */
 458         const gchar *active_account_name = modest_window_get_active_account (win);
 459
 460         /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
 461          * or show the default account?
 462          * If we show the default account then the account name should be shown in
 463          * the window when we show it. */
 464         if (!active_account_name) {
 465                 g_warning ("%s: No account is active.", __FUNCTION__);
 466                 return;
 467         }
 468
 469         GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
 470         modest_connection_specific_smtp_window_fill_with_connections (
 471                 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
 472                 modest_runtime_get_account_mgr(),
 473                 active_account_name);
 474
 475         /* Show the window: */
 476         gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
 477         gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
 478         gtk_widget_show (specific_window);
 479
 480         /* Save changes when the window is hidden: */
 481         g_signal_connect (specific_window, "hide",
 482                 G_CALLBACK (on_smtp_servers_window_hide), win);
 483 #endif /* MODEST_PLATFORM_MAEMO */
 484 }
 485
 486 void
 487 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
 488 {
 489         ModestWindow *msg_win = NULL;
 490         TnyMsg *msg = NULL;
 491         TnyFolder *folder = NULL;
 492         gchar *account_name = NULL;
 493         gchar *from_str = NULL;
 494 /*      GError *err = NULL; */
 495         TnyAccount *account = NULL;
 496         ModestWindowMgr *mgr;
 497         gchar *signature = NULL, *blank_and_signature = NULL;
 498
 499         /* if there are no accounts yet, just show the wizard */
 500         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
 501                         run_account_setup_wizard (win);
 502                         return;
 503         }
 504
 505         account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
 506         if (!account_name)
 507                 account_name = g_strdup (modest_window_get_active_account (win));
 508         if (!account_name) {
 509                 g_printerr ("modest: no account found\n");
 510                 goto cleanup;
 511         }
 512
 513         account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
 514                                                                        account_name,
 515                                                                        TNY_ACCOUNT_TYPE_STORE);
 516         if (!account) {
 517                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
 518                 goto cleanup;
 519         }
 520
 521         from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
 522         if (!from_str) {
 523                 g_printerr ("modest: failed get from string for '%s'\n", account_name);
 524                 goto cleanup;
 525         }
 526
 527         if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
 528                                          MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
 529                 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
 530                                                            MODEST_ACCOUNT_SIGNATURE, FALSE);
 531                 blank_and_signature = g_strconcat ("\n", signature, NULL);
 532                 g_free (signature);
 533         } else {
 534                 blank_and_signature = g_strdup ("");
 535         }
 536
 537         msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
 538         if (!msg) {
 539                 g_printerr ("modest: failed to create new msg\n");
 540                 goto cleanup;
 541         }
 542
 543         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 544         if (!folder) {
 545                 g_printerr ("modest: failed to find Drafts folder\n");
 546                 goto cleanup;
 547         }
 548
 549
 550         /* Create and register edit window */
 551         /* This is destroyed by TOOD. */
 552         msg_win = modest_msg_edit_window_new (msg, account_name);
 553         mgr = modest_runtime_get_window_mgr ();
 554         modest_window_mgr_register_window (mgr, msg_win);
 555
 556         if (win)
 557                 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
 558                                               GTK_WINDOW (win));
 559         gtk_widget_show_all (GTK_WIDGET (msg_win));
 560
 561 cleanup:
 562         g_free (account_name);
 563         g_free (from_str);
 564         g_free (blank_and_signature);
 565         if (msg_win)
 566                 g_object_unref (msg_win);
 567         if (account)
 568                 g_object_unref (G_OBJECT(account));
 569         if (msg)
 570                 g_object_unref (G_OBJECT(msg));
 571         if (folder)
 572                 g_object_unref (G_OBJECT(folder));
 573 }
 574
 575 static void
 576 open_msg_cb (ModestMailOperation *mail_op,
 577              TnyHeader *header,
 578              TnyMsg *msg,
 579              gpointer user_data)
 580 {
 581         ModestWindowMgr *mgr = NULL;
 582         ModestWindow *parent_win = NULL;
 583         ModestWindow *win = NULL;
 584         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
 585         gchar *account = NULL;
 586         TnyFolder *folder;
 587
 588         /* TODO: Show an error? (review the specs) */
 589         if (!msg)
 590                 return;
 591
 592         parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
 593         folder = tny_header_get_folder (header);
 594
 595         /* Mark header as read */
 596         headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
 597
 598         /* Get account */
 599         account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 600         if (!account)
 601                 account =  g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
 602
 603         /* Gets folder type (OUTBOX headers will be opened in edit window */
 604         if (modest_tny_folder_is_local_folder (folder))
 605                 folder_type = modest_tny_folder_get_local_folder_type (folder);
 606
 607         /* If the header is in the drafts folder then open the editor,
 608            else the message view window */
 609         if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
 610                 /* we cannot edit without a valid account... */
 611                 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
 612                         run_account_setup_wizard(parent_win);
 613                         goto cleanup;
 614                 }
 615                 win = modest_msg_edit_window_new (msg, account);
 616         } else {
 617                 gchar *uid = modest_tny_folder_get_header_unique_id (header);
 618
 619                 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
 620                         GtkWidget *header_view;
 621                         GtkTreeSelection *sel;
 622                         GList *sel_list = NULL;
 623                         GtkTreeModel *model;
 624
 625                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
 626                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 627
 628                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 629                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 630
 631                         if (sel_list != NULL) {
 632                                 GtkTreeRowReference *row_reference;
 633
 634                                 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
 635                                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 636                                 g_list_free (sel_list);
 637
 638                                 win = modest_msg_view_window_new_with_header_model (msg,
 639                                                                                     account,
 640                                                                                     (const gchar*) uid,
 641                                                                                     model,
 642                                                                                     row_reference);
 643                                 gtk_tree_row_reference_free (row_reference);
 644                         } else {
 645                                 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
 646                         }
 647                 } else {
 648                         win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
 649                 }
 650                 g_free (uid);
 651         }
 652
 653         /* Register and show new window */
 654         if (win != NULL) {
 655                 mgr = modest_runtime_get_window_mgr ();
 656                 modest_window_mgr_register_window (mgr, win);
 657                 g_object_unref (win);
 658                 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
 659                 gtk_widget_show_all (GTK_WIDGET(win));
 660         }
 661
 662 cleanup:
 663         /* Free */
 664         g_free(account);
 665         g_object_unref (parent_win);
 666         g_object_unref (msg);
 667         g_object_unref (folder);
 668 }
 669
 670 /*
 671  * This function is the error handler of the
 672  * modest_mail_operation_get_msgs_full operation
 673  */
 674 static void
 675 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
 676                                                gpointer user_data)
 677 {
 678         const GError *error;
 679
 680         error = modest_mail_operation_get_error (mail_op);
 681         if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
 682                 GObject *win = modest_mail_operation_get_source (mail_op);
 683
 684                 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
 685                                                         error->message);
 686                 g_object_unref (win);
 687         }
 688 }
 689
 690 /*
 691  * This function is used by both modest_ui_actions_on_open and
 692  * modest_ui_actions_on_header_activated. This way we always do the
 693  * same when trying to open messages.
 694  */
 695 static void
 696 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
 697 {
 698         ModestWindowMgr *mgr = NULL;
 699         TnyIterator *iter = NULL;
 700         ModestMailOperation *mail_op1 = NULL;
 701         ModestMailOperation *mail_op2 = NULL;
 702         TnyList *not_opened_headers = NULL;
 703         TnyList *not_opened_cached_headers = NULL;
 704         TnyHeaderFlags flags;
 705
 706         /* Look if we already have a message view for each header. If
 707            true, then remove the header from the list of headers to
 708            open */
 709         mgr = modest_runtime_get_window_mgr ();
 710         iter = tny_list_create_iterator (headers);
 711         not_opened_headers = tny_simple_list_new ();
 712         not_opened_cached_headers = tny_simple_list_new ();
 713         while (!tny_iterator_is_done (iter)) {
 714                 ModestWindow *window;
 715                 TnyHeader *header;
 716
 717                 header = TNY_HEADER (tny_iterator_get_current (iter));
 718                 flags = tny_header_get_flags (header);
 719                 window = modest_window_mgr_find_window_by_header (mgr, header);
 720
 721                 /* Do not open again the message and present the
 722                    window to the user */
 723                 if (window)
 724                         gtk_window_present (GTK_WINDOW (window));
 725                 else if (!(flags & TNY_HEADER_FLAG_CACHED))
 726                         tny_list_append (not_opened_headers, G_OBJECT (header));
 727                 /* Check if msg has already been retreived */
 728                 else
 729                         tny_list_append (not_opened_cached_headers, G_OBJECT (header));
 730
 731                 g_object_unref (header);
 732                 tny_iterator_next (iter);
 733         }
 734
 735         /* Open each uncached message */
 736         if (tny_list_get_length (not_opened_headers) > 0) {
 737                 mail_op1 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
 738                                                                          G_OBJECT (win),
 739                                                                          modest_ui_actions_get_msgs_full_error_handler,
 740                                                                          NULL);
 741                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op1);
 742                 if (tny_list_get_length (not_opened_headers) > 1) {
 743                         modest_mail_operation_get_msgs_full (mail_op1,
 744                                                              not_opened_headers,
 745                                                              open_msg_cb,
 746                                                              NULL,
 747                                                              NULL);
 748                 } else {
 749                         TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
 750                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
 751                         modest_mail_operation_get_msg (mail_op1, header, open_msg_cb, NULL);
 752                         g_object_unref (header);
 753                         g_object_unref (iter);
 754                 }
 755         }
 756
 757         /* Open each cached message */
 758         if (tny_list_get_length (not_opened_cached_headers) > 0) {
 759                 mail_op2 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_OPEN,
 760                                                                          G_OBJECT (win),
 761                                                                          modest_ui_actions_get_msgs_full_error_handler,
 762                                                                          NULL);
 763                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op2);
 764                 if (tny_list_get_length (not_opened_cached_headers) > 1) {
 765                         modest_mail_operation_get_msgs_full (mail_op2,
 766                                                              not_opened_headers,
 767                                                              open_msg_cb,
 768                                                              NULL,
 769                                                              NULL);
 770                 } else {
 771                         TnyIterator *iter = tny_list_create_iterator (not_opened_cached_headers);
 772                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
 773                         modest_mail_operation_get_msg (mail_op2, header, open_msg_cb, NULL);
 774                         g_object_unref (header);
 775                         g_object_unref (iter);
 776                 }
 777         }
 778
 779         /* Clean */
 780         if (not_opened_headers != NULL)
 781                 g_object_unref (not_opened_headers);
 782         if (not_opened_cached_headers != NULL)
 783                 g_object_unref (not_opened_cached_headers);
 784         if (iter != NULL)
 785                 g_object_unref (iter);
 786         if (mail_op1 != NULL)
 787                 g_object_unref (mail_op1);
 788         if (mail_op2 != NULL)
 789                 g_object_unref (mail_op2);
 790 }
 791
 792 void
 793 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
 794 {
 795         TnyList *headers;
 796
 797         /* Get headers */
 798         headers = get_selected_headers (win);
 799         if (!headers)
 800                 return;
 801
 802         /* Open them */
 803         _modest_ui_actions_open (headers, win);
 804
 805         g_object_unref(headers);
 806 }
 807
 808
 809 static void
 810 free_reply_forward_helper (gpointer data)
 811 {
 812         ReplyForwardHelper *helper;
 813
 814         helper = (ReplyForwardHelper *) data;
 815         g_free (helper->account_name);
 816         g_slice_free (ReplyForwardHelper, helper);
 817 }
 818
 819 static void
 820 reply_forward_cb (ModestMailOperation *mail_op,
 821                   TnyHeader *header,
 822                   TnyMsg *msg,
 823                   gpointer user_data)
 824 {
 825         TnyMsg *new_msg;
 826         ReplyForwardHelper *rf_helper;
 827         ModestWindow *msg_win = NULL;
 828         ModestEditType edit_type;
 829         gchar *from = NULL;
 830         TnyAccount *account = NULL;
 831         ModestWindowMgr *mgr = NULL;
 832         gchar *signature = NULL;
 833
 834         g_return_if_fail (user_data != NULL);
 835         rf_helper = (ReplyForwardHelper *) user_data;
 836
 837         from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
 838                                                    rf_helper->account_name);
 839         if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
 840                                          rf_helper->account_name,
 841                                          MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
 842                 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
 843                                                            rf_helper->account_name,
 844                                                            MODEST_ACCOUNT_SIGNATURE, FALSE);
 845         }
 846
 847         /* Create reply mail */
 848         switch (rf_helper->action) {
 849         case ACTION_REPLY:
 850                 new_msg =
 851                         modest_tny_msg_create_reply_msg (msg,  from, signature,
 852                                                          rf_helper->reply_forward_type,
 853                                                          MODEST_TNY_MSG_REPLY_MODE_SENDER);
 854                 break;
 855         case ACTION_REPLY_TO_ALL:
 856                 new_msg =
 857                         modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
 858                                                          MODEST_TNY_MSG_REPLY_MODE_ALL);
 859                 edit_type = MODEST_EDIT_TYPE_REPLY;
 860                 break;
 861         case ACTION_FORWARD:
 862                 new_msg =
 863                         modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
 864                 edit_type = MODEST_EDIT_TYPE_FORWARD;
 865                 break;
 866         default:
 867                 g_return_if_reached ();
 868                 return;
 869         }
 870
 871         g_free (signature);
 872
 873         if (!new_msg) {
 874                 g_printerr ("modest: failed to create message\n");
 875                 goto cleanup;
 876         }
 877
 878         account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
 879                                                                        rf_helper->account_name,
 880                                                                        TNY_ACCOUNT_TYPE_STORE);
 881         if (!account) {
 882                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
 883                 goto cleanup;
 884         }
 885
 886         /* Create and register the windows */
 887         msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
 888         mgr = modest_runtime_get_window_mgr ();
 889         modest_window_mgr_register_window (mgr, msg_win);
 890
 891         if (rf_helper->parent_window != NULL) {
 892                 gdouble parent_zoom;
 893
 894                 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
 895                 modest_window_set_zoom (msg_win, parent_zoom);
 896         }
 897
 898         /* Show edit window */
 899         gtk_widget_show_all (GTK_WIDGET (msg_win));
 900
 901 cleanup:
 902         if (msg_win)
 903                 g_object_unref (msg_win);
 904         if (new_msg)
 905                 g_object_unref (G_OBJECT (new_msg));
 906         if (account)
 907                 g_object_unref (G_OBJECT (account));
 908         g_object_unref (msg);
 909         g_object_unref (header);
 910 }
 911
 912 /*
 913  * Checks a list of headers. If any of them are not currently
 914  * downloaded (CACHED) then it asks the user for permission to
 915  * download them.
 916  *
 917  * Returns FALSE if the user does not want to download the
 918  * messages. Returns TRUE if the user allowed the download or if all
 919  * of them are currently downloaded
 920  */
 921 static gboolean
 922 download_uncached_messages (TnyList *header_list, GtkWindow *win)
 923 {
 924         TnyIterator *iter;
 925         gboolean retval;
 926         gint uncached_messages = 0;
 927
 928         iter = tny_list_create_iterator (header_list);
 929         while (!tny_iterator_is_done (iter)) {
 930                 TnyHeader *header;
 931                 TnyHeaderFlags flags;
 932
 933                 header = TNY_HEADER (tny_iterator_get_current (iter));
 934                 flags = tny_header_get_flags (header);
 935                 /* TODO: is this the right flag?, it seems that some
 936                    headers that have been previously downloaded do not
 937                    come with it */
 938                 if (! (flags & TNY_HEADER_FLAG_CACHED))
 939                         uncached_messages ++;
 940                 g_object_unref (header);
 941                 tny_iterator_next (iter);
 942         }
 943         g_object_unref (iter);
 944
 945         /* Ask for user permission to download the messages */
 946         retval = TRUE;
 947         if (uncached_messages > 0) {
 948                 GtkResponseType response;
 949                 response =
 950                         modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
 951                                                                  ngettext("mcen_nc_get_msg",
 952                                                                           "mcen_nc_get_msgs",
 953                                                                          uncached_messages));
 954                 if (response == GTK_RESPONSE_CANCEL)
 955                         retval = FALSE;
 956         }
 957         return retval;
 958 }
 959
 960
 961 /*
 962  * Common code for the reply and forward actions
 963  */
 964 static void
 965 reply_forward (ReplyForwardAction action, ModestWindow *win)
 966 {
 967         ModestMailOperation *mail_op = NULL;
 968         TnyList *header_list = NULL;
 969         ReplyForwardHelper *rf_helper = NULL;
 970         guint reply_forward_type;
 971         gboolean continue_download;
 972
 973         g_return_if_fail (MODEST_IS_WINDOW(win));
 974
 975         /* we need an account when editing */
 976         if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
 977                 run_account_setup_wizard (win);
 978                 return;
 979         }
 980
 981         header_list = get_selected_headers (win);
 982         if (!header_list)
 983                 return;
 984
 985         /* Check that the messages have been previously downloaded */
 986         continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
 987         if (!continue_download) {
 988                 g_object_unref (header_list);
 989                 return;
 990         }
 991
 992         reply_forward_type =
 993                 modest_conf_get_int (modest_runtime_get_conf (),
 994                                      (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
 995                                      NULL);
 996         /* We assume that we can only select messages of the
 997            same folder and that we reply all of them from the
 998            same account. In fact the interface currently only
 999            allows single selection */
1000
1001         /* Fill helpers */
1002         rf_helper = g_slice_new0 (ReplyForwardHelper);
1003         rf_helper->reply_forward_type = reply_forward_type;
1004         rf_helper->action = action;
1005         rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1006         if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1007                 rf_helper->parent_window = GTK_WIDGET (win);
1008         if (!rf_helper->account_name)
1009                 rf_helper->account_name =
1010                         modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1011
1012         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1013                 TnyMsg *msg;
1014                 TnyHeader *header;
1015                 /* Get header and message. Do not free them here, the
1016                    reply_forward_cb must do it */
1017                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1018                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1019                 if (!msg || !header) {
1020                         if (msg)
1021                                 g_object_unref (msg);
1022                         if (header)
1023                                 g_object_unref (header);
1024                         g_printerr ("modest: no message found\n");
1025                         return;
1026                 } else
1027                         reply_forward_cb (NULL, header, msg, rf_helper);
1028         } else {
1029                 /* Retrieve messages */
1030                 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1031                                                                          G_OBJECT(win),
1032                                                                          modest_ui_actions_get_msgs_full_error_handler,
1033                                                                          NULL);
1034                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1035                 modest_mail_operation_get_msgs_full (mail_op,
1036                                                      header_list,
1037                                                      reply_forward_cb,
1038                                                      rf_helper,
1039                                                      free_reply_forward_helper);
1040
1041                 /* Clean */
1042                 g_object_unref(mail_op);
1043         }
1044
1045         /* Free */
1046         g_object_unref (header_list);
1047 }
1048
1049 void
1050 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1051 {
1052         g_return_if_fail (MODEST_IS_WINDOW(win));
1053
1054         reply_forward (ACTION_REPLY, win);
1055 }
1056
1057 void
1058 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1059 {
1060         g_return_if_fail (MODEST_IS_WINDOW(win));
1061
1062         reply_forward (ACTION_FORWARD, win);
1063 }
1064
1065 void
1066 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1067 {
1068         g_return_if_fail (MODEST_IS_WINDOW(win));
1069
1070         reply_forward (ACTION_REPLY_TO_ALL, win);
1071 }
1072
1073 void
1074 modest_ui_actions_on_next (GtkAction *action,
1075                            ModestWindow *window)
1076 {
1077         if (MODEST_IS_MAIN_WINDOW (window)) {
1078                 GtkWidget *header_view;
1079
1080                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1081                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1082                 if (!header_view)
1083                         return;
1084
1085                 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1086         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1087                 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1088         } else {
1089                 g_return_if_reached ();
1090         }
1091 }
1092
1093 void
1094 modest_ui_actions_on_prev (GtkAction *action,
1095                            ModestWindow *window)
1096 {
1097         g_return_if_fail (MODEST_IS_WINDOW(window));
1098
1099         if (MODEST_IS_MAIN_WINDOW (window)) {
1100                 GtkWidget *header_view;
1101                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1102                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1103                 if (!header_view)
1104                         return;
1105
1106                 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1107         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1108                 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1109         } else {
1110                 g_return_if_reached ();
1111         }
1112 }
1113
1114 void
1115 modest_ui_actions_on_sort (GtkAction *action,
1116                            ModestWindow *window)
1117 {
1118         g_return_if_fail (MODEST_IS_WINDOW(window));
1119
1120         if (MODEST_IS_MAIN_WINDOW (window)) {
1121                 GtkWidget *header_view;
1122                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1123                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1124                 if (!header_view)
1125                         return;
1126
1127                 /* Show sorting dialog */
1128                 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1129         }
1130 }
1131
1132 static void
1133 new_messages_arrived (ModestMailOperation *self,
1134                       gint new_messages,
1135                       gpointer user_data)
1136 {
1137         if (new_messages == 0)
1138                 return;
1139
1140         modest_platform_on_new_msg ();
1141 }
1142
1143 /*
1144  * This function performs the send & receive required actions. The
1145  * window is used to create the mail operation. Typically it should
1146  * always be the main window, but we pass it as argument in order to
1147  * be more flexible.
1148  */
1149 void
1150 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1151 {
1152         gchar *acc_name = NULL;
1153         ModestMailOperation *mail_op;
1154
1155         /* If no account name was provided then get the current account, and if
1156            there is no current account then pick the default one: */
1157         if (!account_name) {
1158                 acc_name = g_strdup (modest_window_get_active_account(win));
1159                 if (!acc_name)
1160                         acc_name  = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1161                 if (!acc_name) {
1162                         g_printerr ("modest: cannot get default account\n");
1163                         return;
1164                 }
1165         } else {
1166                 acc_name = g_strdup (account_name);
1167         }
1168
1169         /* Set send/receive operation in progress */
1170         modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1171
1172         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
1173         g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1174                           G_CALLBACK (_on_send_receive_progress_changed),
1175                           win);
1176
1177         /* Send & receive. */
1178         /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1179         /* Receive and then send. The operation is tagged initially as
1180            a receive operation because the account update performs a
1181            receive and then a send. The operation changes its type
1182            internally, so the progress objects will receive the proper
1183            progress information */
1184         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1185         modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1186         g_object_unref (G_OBJECT (mail_op));
1187
1188         /* Free */
1189         g_free (acc_name);
1190 }
1191
1192 /*
1193  * Refreshes all accounts. This function will be used by automatic
1194  * updates
1195  */
1196 void
1197 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1198 {
1199         GSList *account_names, *iter;
1200
1201         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1202                                                           TRUE);
1203
1204         iter = account_names;
1205         while (iter) {
1206                 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1207                 iter = g_slist_next (iter);
1208         }
1209
1210         modest_account_mgr_free_account_names (account_names);
1211         account_names = NULL;
1212 }
1213
1214 /*
1215  * Handler of the click on Send&Receive button in the main toolbar
1216  */
1217 void
1218 modest_ui_actions_on_send_receive (GtkAction *action,  ModestWindow *win)
1219 {
1220         /* Check if accounts exist */
1221         gboolean accounts_exist =
1222                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1223
1224         /* If not, allow the user to create an account before trying to send/receive. */
1225         if (!accounts_exist)
1226                 modest_ui_actions_on_accounts (NULL, win);
1227
1228         /* Refresh the active account */
1229         modest_ui_actions_do_send_receive (NULL, win);
1230 }
1231
1232
1233 void
1234 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1235 {
1236         ModestConf *conf;
1237         GtkWidget *header_view;
1238
1239         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1240
1241         header_view = modest_main_window_get_child_widget (main_window,
1242                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1243         if (!header_view)
1244                 return;
1245
1246         conf = modest_runtime_get_conf ();
1247
1248         /* what is saved/restored is depending on the style; thus; we save with
1249          * old style, then update the style, and restore for this new style
1250          */
1251         modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1252
1253         if (modest_header_view_get_style
1254             (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1255                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1256                                               MODEST_HEADER_VIEW_STYLE_TWOLINES);
1257         else
1258                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1259                                               MODEST_HEADER_VIEW_STYLE_DETAILS);
1260
1261         modest_widget_memory_restore (conf, G_OBJECT(header_view),
1262                                       MODEST_CONF_HEADER_VIEW_KEY);
1263 }
1264
1265
1266 void
1267 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1268                                       TnyHeader *header,
1269                                       ModestMainWindow *main_window)
1270 {
1271         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1272         g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1273
1274         /* If no header has been selected then exit */
1275         if (!header)
1276                 return;
1277
1278         /* Update focus */
1279         if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1280             gtk_widget_grab_focus (GTK_WIDGET(header_view));
1281
1282         /* Update Main window title */
1283         if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1284                 const gchar *subject = tny_header_get_subject (header);
1285                 if (subject && strlen(subject) > 0)
1286                         gtk_window_set_title (GTK_WINDOW (main_window), subject);
1287                 else
1288                         gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1289         }
1290
1291         /* Update toolbar dimming state */
1292         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1293 }
1294
1295 void
1296 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1297                                        TnyHeader *header,
1298                                        ModestMainWindow *main_window)
1299 {
1300         TnyList *headers;
1301
1302         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1303
1304         if (!header)
1305                 return;
1306
1307         headers = tny_simple_list_new ();
1308         tny_list_prepend (headers, G_OBJECT (header));
1309
1310         _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1311
1312         g_object_unref (headers);
1313 }
1314
1315 static void
1316 set_active_account_from_tny_account (TnyAccount *account,
1317                                      ModestWindow *window)
1318 {
1319         const gchar *server_acc_name = tny_account_get_id (account);
1320
1321         /* We need the TnyAccount provided by the
1322            account store because that is the one that
1323            knows the name of the Modest account */
1324         TnyAccount *modest_server_account = modest_server_account =
1325                 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1326                                                              MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1327                                                              server_acc_name);
1328
1329         const gchar *modest_acc_name =
1330                 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1331         modest_window_set_active_account (window, modest_acc_name);
1332         g_object_unref (modest_server_account);
1333 }
1334
1335
1336 static void
1337 folder_refreshed_cb (const GObject *obj,
1338                      TnyFolder *folder,
1339                      gpointer user_data)
1340 {
1341         ModestMainWindow *win = NULL;
1342         GtkWidget *header_view;
1343
1344         g_return_if_fail (TNY_IS_FOLDER (folder));
1345
1346         win = MODEST_MAIN_WINDOW (user_data);
1347         header_view =
1348                 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1349
1350         /* Check if folder is empty and set headers view contents style */
1351         if (tny_folder_get_all_count (folder) == 0) {
1352         printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1353                 modest_main_window_set_contents_style (win,
1354                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1355         } else {
1356                 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1357         }
1358 }
1359
1360 void
1361 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1362                                                TnyFolderStore *folder_store,
1363                                                gboolean selected,
1364                                                ModestMainWindow *main_window)
1365 {
1366         ModestConf *conf;
1367         GtkWidget *header_view;
1368
1369         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1370
1371         header_view = modest_main_window_get_child_widget(main_window,
1372                                                           MODEST_WIDGET_TYPE_HEADER_VIEW);
1373         if (!header_view)
1374                 return;
1375
1376         conf = modest_runtime_get_conf ();
1377
1378         if (TNY_IS_ACCOUNT (folder_store)) {
1379                 if (selected) {
1380                         /* Update active account */
1381                         set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1382                         /* Show account details */
1383                         modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1384                 }
1385         } else {
1386                 if (TNY_IS_FOLDER (folder_store) && selected) {
1387
1388                         /* Update the active account */
1389                         TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1390                         if (account) {
1391                                 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1392                                 g_object_unref (account);
1393                                 account = NULL;
1394                         }
1395
1396                         /* Set the header style by default, it could
1397                            be changed later by the refresh callback to
1398                            empty */
1399                         modest_main_window_set_contents_style (main_window,
1400                                                                MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1401
1402                         /* Set folder on header view. This function
1403                            will call tny_folder_refresh_async so we
1404                            pass a callback that will be called when
1405                            finished. We use that callback to set the
1406                            empty view if there are no messages */
1407                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1408                                                        TNY_FOLDER (folder_store),
1409                                                        folder_refreshed_cb,
1410                                                        main_window);
1411
1412                         /* Restore configuration. We need to do this
1413                            *after* the set_folder because the widget
1414                            memory asks the header view about its
1415                            folder  */
1416                         modest_widget_memory_restore (modest_runtime_get_conf (),
1417                                                       G_OBJECT(header_view),
1418                                                       MODEST_CONF_HEADER_VIEW_KEY);
1419                 } else {
1420                         /* Update the active account */
1421                         modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1422                         /* Save only if we're seeing headers */
1423                         if (modest_main_window_get_contents_style (main_window) ==
1424                             MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1425                                 modest_widget_memory_save (conf, G_OBJECT (header_view),
1426                                                            MODEST_CONF_HEADER_VIEW_KEY);
1427                         modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1428                 }
1429         }
1430
1431         /* Update toolbar dimming state */
1432         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1433 }
1434
1435 void
1436 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1437                                      ModestWindow *win)
1438 {
1439         GtkWidget *dialog;
1440         gchar *txt, *item;
1441         gboolean online;
1442
1443         item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1444
1445         if (g_main_depth > 0)
1446                 gdk_threads_enter ();
1447         online = tny_device_is_online (modest_runtime_get_device());
1448
1449         if (online) {
1450                 /* already online -- the item is simply not there... */
1451                 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1452                                                  GTK_DIALOG_MODAL,
1453                                                  GTK_MESSAGE_WARNING,
1454                                                  GTK_BUTTONS_OK,
1455                                                  _("The %s you selected cannot be found"),
1456                                                  item);
1457                 gtk_dialog_run (GTK_DIALOG(dialog));
1458         } else {
1459                 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1460                                                       GTK_WINDOW (win),
1461                                                       GTK_DIALOG_MODAL,
1462                                                       GTK_STOCK_CANCEL,
1463                                                       GTK_RESPONSE_REJECT,
1464                                                       GTK_STOCK_OK,
1465                                                       GTK_RESPONSE_ACCEPT,
1466                                                       NULL);
1467                 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1468                                          "Do you want to get online?"), item);
1469                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1470                                     gtk_label_new (txt), FALSE, FALSE, 0);
1471                 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1472                 g_free (txt);
1473
1474                 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1475                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1476 //                      modest_platform_connect_and_wait ();
1477                 }
1478         }
1479         gtk_widget_destroy (dialog);
1480         if (g_main_depth > 0)
1481                 gdk_threads_leave ();
1482 }
1483
1484 void
1485 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1486                                      ModestWindow *win)
1487 {
1488         /* g_message ("%s %s", __FUNCTION__, link); */
1489 }
1490
1491
1492 void
1493 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1494                                         ModestWindow *win)
1495 {
1496         modest_platform_activate_uri (link);
1497 }
1498
1499 void
1500 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1501                                           ModestWindow *win)
1502 {
1503         modest_platform_show_uri_popup (link);
1504 }
1505
1506 void
1507 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1508                                              ModestWindow *win)
1509 {
1510         modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1511 }
1512
1513 void
1514 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1515                                           const gchar *address,
1516                                           ModestWindow *win)
1517 {
1518         /* g_message ("%s %s", __FUNCTION__, address); */
1519 }
1520
1521 void
1522 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1523 {
1524         TnyTransportAccount *transport_account;
1525         ModestMailOperation *mail_operation;
1526         MsgData *data;
1527         gchar *account_name, *from;
1528         ModestAccountMgr *account_mgr;
1529         gchar *info_text = NULL;
1530
1531         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1532
1533         data = modest_msg_edit_window_get_msg_data (edit_window);
1534
1535         account_mgr = modest_runtime_get_account_mgr();
1536         account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1537         if (!account_name)
1538                 account_name = modest_account_mgr_get_default_account (account_mgr);
1539         if (!account_name) {
1540                 g_printerr ("modest: no account found\n");
1541                 modest_msg_edit_window_free_msg_data (edit_window, data);
1542                 return;
1543         }
1544
1545         if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1546                 account_name = g_strdup (data->account_name);
1547         }
1548
1549         transport_account =
1550                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1551                                       (modest_runtime_get_account_store(),
1552                                        account_name,
1553                                        TNY_ACCOUNT_TYPE_TRANSPORT));
1554         if (!transport_account) {
1555                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1556                 g_free (account_name);
1557                 modest_msg_edit_window_free_msg_data (edit_window, data);
1558                 return;
1559         }
1560         from = modest_account_mgr_get_from_string (account_mgr, account_name);
1561
1562         /* Create the mail operation */
1563         mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1564         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1565
1566         modest_mail_operation_save_to_drafts (mail_operation,
1567                                               transport_account,
1568                                               data->draft_msg,
1569                                               from,
1570                                               data->to,
1571                                               data->cc,
1572                                               data->bcc,
1573                                               data->subject,
1574                                               data->plain_body,
1575                                               data->html_body,
1576                                               data->attachments,
1577                                               data->priority_flags);
1578         /* Frees */
1579         g_free (from);
1580         g_free (account_name);
1581         g_object_unref (G_OBJECT (transport_account));
1582         g_object_unref (G_OBJECT (mail_operation));
1583
1584         modest_msg_edit_window_free_msg_data (edit_window, data);
1585
1586         info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1587         modest_platform_information_banner (NULL, NULL, info_text);
1588         g_free (info_text);
1589 }
1590
1591 /* For instance, when clicking the Send toolbar button when editing a message: */
1592 void
1593 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1594 {
1595         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1596
1597         if (!modest_msg_edit_window_check_names (edit_window))
1598                 return;
1599
1600         /* FIXME: Code added just for testing. The final version will
1601            use the send queue provided by tinymail and some
1602            classifier */
1603         ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1604         gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1605         if (!account_name)
1606                 account_name = modest_account_mgr_get_default_account (account_mgr);
1607
1608         if (!account_name) {
1609                 g_printerr ("modest: no account found\n");
1610                 return;
1611         }
1612
1613         MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1614
1615         if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1616                 account_name = g_strdup (data->account_name);
1617         }
1618
1619         /* Get the currently-active transport account for this modest account: */
1620         TnyTransportAccount *transport_account =
1621                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1622                                       (modest_runtime_get_account_store(),
1623                                        account_name));
1624         if (!transport_account) {
1625                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1626                 g_free (account_name);
1627                 modest_msg_edit_window_free_msg_data (edit_window, data);
1628                 return;
1629         }
1630
1631         gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1632
1633         /* mail content checks and dialogs */
1634         if (data->subject == NULL || data->subject[0] == '\0') {
1635                 GtkResponseType response;
1636                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1637                                                                     _("mcen_nc_subject_is_empty_send"));
1638                 if (response == GTK_RESPONSE_CANCEL) {
1639                         g_free (account_name);
1640                         return;
1641                 }
1642         }
1643
1644         if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1645                 GtkResponseType response;
1646                 gchar *note_message;
1647                 gchar *note_subject = data->subject;
1648                 if (note_subject == NULL || note_subject[0] == '\0')
1649                         note_subject = _("mail_va_no_subject");
1650                 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1651                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1652                                                                     note_message);
1653                 g_free (note_message);
1654                 if (response == GTK_RESPONSE_CANCEL) {
1655                         g_free (account_name);
1656                         return;
1657                 }
1658         }
1659
1660         modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
1661
1662         /* Create the mail operation */
1663         ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1664         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1665
1666         modest_mail_operation_send_new_mail (mail_operation,
1667                                              transport_account,
1668                                              data->draft_msg,
1669                                              from,
1670                                              data->to,
1671                                              data->cc,
1672                                              data->bcc,
1673                                              data->subject,
1674                                              data->plain_body,
1675                                              data->html_body,
1676                                              data->attachments,
1677                                              data->priority_flags);
1678
1679         /* Free data: */
1680         g_free (from);
1681         g_free (account_name);
1682         g_object_unref (G_OBJECT (transport_account));
1683         g_object_unref (G_OBJECT (mail_operation));
1684
1685         modest_msg_edit_window_free_msg_data (edit_window, data);
1686         modest_msg_edit_window_set_sent (edit_window, TRUE);
1687
1688         /* Save settings and close the window: */
1689         gtk_widget_destroy (GTK_WIDGET (edit_window));
1690 }
1691
1692 void
1693 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1694                                   ModestMsgEditWindow *window)
1695 {
1696         ModestMsgEditFormatState *format_state = NULL;
1697
1698         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1699         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1700
1701         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1702                 return;
1703
1704         format_state = modest_msg_edit_window_get_format_state (window);
1705         g_return_if_fail (format_state != NULL);
1706
1707         format_state->bold = gtk_toggle_action_get_active (action);
1708         modest_msg_edit_window_set_format_state (window, format_state);
1709         g_free (format_state);
1710
1711 }
1712
1713 void
1714 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1715                                      ModestMsgEditWindow *window)
1716 {
1717         ModestMsgEditFormatState *format_state = NULL;
1718
1719         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1720         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1721
1722         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1723                 return;
1724
1725         format_state = modest_msg_edit_window_get_format_state (window);
1726         g_return_if_fail (format_state != NULL);
1727
1728         format_state->italics = gtk_toggle_action_get_active (action);
1729         modest_msg_edit_window_set_format_state (window, format_state);
1730         g_free (format_state);
1731
1732 }
1733
1734 void
1735 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1736                                      ModestMsgEditWindow *window)
1737 {
1738         ModestMsgEditFormatState *format_state = NULL;
1739
1740         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1741         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1742
1743         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1744                 return;
1745
1746         format_state = modest_msg_edit_window_get_format_state (window);
1747         g_return_if_fail (format_state != NULL);
1748
1749         format_state->bullet = gtk_toggle_action_get_active (action);
1750         modest_msg_edit_window_set_format_state (window, format_state);
1751         g_free (format_state);
1752
1753 }
1754
1755 void
1756 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1757                                      GtkRadioAction *selected,
1758                                      ModestMsgEditWindow *window)
1759 {
1760         ModestMsgEditFormatState *format_state = NULL;
1761         GtkJustification value;
1762
1763         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1764
1765         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1766                 return;
1767
1768         value = gtk_radio_action_get_current_value (selected);
1769
1770         format_state = modest_msg_edit_window_get_format_state (window);
1771         g_return_if_fail (format_state != NULL);
1772
1773         format_state->justification = value;
1774         modest_msg_edit_window_set_format_state (window, format_state);
1775         g_free (format_state);
1776 }
1777
1778 void
1779 modest_ui_actions_on_select_editor_color (GtkAction *action,
1780                                           ModestMsgEditWindow *window)
1781 {
1782         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1783         g_return_if_fail (GTK_IS_ACTION (action));
1784
1785         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1786                 return;
1787
1788         modest_msg_edit_window_select_color (window);
1789 }
1790
1791 void
1792 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1793                                                      ModestMsgEditWindow *window)
1794 {
1795         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1796         g_return_if_fail (GTK_IS_ACTION (action));
1797
1798         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1799                 return;
1800
1801         modest_msg_edit_window_select_background_color (window);
1802 }
1803
1804 void
1805 modest_ui_actions_on_insert_image (GtkAction *action,
1806                                    ModestMsgEditWindow *window)
1807 {
1808         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1809         g_return_if_fail (GTK_IS_ACTION (action));
1810
1811         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1812                 return;
1813
1814         modest_msg_edit_window_insert_image (window);
1815 }
1816
1817 void
1818 modest_ui_actions_on_attach_file (GtkAction *action,
1819                                   ModestMsgEditWindow *window)
1820 {
1821         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1822         g_return_if_fail (GTK_IS_ACTION (action));
1823
1824         modest_msg_edit_window_attach_file (window);
1825 }
1826
1827 void
1828 modest_ui_actions_on_remove_attachments (GtkAction *action,
1829                                          ModestMsgEditWindow *window)
1830 {
1831         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1832         g_return_if_fail (GTK_IS_ACTION (action));
1833
1834         modest_msg_edit_window_remove_attachments (window, NULL);
1835 }
1836
1837 void
1838 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1839 {
1840         TnyFolderStore *parent_folder;
1841         GtkWidget *folder_view;
1842
1843         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1844
1845         folder_view = modest_main_window_get_child_widget (main_window,
1846                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1847         if (!folder_view)
1848                 return;
1849
1850         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1851
1852         if (parent_folder) {
1853                 gboolean finished = FALSE;
1854                 gint result;
1855                 gchar *folder_name = NULL, *suggested_name = NULL;
1856
1857                 /* Run the new folder dialog */
1858                 while (!finished) {
1859                         result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1860                                                                         parent_folder,
1861                                                                         suggested_name,
1862                                                                         &folder_name);
1863
1864                         if (result == GTK_RESPONSE_REJECT) {
1865                                 finished = TRUE;
1866                         } else {
1867                                 ModestMailOperation *mail_op;
1868                                 TnyFolder *new_folder = NULL;
1869
1870                                 mail_op  = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO,
1871                                                                       G_OBJECT(main_window));
1872                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1873                                                                  mail_op);
1874                                 new_folder = modest_mail_operation_create_folder (mail_op,
1875                                                                                   parent_folder,
1876                                                                                   (const gchar *) folder_name);
1877                                 if (new_folder) {
1878                                         g_object_unref (new_folder);
1879                                         finished = TRUE;
1880                                 }
1881                                 g_object_unref (mail_op);
1882                         }
1883                         g_free (folder_name);
1884                         folder_name = NULL;
1885                 }
1886
1887                 g_object_unref (parent_folder);
1888         }
1889 }
1890
1891 void
1892 modest_ui_actions_on_rename_folder (GtkAction *action,
1893                                      ModestMainWindow *main_window)
1894 {
1895         TnyFolderStore *folder;
1896         GtkWidget *folder_view;
1897         GtkWidget *header_view;
1898
1899         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1900
1901         folder_view = modest_main_window_get_child_widget (main_window,
1902                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1903         if (!folder_view)
1904                 return;
1905
1906         header_view = modest_main_window_get_child_widget (main_window,
1907                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1908
1909         if (!header_view)
1910                 return;
1911
1912         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1913
1914         if (folder && TNY_IS_FOLDER (folder)) {
1915                 gchar *folder_name;
1916                 gint response;
1917                 const gchar *current_name;
1918
1919                 current_name = tny_folder_get_name (TNY_FOLDER (folder));
1920                 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
1921                                                                      current_name, &folder_name);
1922
1923                 if (response == GTK_RESPONSE_OK && strlen (folder_name) > 0) {
1924                         ModestMailOperation *mail_op;
1925
1926                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1927                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1928                                                          mail_op);
1929
1930                         modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
1931
1932                         modest_mail_operation_rename_folder (mail_op,
1933                                                              TNY_FOLDER (folder),
1934                                                              (const gchar *) folder_name);
1935
1936                         g_object_unref (mail_op);
1937                         g_free (folder_name);
1938                 }
1939                 g_object_unref (folder);
1940         }
1941 }
1942
1943 static void
1944 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
1945                                                gpointer user_data)
1946 {
1947         GObject *win = modest_mail_operation_get_source (mail_op);
1948
1949         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1950                                                 _("mail_in_ui_folder_delete_error"));
1951         g_object_unref (win);
1952 }
1953
1954 static void
1955 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1956 {
1957         TnyFolderStore *folder;
1958         GtkWidget *folder_view;
1959         gint response;
1960         gchar *message;
1961
1962         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1963
1964         folder_view = modest_main_window_get_child_widget (main_window,
1965                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1966         if (!folder_view)
1967                 return;
1968
1969         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1970
1971         /* Show an error if it's an account */
1972         if (!TNY_IS_FOLDER (folder)) {
1973                 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1974                                                         _("mail_in_ui_folder_delete_error"));
1975                 return ;
1976         }
1977
1978         /* Ask the user */
1979         message =  g_strdup_printf (_("mcen_nc_delete_folder_text"),
1980                                     tny_folder_get_name (TNY_FOLDER (folder)));
1981         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1982                                                             (const gchar *) message);
1983         g_free (message);
1984
1985         if (response == GTK_RESPONSE_OK) {
1986                 ModestMailOperation *mail_op =
1987                         modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
1988                                                                        G_OBJECT(main_window),
1989                                                                        modest_ui_actions_delete_folder_error_handler,
1990                                                                        NULL);
1991
1992                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1993                                                  mail_op);
1994                 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1995                 g_object_unref (G_OBJECT (mail_op));
1996         }
1997
1998         g_object_unref (G_OBJECT (folder));
1999 }
2000
2001 void
2002 modest_ui_actions_on_delete_folder (GtkAction *action,
2003                                      ModestMainWindow *main_window)
2004 {
2005         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2006
2007         delete_folder (main_window, FALSE);
2008 }
2009
2010 void
2011 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2012 {
2013         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2014
2015         delete_folder (main_window, TRUE);
2016 }
2017
2018 void
2019 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2020                                          const gchar* server_account_name,
2021                                          gchar **username,
2022                                          gchar **password,
2023                                          gboolean *cancel,
2024                                          gboolean *remember,
2025                                          ModestMainWindow *main_window)
2026 {
2027         g_return_if_fail(server_account_name);
2028         /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2029
2030         /* Initalize output parameters: */
2031         if (cancel)
2032                 *cancel = FALSE;
2033
2034         if (remember)
2035                 *remember = TRUE;
2036
2037 #ifdef MODEST_PLATFORM_MAEMO
2038         /* Maemo uses a different (awkward) button order,
2039          * It should probably just use gtk_alternative_dialog_button_order ().
2040          */
2041         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2042                                               NULL,
2043                                               GTK_DIALOG_MODAL,
2044                                               GTK_STOCK_OK,
2045                                               GTK_RESPONSE_ACCEPT,
2046                                               GTK_STOCK_CANCEL,
2047                                               GTK_RESPONSE_REJECT,
2048                                               NULL);
2049 #else
2050         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2051                                               NULL,
2052                                               GTK_DIALOG_MODAL,
2053                                               GTK_STOCK_CANCEL,
2054                                               GTK_RESPONSE_REJECT,
2055                                               GTK_STOCK_OK,
2056                                               GTK_RESPONSE_ACCEPT,
2057                                               NULL);
2058 #endif /* MODEST_PLATFORM_MAEMO */
2059
2060         gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2061
2062         gchar *server_name = modest_server_account_get_hostname (
2063                 modest_runtime_get_account_mgr(), server_account_name);
2064         if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2065                 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2066                 *cancel = TRUE;
2067                 return;
2068         }
2069
2070         /* This causes a warning because the logical ID has no %s in it,
2071          * though the translation does, but there is not much we can do about that: */
2072         gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2073         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2074                             FALSE, FALSE, 0);
2075         g_free (txt);
2076         g_free (server_name);
2077         server_name = NULL;
2078
2079         /* username: */
2080         gchar *initial_username = modest_server_account_get_username (
2081                 modest_runtime_get_account_mgr(), server_account_name);
2082
2083         GtkWidget *entry_username = gtk_entry_new ();
2084         if (initial_username)
2085                 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2086         /* Dim this if a connection has ever succeeded with this username,
2087          * as per the UI spec: */
2088         const gboolean username_known =
2089                 modest_server_account_get_username_has_succeeded(
2090                         modest_runtime_get_account_mgr(), server_account_name);
2091         gtk_widget_set_sensitive (entry_username, !username_known);
2092
2093 #ifdef MODEST_PLATFORM_MAEMO
2094         /* Auto-capitalization is the default, so let's turn it off: */
2095         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2096
2097         /* Create a size group to be used by all captions.
2098          * Note that HildonCaption does not create a default size group if we do not specify one.
2099          * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2100         GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2101
2102         GtkWidget *caption = hildon_caption_new (sizegroup,
2103                 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2104         gtk_widget_show (entry_username);
2105         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2106                 FALSE, FALSE, MODEST_MARGIN_HALF);
2107         gtk_widget_show (caption);
2108 #else
2109         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2110                             TRUE, FALSE, 0);
2111 #endif /* MODEST_PLATFORM_MAEMO */
2112
2113         /* password: */
2114         GtkWidget *entry_password = gtk_entry_new ();
2115         gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2116         /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2117
2118 #ifdef MODEST_PLATFORM_MAEMO
2119         /* Auto-capitalization is the default, so let's turn it off: */
2120         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2121                 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2122
2123         caption = hildon_caption_new (sizegroup,
2124                 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2125         gtk_widget_show (entry_password);
2126         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2127                 FALSE, FALSE, MODEST_MARGIN_HALF);
2128         gtk_widget_show (caption);
2129         g_object_unref (sizegroup);
2130 #else
2131         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2132                             TRUE, FALSE, 0);
2133 #endif /* MODEST_PLATFORM_MAEMO */
2134
2135 /* This is not in the Maemo UI spec:
2136         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2137         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2138                             TRUE, FALSE, 0);
2139 */
2140
2141         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2142
2143         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2144                 if (username) {
2145                         *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2146
2147                         modest_server_account_set_username (
2148                                  modest_runtime_get_account_mgr(), server_account_name,
2149                                  *username);
2150
2151                         const gboolean username_was_changed =
2152                                 (strcmp (*username, initial_username) != 0);
2153                         if (username_was_changed) {
2154                                 g_warning ("%s: tinymail does not yet support changing the "
2155                                         "username in the get_password() callback.\n", __FUNCTION__);
2156                         }
2157                 }
2158
2159                 if (password) {
2160                         *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2161
2162                         /* We do not save the password in the configuration,
2163                          * because this function is only called for passwords that should
2164                          * not be remembered:
2165                         modest_server_account_set_password (
2166                                  modest_runtime_get_account_mgr(), server_account_name,
2167                                  *password);
2168                         */
2169                 }
2170
2171                 if (cancel)
2172                         *cancel   = FALSE;
2173
2174         } else {
2175                 if (username)
2176                         *username = NULL;
2177
2178                 if (password)
2179                         *password = NULL;
2180
2181                 if (cancel)
2182                         *cancel   = TRUE;
2183         }
2184
2185 /* This is not in the Maemo UI spec:
2186         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2187                 *remember = TRUE;
2188         else
2189                 *remember = FALSE;
2190 */
2191
2192         gtk_widget_destroy (dialog);
2193
2194         /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2195 }
2196
2197 void
2198 modest_ui_actions_on_cut (GtkAction *action,
2199                           ModestWindow *window)
2200 {
2201         GtkWidget *focused_widget;
2202
2203         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2204         if (GTK_IS_EDITABLE (focused_widget)) {
2205                 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2206         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2207                 GtkTextBuffer *buffer;
2208                 GtkClipboard *clipboard;
2209
2210                 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2211                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2212                 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2213         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2214                 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2215         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2216                 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2217         }
2218 }
2219
2220 void
2221 modest_ui_actions_on_copy (GtkAction *action,
2222                            ModestWindow *window)
2223 {
2224         GtkClipboard *clipboard;
2225         GtkWidget *focused_widget;
2226
2227         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2228         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2229
2230         if (GTK_IS_LABEL (focused_widget)) {
2231                 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2232         } else if (GTK_IS_EDITABLE (focused_widget)) {
2233                 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2234         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2235                 GtkTextBuffer *buffer;
2236                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2237                 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2238                 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2239         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2240                 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2241                 TnyIterator *iter = tny_list_create_iterator (header_list);
2242                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2243                 TnyFolder *folder = tny_header_get_folder (header);
2244                 TnyAccount *account = tny_folder_get_account (folder);
2245                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2246                 /* If it's POP then ask */
2247                 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2248                        MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2249                 g_object_unref (account);
2250                 g_object_unref (folder);
2251                 g_object_unref (header);
2252                 g_object_unref (iter);
2253
2254                 /* Check that the messages have been previously downloaded */
2255                 gboolean continue_download = TRUE;
2256                 if (ask)
2257                         continue_download = download_uncached_messages (header_list, GTK_WINDOW (window));
2258                 if (continue_download)
2259                         modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2260                 g_object_unref (header_list);
2261         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2262                 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2263         }
2264
2265         /* Show information banner */
2266         modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2267
2268 }
2269
2270 void
2271 modest_ui_actions_on_undo (GtkAction *action,
2272                            ModestWindow *window)
2273 {
2274         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2275                 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2276         } else {
2277                 g_return_if_reached ();
2278         }
2279 }
2280
2281 void
2282 modest_ui_actions_on_paste (GtkAction *action,
2283                             ModestWindow *window)
2284 {
2285         GtkWidget *focused_widget;
2286         ModestMailOperation *mail_op = NULL;
2287
2288         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2289         if (GTK_IS_EDITABLE (focused_widget)) {
2290                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2291         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2292                 GtkTextBuffer *buffer;
2293                 GtkClipboard *clipboard;
2294
2295                 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2296                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2297                 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2298         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2299                 ModestEmailClipboard *clipboard = NULL;
2300                 TnyFolder *src_folder = NULL;
2301                 TnyFolderStore *folder_store = NULL;
2302                 TnyList *data = NULL;
2303                 gboolean delete = FALSE;
2304
2305                 /* Check clipboard source */
2306                 clipboard = modest_runtime_get_email_clipboard ();
2307                 if (modest_email_clipboard_cleared (clipboard))
2308                         return;
2309
2310                 /* Get elements to paste */
2311                 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2312
2313                 /* Create a new mail operation */
2314                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2315                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2316                                                  mail_op);
2317
2318                 /* Get destination folder */
2319                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2320
2321                 /* transfer messages  */
2322                 if (data != NULL) {
2323                         modest_mail_operation_xfer_msgs (mail_op,
2324                                                          data,
2325                                                          TNY_FOLDER (folder_store),
2326                                                          delete,
2327                                                          NULL,
2328                                                          NULL);
2329
2330                 } else if (src_folder != NULL) {
2331                         modest_mail_operation_xfer_folder (mail_op,
2332                                                            src_folder,
2333                                                            folder_store,
2334                                                            delete);
2335                 }
2336
2337                 /* Free */
2338                 if (data != NULL)
2339                         g_object_unref (data);
2340                 if (src_folder != NULL)
2341                         g_object_unref (src_folder);
2342                 if (folder_store != NULL)
2343                         g_object_unref (folder_store);
2344         }
2345 }
2346
2347 void
2348 modest_ui_actions_on_select_all (GtkAction *action,
2349                                  ModestWindow *window)
2350 {
2351         GtkWidget *focused_widget;
2352
2353         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2354         if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2355                 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2356         } else if (GTK_IS_LABEL (focused_widget)) {
2357                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2358         } else if (GTK_IS_EDITABLE (focused_widget)) {
2359                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2360         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2361                 GtkTextBuffer *buffer;
2362                 GtkTextIter start, end;
2363
2364                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2365                 gtk_text_buffer_get_start_iter (buffer, &start);
2366                 gtk_text_buffer_get_end_iter (buffer, &end);
2367                 gtk_text_buffer_select_range (buffer, &start, &end);
2368         }
2369         else if ((MODEST_IS_FOLDER_VIEW (focused_widget)) ||
2370                  (MODEST_IS_HEADER_VIEW (focused_widget))) {
2371
2372                 GtkTreeSelection *selection = NULL;
2373
2374                 /* Get header view */
2375                 GtkWidget *header_view = focused_widget;
2376                 if (MODEST_IS_FOLDER_VIEW (focused_widget))
2377                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2378                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2379
2380                 /* Select all messages */
2381                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2382                 gtk_tree_selection_select_all (selection);
2383
2384                 /* Set focuse on header view */
2385                 gtk_widget_grab_focus (header_view);
2386
2387         } else if (GTK_IS_HTML (focused_widget)) {
2388                 gtk_html_select_all (GTK_HTML (focused_widget));
2389         }
2390 }
2391
2392 void
2393 modest_ui_actions_on_mark_as_read (GtkAction *action,
2394                                    ModestWindow *window)
2395 {
2396         g_return_if_fail (MODEST_IS_WINDOW(window));
2397
2398         /* Mark each header as read */
2399         do_headers_action (window, headers_action_mark_as_read, NULL);
2400 }
2401
2402 void
2403 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2404                                      ModestWindow *window)
2405 {
2406         g_return_if_fail (MODEST_IS_WINDOW(window));
2407
2408         /* Mark each header as read */
2409         do_headers_action (window, headers_action_mark_as_unread, NULL);
2410 }
2411
2412 void
2413 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2414                                   GtkRadioAction *selected,
2415                                   ModestWindow *window)
2416 {
2417         gint value;
2418
2419         value = gtk_radio_action_get_current_value (selected);
2420         if (MODEST_IS_WINDOW (window)) {
2421                 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2422         }
2423 }
2424
2425 void     modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2426                                                         GtkRadioAction *selected,
2427                                                         ModestWindow *window)
2428 {
2429         TnyHeaderFlags flags;
2430         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2431
2432         flags = gtk_radio_action_get_current_value (selected);
2433         modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2434 }
2435
2436 void     modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2437                                                            GtkRadioAction *selected,
2438                                                            ModestWindow *window)
2439 {
2440         gint file_format;
2441
2442         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2443
2444         file_format = gtk_radio_action_get_current_value (selected);
2445         modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2446 }
2447
2448
2449 void
2450 modest_ui_actions_on_zoom_plus (GtkAction *action,
2451                                 ModestWindow *window)
2452 {
2453         g_return_if_fail (MODEST_IS_WINDOW (window));
2454
2455         modest_window_zoom_plus (MODEST_WINDOW (window));
2456 }
2457
2458 void
2459 modest_ui_actions_on_zoom_minus (GtkAction *action,
2460                                  ModestWindow *window)
2461 {
2462         g_return_if_fail (MODEST_IS_WINDOW (window));
2463
2464         modest_window_zoom_minus (MODEST_WINDOW (window));
2465 }
2466
2467 void
2468 modest_ui_actions_on_toggle_fullscreen    (GtkToggleAction *toggle,
2469                                            ModestWindow *window)
2470 {
2471         ModestWindowMgr *mgr;
2472         gboolean fullscreen, active;
2473         g_return_if_fail (MODEST_IS_WINDOW (window));
2474
2475         mgr = modest_runtime_get_window_mgr ();
2476
2477         active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2478         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2479
2480         if (active != fullscreen) {
2481                 modest_window_mgr_set_fullscreen_mode (mgr, active);
2482                 gtk_window_present (GTK_WINDOW (window));
2483         }
2484 }
2485
2486 void
2487 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2488                                         ModestWindow *window)
2489 {
2490         ModestWindowMgr *mgr;
2491         gboolean fullscreen;
2492
2493         g_return_if_fail (MODEST_IS_WINDOW (window));
2494
2495         mgr = modest_runtime_get_window_mgr ();
2496         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2497         modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2498
2499         gtk_window_present (GTK_WINDOW (window));
2500 }
2501
2502 /*
2503  * Used by modest_ui_actions_on_details to call do_headers_action
2504  */
2505 static void
2506 headers_action_show_details (TnyHeader *header,
2507                              ModestWindow *window,
2508                              gpointer user_data)
2509
2510 {
2511         GtkWidget *dialog;
2512
2513         /* Create dialog */
2514         dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2515
2516         /* Run dialog */
2517         gtk_widget_show_all (dialog);
2518         gtk_dialog_run (GTK_DIALOG (dialog));
2519
2520         gtk_widget_destroy (dialog);
2521 }
2522
2523 /*
2524  * Show the folder details in a ModestDetailsDialog widget
2525  */
2526 static void
2527 show_folder_details (TnyFolder *folder,
2528                      GtkWindow *window)
2529 {
2530         GtkWidget *dialog;
2531
2532         /* Create dialog */
2533         dialog = modest_details_dialog_new_with_folder (window, folder);
2534
2535         /* Run dialog */
2536         gtk_widget_show_all (dialog);
2537         gtk_dialog_run (GTK_DIALOG (dialog));
2538
2539         gtk_widget_destroy (dialog);
2540 }
2541
2542 /*
2543  * Show the header details in a ModestDetailsDialog widget
2544  */
2545 void
2546 modest_ui_actions_on_details (GtkAction *action,
2547                               ModestWindow *win)
2548 {
2549         TnyList * headers_list;
2550         TnyIterator *iter;
2551         TnyHeader *header;
2552
2553         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2554                 TnyMsg *msg;
2555
2556                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2557                 if (!msg)
2558                         return;
2559                 g_object_unref (msg);
2560
2561                 headers_list = get_selected_headers (win);
2562                 if (!headers_list)
2563                         return;
2564
2565                 iter = tny_list_create_iterator (headers_list);
2566
2567                 header = TNY_HEADER (tny_iterator_get_current (iter));
2568                 headers_action_show_details (header, win, NULL);
2569                 g_object_unref (header);
2570
2571                 g_object_unref (iter);
2572                 g_object_unref (headers_list);
2573
2574         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2575                 GtkWidget *folder_view, *header_view;
2576
2577                 /* Check which widget has the focus */
2578                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2579                                                                     MODEST_WIDGET_TYPE_FOLDER_VIEW);
2580                 if (gtk_widget_is_focus (folder_view)) {
2581                         TnyFolderStore *folder_store
2582                                 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2583                         if (!folder_store) {
2584                                 g_warning ("%s: No item was selected.\n", __FUNCTION__);
2585                                 return;
2586                         }
2587                         /* Show only when it's a folder */
2588                         /* This function should not be called for account items,
2589                          * because we dim the menu item for them. */
2590                         if (TNY_IS_FOLDER (folder_store)) {
2591                                 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
2592                         }
2593
2594                         g_object_unref (folder_store);
2595
2596                 } else {
2597                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2598                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2599                         /* Show details of each header */
2600                         do_headers_action (win, headers_action_show_details, header_view);
2601                 }
2602         }
2603 }
2604
2605 void
2606 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2607                                      ModestMsgEditWindow *window)
2608 {
2609         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2610
2611         modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2612 }
2613
2614 void
2615 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2616                                       ModestMsgEditWindow *window)
2617 {
2618         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2619
2620         modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2621 }
2622
2623 void
2624 modest_ui_actions_toggle_folders_view (GtkAction *action,
2625                                        ModestMainWindow *main_window)
2626 {
2627         ModestConf *conf;
2628
2629         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2630
2631         conf = modest_runtime_get_conf ();
2632
2633         if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2634                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2635         else
2636                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2637 }
2638
2639 void
2640 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2641                                      ModestWindow *window)
2642 {
2643         gboolean active, fullscreen = FALSE;
2644         ModestWindowMgr *mgr;
2645
2646         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2647
2648         /* Check if we want to toggle the toolbar vuew in fullscreen
2649            or normal mode */
2650         if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2651                      "ViewShowToolbarFullScreen")) {
2652                 fullscreen = TRUE;
2653         }
2654
2655         /* Toggle toolbar */
2656         mgr = modest_runtime_get_window_mgr ();
2657         modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2658 }
2659
2660 void
2661 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2662                                            ModestMsgEditWindow *window)
2663 {
2664         modest_msg_edit_window_select_font (window);
2665 }
2666
2667 void
2668 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2669                                                   const gchar *display_name,
2670                                                   GtkWindow *window)
2671 {
2672         /* Do not change the application name if the widget has not
2673            the focus. This callback could be called even if the folder
2674            view has not the focus, because the handled signal could be
2675            emitted when the folder view is redrawn */
2676         if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2677                 if (display_name)
2678                         gtk_window_set_title (window, display_name);
2679                 else
2680                         gtk_window_set_title (window, " ");
2681         }
2682 }
2683
2684 void
2685 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2686 {
2687         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2688         modest_msg_edit_window_select_contacts (window);
2689 }
2690
2691 void
2692 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2693 {
2694         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2695         modest_msg_edit_window_check_names (window);
2696 }
2697
2698
2699 static GtkWidget*
2700 create_move_to_dialog (ModestWindow *win,
2701                        GtkWidget *folder_view,
2702                        GtkWidget **tree_view)
2703 {
2704         GtkWidget *dialog, *scroll;
2705
2706         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2707                                               GTK_WINDOW (win),
2708                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2709                                               GTK_STOCK_OK,
2710                                               GTK_RESPONSE_ACCEPT,
2711                                               GTK_STOCK_CANCEL,
2712                                               GTK_RESPONSE_REJECT,
2713                                               NULL);
2714
2715         /* Create scrolled window */
2716         scroll = gtk_scrolled_window_new (NULL, NULL);
2717         gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scroll),
2718                                          GTK_POLICY_AUTOMATIC,
2719                                          GTK_POLICY_AUTOMATIC);
2720
2721         /* Create folder view */
2722         *tree_view = modest_platform_create_folder_view (NULL);
2723
2724         /* It could happen that we're trying to move a message from a
2725            window (msg window for example) after the main window was
2726            closed, so we can not just get the model of the folder
2727            view */
2728         if (MODEST_IS_FOLDER_VIEW (folder_view))
2729                 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2730                                          gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2731         else
2732                 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
2733                                                  TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
2734
2735         gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2736
2737         /* Add scroll to dialog */
2738         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2739                             scroll, FALSE, FALSE, 0);
2740
2741         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2742
2743         /* Select INBOX or local account */
2744         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (*tree_view));
2745
2746         return dialog;
2747 }
2748
2749 /*
2750  * Returns TRUE if at least one of the headers of the list belongs to
2751  * a message that has been fully retrieved.
2752  */
2753 static gboolean
2754 has_retrieved_msgs (TnyList *list)
2755 {
2756         TnyIterator *iter;
2757         gboolean found = FALSE;
2758
2759         iter = tny_list_create_iterator (list);
2760         while (tny_iterator_is_done (iter) && !found) {
2761                 TnyHeader *header;
2762                 TnyHeaderFlags flags;
2763
2764                 header = TNY_HEADER (tny_iterator_get_current (iter));
2765                 flags = tny_header_get_flags (header);
2766                 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2767                         found = TRUE;
2768
2769                 if (!found)
2770                         tny_iterator_next (iter);
2771         }
2772         g_object_unref (iter);
2773
2774         return found;
2775 }
2776
2777 /*
2778  * Shows a confirmation dialog to the user when we're moving messages
2779  * from a remote server to the local storage. Returns the dialog
2780  * response. If it's other kind of movement the it always returns
2781  * GTK_RESPONSE_OK
2782  */
2783 static gint
2784 msgs_move_to_confirmation (GtkWindow *win,
2785                            TnyFolder *dest_folder,
2786                            TnyList *headers)
2787 {
2788         gint response = GTK_RESPONSE_OK;
2789
2790         /* If the destination is a local folder */
2791         if (modest_tny_folder_is_local_folder (dest_folder)) {
2792                 TnyFolder *src_folder;
2793                 TnyIterator *iter;
2794                 TnyHeader *header;
2795
2796                 /* Get source folder */
2797                 iter = tny_list_create_iterator (headers);
2798                 header = TNY_HEADER (tny_iterator_get_current (iter));
2799                 src_folder = tny_header_get_folder (header);
2800                 g_object_unref (header);
2801                 g_object_unref (iter);
2802
2803                 /* if no src_folder, message may be an attahcment */
2804                 if (src_folder == NULL)
2805                         return GTK_RESPONSE_CANCEL;
2806
2807                 /* If the source is a remote folder */
2808                 if (!modest_tny_folder_is_local_folder (src_folder)) {
2809                         const gchar *message;
2810
2811                         if (has_retrieved_msgs (headers))
2812                                 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
2813                                                     tny_list_get_length (headers));
2814                         else
2815                                 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
2816                                                     tny_list_get_length (headers));
2817
2818                         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2819                                                                             (const gchar *) message);
2820                 }
2821                 g_object_unref (src_folder);
2822         }
2823         return response;
2824 }
2825
2826
2827 static void
2828 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2829 {
2830         ModestMsgViewWindow *self = NULL;
2831
2832         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2833         self = MODEST_MSG_VIEW_WINDOW (object);
2834
2835         /* If there are not more messages don't do anything. The
2836            viewer will show the same message */
2837         if (!modest_msg_view_window_select_first_message (self))
2838             return;
2839 }
2840
2841 void
2842 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
2843                                              gpointer user_data)
2844 {
2845         GObject *win = modest_mail_operation_get_source (mail_op);
2846
2847         /* TODO: show error message */
2848         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2849                                                 _("mail_in_ui_folder_move_target_error"));
2850         g_object_unref (win);
2851 }
2852
2853 /*
2854  * UI handler for the "Move to" action when invoked from the
2855  * ModestMainWindow
2856  */
2857 static void
2858 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2859                                           ModestMainWindow *win)
2860 {
2861         GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2862         GtkWidget *header_view = NULL;
2863         gint result;
2864         TnyFolderStore *folder_store = NULL;
2865         ModestMailOperation *mail_op = NULL;
2866
2867         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2868
2869         /* Get the folder view */
2870         folder_view = modest_main_window_get_child_widget (win,
2871                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2872
2873         /* Get header view */
2874         header_view = modest_main_window_get_child_widget (win,
2875                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2876
2877         /* Create and run the dialog */
2878         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2879         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
2880         result = gtk_dialog_run (GTK_DIALOG(dialog));
2881         g_object_ref (tree_view);
2882
2883         /* We do this to save an indentation level ;-) */
2884         if (result != GTK_RESPONSE_ACCEPT)
2885                 goto end;
2886
2887         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2888
2889         if (TNY_IS_ACCOUNT (folder_store))
2890                 goto end;
2891
2892         /* Get folder or messages to transfer */
2893         if (gtk_widget_is_focus (folder_view)) {
2894                 TnyFolderStore *src_folder;
2895                 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2896
2897                 /* Clean folder on header view before moving it */
2898                 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2899
2900                 if (TNY_IS_FOLDER (src_folder)) {
2901                         mail_op =
2902                                 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2903                                                                                G_OBJECT(win),
2904                                                                                modest_ui_actions_move_folder_error_handler,
2905                                                                                NULL);
2906                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2907
2908                         modest_mail_operation_xfer_folder (mail_op,
2909                                                            TNY_FOLDER (src_folder),
2910                                                            folder_store,
2911                                                            TRUE);
2912                         /* Unref mail operation */
2913                         g_object_unref (G_OBJECT (mail_op));
2914                 }
2915
2916                 /* Frees */
2917                 g_object_unref (G_OBJECT (src_folder));
2918         } else {
2919                 if (gtk_widget_is_focus (header_view)) {
2920                         TnyList *headers;
2921                         gint response;
2922
2923                         headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2924
2925                         /* Ask for user confirmation */
2926                         response = msgs_move_to_confirmation (GTK_WINDOW (win),
2927                                                               TNY_FOLDER (folder_store),
2928                                                               headers);
2929
2930                         /* Transfer messages */
2931                         if (response == GTK_RESPONSE_OK) {
2932                                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2933                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2934                                                                  mail_op);
2935
2936                                 modest_mail_operation_xfer_msgs (mail_op,
2937                                                                  headers,
2938                                                                  TNY_FOLDER (folder_store),
2939                                                                  TRUE,
2940                                                                  NULL,
2941                                                                  NULL);
2942
2943                                 g_object_unref (G_OBJECT (mail_op));
2944                         }
2945                         g_object_unref (headers);
2946                 }
2947         }
2948  end:
2949         if (folder_store != NULL)
2950                 g_object_unref (folder_store);
2951         gtk_widget_destroy (dialog);
2952 }
2953
2954
2955 /*
2956  * UI handler for the "Move to" action when invoked from the
2957  * ModestMsgViewWindow
2958  */
2959 static void
2960 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2961                                               ModestMsgViewWindow *win)
2962 {
2963         GtkWidget *dialog, *folder_view, *tree_view = NULL;
2964         gint result;
2965         ModestMainWindow *main_window;
2966         TnyHeader *header;
2967         TnyList *headers;
2968
2969         /* Get the folder view */
2970         main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2971         if (main_window)
2972                 folder_view = modest_main_window_get_child_widget (main_window,
2973                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
2974         else
2975                 folder_view = NULL;
2976
2977         /* Create and run the dialog */
2978         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2979         result = gtk_dialog_run (GTK_DIALOG(dialog));
2980         g_object_ref (tree_view);
2981
2982         if (result == GTK_RESPONSE_ACCEPT) {
2983                 TnyFolderStore *folder_store;
2984                 gint response;
2985
2986                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2987
2988                 /* Create header list */
2989                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2990
2991                 headers = tny_simple_list_new ();
2992                 tny_list_prepend (headers, G_OBJECT (header));
2993                 g_object_unref (header);
2994
2995                 /* Ask user for confirmation. MSG-NOT404 */
2996                 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2997                                                       TNY_FOLDER (folder_store),
2998                                                       headers);
2999
3000                 /* Transfer current msg */
3001                 if (response == GTK_RESPONSE_OK) {
3002                         ModestMailOperation *mail_op;
3003
3004                         /* Create mail op */
3005                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
3006                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3007                                                          mail_op);
3008
3009                         /* Transfer messages */
3010                         modest_mail_operation_xfer_msgs (mail_op,
3011                                                          headers,
3012                                                          TNY_FOLDER (folder_store),
3013                                                          TRUE,
3014                                                          transfer_msgs_from_viewer_cb,
3015                                                          NULL);
3016                         g_object_unref (G_OBJECT (mail_op));
3017                 }
3018                 g_object_unref (headers);
3019                 g_object_unref (folder_store);
3020         }
3021         gtk_widget_destroy (dialog);
3022 }
3023
3024 void
3025 modest_ui_actions_on_move_to (GtkAction *action,
3026                               ModestWindow *win)
3027 {
3028         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3029                           MODEST_IS_MSG_VIEW_WINDOW (win));
3030
3031         if (MODEST_IS_MAIN_WINDOW (win))
3032                 modest_ui_actions_on_main_window_move_to (action,
3033                                                           MODEST_MAIN_WINDOW (win));
3034         else
3035                 modest_ui_actions_on_msg_view_window_move_to (action,
3036                                                               MODEST_MSG_VIEW_WINDOW (win));
3037 }
3038
3039 /*
3040  * Calls #HeadersFunc for each header already selected in the main
3041  * window or the message currently being shown in the msg view window
3042  */
3043 static void
3044 do_headers_action (ModestWindow *win,
3045                    HeadersFunc func,
3046                    gpointer user_data)
3047 {
3048         TnyList *headers_list;
3049         TnyIterator *iter;
3050         TnyHeader *header;
3051         TnyFolder *folder;
3052
3053         /* Get headers */
3054         headers_list = get_selected_headers (win);
3055         if (!headers_list)
3056                 return;
3057
3058         /* Get the folder */
3059         iter = tny_list_create_iterator (headers_list);
3060         header = TNY_HEADER (tny_iterator_get_current (iter));
3061         folder = tny_header_get_folder (header);
3062         g_object_unref (header);
3063
3064         /* Call the function for each header */
3065         while (!tny_iterator_is_done (iter)) {
3066                 header = TNY_HEADER (tny_iterator_get_current (iter));
3067                 func (header, win, user_data);
3068                 g_object_unref (header);
3069                 tny_iterator_next (iter);
3070         }
3071
3072         /* Trick: do a poke status in order to speed up the signaling
3073            of observers */
3074         tny_folder_poke_status (folder);
3075
3076         /* Frees */
3077         g_object_unref (folder);
3078         g_object_unref (iter);
3079         g_object_unref (headers_list);
3080 }
3081
3082 void
3083 modest_ui_actions_view_attachment (GtkAction *action,
3084                                    ModestWindow *window)
3085 {
3086         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3087                 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3088         } else {
3089                 /* not supported window for this action */
3090                 g_return_if_reached ();
3091         }
3092 }
3093
3094 void
3095 modest_ui_actions_save_attachments (GtkAction *action,
3096                                     ModestWindow *window)
3097 {
3098         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3099                 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3100         } else {
3101                 /* not supported window for this action */
3102                 g_return_if_reached ();
3103         }
3104 }
3105
3106 void
3107 modest_ui_actions_remove_attachments (GtkAction *action,
3108                                       ModestWindow *window)
3109 {
3110         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3111                 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window));
3112         } else {
3113                 /* not supported window for this action */
3114                 g_return_if_reached ();
3115         }
3116 }
3117
3118 void
3119 modest_ui_actions_on_settings (GtkAction *action,
3120                                ModestWindow *win)
3121 {
3122         GtkWidget *dialog;
3123
3124         dialog = modest_platform_get_global_settings_dialog ();
3125         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3126         gtk_widget_show_all (dialog);
3127
3128         gtk_dialog_run (GTK_DIALOG (dialog));
3129
3130         gtk_widget_destroy (dialog);
3131 }
3132
3133 void
3134 modest_ui_actions_on_help (GtkAction *action,
3135                            ModestWindow *win)
3136 {
3137         const gchar *help_id = NULL;
3138
3139         if (MODEST_IS_MAIN_WINDOW (win)) {
3140                 const gchar *action_name;
3141                 action_name = gtk_action_get_name (action);
3142
3143                 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3144                     !strcmp (action_name, "HeaderViewCSMHelp")) {
3145                         GtkWidget *folder_view;
3146                         TnyFolderStore *folder_store;
3147                         /* Get selected folder */
3148                         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3149                                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
3150                         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3151
3152                         /* Switch help_id */
3153                         if (TNY_IS_FOLDER (folder_store)) {
3154                                 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
3155                                 case TNY_FOLDER_TYPE_NORMAL:
3156                                         help_id = "applications_email_userfolder";
3157                                         break;
3158                                 case TNY_FOLDER_TYPE_INBOX:
3159                                         help_id = "applications_email_inbox";
3160                                         break;
3161                                 case TNY_FOLDER_TYPE_OUTBOX:
3162                                         help_id = "applications_email_outbox";
3163                                         break;
3164                                 case TNY_FOLDER_TYPE_SENT:
3165                                         help_id = "applications_email_sent";
3166                                         break;
3167                                 case TNY_FOLDER_TYPE_DRAFTS:
3168                                         help_id = "applications_email_drafts";
3169                                         break;
3170                                 case TNY_FOLDER_TYPE_ARCHIVE:
3171                                         help_id = "applications_email_archive";
3172                                         break;
3173                                 default:
3174                                         help_id = NULL;
3175                                 }
3176                         }
3177                         g_object_unref (folder_store);
3178                 } else {
3179                         help_id = "applications_email_mainview";
3180                 }
3181         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3182                 help_id = "applications_email_viewer";
3183         } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3184                 help_id = "applications_email_editor";
3185
3186         modest_platform_show_help (GTK_WINDOW (win), help_id);
3187 }
3188
3189 void
3190 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3191                                             ModestWindow *window)
3192 {
3193         ModestMailOperation *mail_op;
3194         TnyList *headers;
3195
3196         /* Get headers */
3197         headers = get_selected_headers (window);
3198         if (!headers)
3199                 return;
3200
3201         /* Create mail operation */
3202         mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3203                                                                  G_OBJECT (window),
3204                                                                  modest_ui_actions_get_msgs_full_error_handler,
3205                                                                  NULL);
3206         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3207         modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3208
3209         /* Frees */
3210         g_object_unref (headers);
3211         g_object_unref (mail_op);
3212 }
3213
3214 void
3215 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3216                                           ModestWindow *window)
3217 {
3218         g_return_if_fail (MODEST_IS_WINDOW (window));
3219
3220         /* Update dimmed */
3221         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3222 }
3223
3224 void
3225 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3226                                           ModestWindow *window)
3227 {
3228         g_return_if_fail (MODEST_IS_WINDOW (window));
3229
3230         /* Update dimmed */
3231         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3232 }
3233
3234 void
3235 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3236                                           ModestWindow *window)
3237 {
3238         g_return_if_fail (MODEST_IS_WINDOW (window));
3239
3240         /* Update dimmed */
3241         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3242 }
3243
3244 void
3245 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3246                                           ModestWindow *window)
3247 {
3248         g_return_if_fail (MODEST_IS_WINDOW (window));
3249
3250         /* Update dimmed */
3251         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3252 }
3253
3254 void
3255 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3256                                           ModestWindow *window)
3257 {
3258         g_return_if_fail (MODEST_IS_WINDOW (window));
3259
3260         /* Update dimmed */
3261         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3262 }
3263
3264 void
3265 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3266                                                  ModestWindow *window)
3267 {
3268         g_return_if_fail (MODEST_IS_WINDOW (window));
3269
3270         /* Update dimmed */
3271         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3272 }
3273
3274 void
3275 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3276                                                      ModestWindow *window)
3277 {
3278         g_return_if_fail (MODEST_IS_WINDOW (window));
3279
3280         /* Update dimmed */
3281         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3282 }
3283
3284 void
3285 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3286                                                      ModestWindow *window)
3287 {
3288         g_return_if_fail (MODEST_IS_WINDOW (window));
3289
3290         /* Update dimmed */
3291         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3292 }
3293
3294 void
3295 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3296 {
3297         g_return_if_fail (MODEST_IS_WINDOW (window));
3298
3299         /* Update dimmed */
3300         modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3301 }
3302
3303 void
3304 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3305 {
3306         g_return_if_fail (MODEST_IS_WINDOW (window));
3307
3308         modest_platform_show_search_messages (GTK_WINDOW (window));
3309 }
3310
3311 void
3312 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3313 {
3314         g_return_if_fail (MODEST_IS_WINDOW (win));
3315         modest_platform_show_addressbook (GTK_WINDOW (win));
3316 }
3317
3318
3319 void
3320 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3321                                           ModestWindow *window)
3322 {
3323         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3324
3325         modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3326 }
3327
3328 static void
3329 _on_send_receive_progress_changed (ModestMailOperation  *mail_op,
3330                                    ModestMailOperationState *state,
3331                                    gpointer user_data)
3332 {
3333         g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3334
3335         /* Set send/receive operation finished */
3336         if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3337                 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));
3338
3339 }
3340
3341