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         ModestEmailClipboard *clipboard = NULL;
2275
2276         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2277                 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2278         } if (MODEST_IS_MAIN_WINDOW (window)) {
2279                 /* Clear clipboard source */
2280                 clipboard = modest_runtime_get_email_clipboard ();
2281                 modest_email_clipboard_clear (clipboard);
2282         }
2283         else {
2284                 g_return_if_reached ();
2285         }
2286 }
2287
2288 void
2289 modest_ui_actions_on_paste (GtkAction *action,
2290                             ModestWindow *window)
2291 {
2292         GtkWidget *focused_widget;
2293         ModestMailOperation *mail_op = NULL;
2294
2295         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2296         if (GTK_IS_EDITABLE (focused_widget)) {
2297                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2298         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2299                 GtkTextBuffer *buffer;
2300                 GtkClipboard *clipboard;
2301
2302                 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2303                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2304                 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2305         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2306                 ModestEmailClipboard *clipboard = NULL;
2307                 TnyFolder *src_folder = NULL;
2308                 TnyFolderStore *folder_store = NULL;
2309                 TnyList *data = NULL;
2310                 gboolean delete = FALSE;
2311
2312                 /* Check clipboard source */
2313                 clipboard = modest_runtime_get_email_clipboard ();
2314                 if (modest_email_clipboard_cleared (clipboard))
2315                         return;
2316
2317                 /* Get elements to paste */
2318                 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2319
2320                 /* Create a new mail operation */
2321                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2322                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2323                                                  mail_op);
2324
2325                 /* Get destination folder */
2326                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2327
2328                 /* transfer messages  */
2329                 if (data != NULL) {
2330                         modest_mail_operation_xfer_msgs (mail_op,
2331                                                          data,
2332                                                          TNY_FOLDER (folder_store),
2333                                                          delete,
2334                                                          NULL,
2335                                                          NULL);
2336
2337                 } else if (src_folder != NULL) {
2338                         modest_mail_operation_xfer_folder (mail_op,
2339                                                            src_folder,
2340                                                            folder_store,
2341                                                            delete);
2342                 }
2343
2344                 /* Free */
2345                 if (data != NULL)
2346                         g_object_unref (data);
2347                 if (src_folder != NULL)
2348                         g_object_unref (src_folder);
2349                 if (folder_store != NULL)
2350                         g_object_unref (folder_store);
2351         }
2352 }
2353
2354 void
2355 modest_ui_actions_on_select_all (GtkAction *action,
2356                                  ModestWindow *window)
2357 {
2358         GtkWidget *focused_widget;
2359
2360         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2361         if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2362                 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2363         } else if (GTK_IS_LABEL (focused_widget)) {
2364                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2365         } else if (GTK_IS_EDITABLE (focused_widget)) {
2366                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2367         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2368                 GtkTextBuffer *buffer;
2369                 GtkTextIter start, end;
2370
2371                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2372                 gtk_text_buffer_get_start_iter (buffer, &start);
2373                 gtk_text_buffer_get_end_iter (buffer, &end);
2374                 gtk_text_buffer_select_range (buffer, &start, &end);
2375         } else if (GTK_IS_HTML (focused_widget)) {
2376                 gtk_html_select_all (GTK_HTML (focused_widget));
2377         } else if (MODEST_IS_MAIN_WINDOW (window)) {
2378                 GtkWidget *header_view = focused_widget;
2379                 GtkTreeSelection *selection = NULL;
2380
2381                 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2382                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2383                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2384
2385                 /* Select all messages */
2386                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2387                 gtk_tree_selection_select_all (selection);
2388
2389                 /* Set focuse on header view */
2390                 gtk_widget_grab_focus (header_view);
2391         }
2392
2393 }
2394
2395 void
2396 modest_ui_actions_on_mark_as_read (GtkAction *action,
2397                                    ModestWindow *window)
2398 {
2399         g_return_if_fail (MODEST_IS_WINDOW(window));
2400
2401         /* Mark each header as read */
2402         do_headers_action (window, headers_action_mark_as_read, NULL);
2403 }
2404
2405 void
2406 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2407                                      ModestWindow *window)
2408 {
2409         g_return_if_fail (MODEST_IS_WINDOW(window));
2410
2411         /* Mark each header as read */
2412         do_headers_action (window, headers_action_mark_as_unread, NULL);
2413 }
2414
2415 void
2416 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2417                                   GtkRadioAction *selected,
2418                                   ModestWindow *window)
2419 {
2420         gint value;
2421
2422         value = gtk_radio_action_get_current_value (selected);
2423         if (MODEST_IS_WINDOW (window)) {
2424                 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2425         }
2426 }
2427
2428 void     modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2429                                                         GtkRadioAction *selected,
2430                                                         ModestWindow *window)
2431 {
2432         TnyHeaderFlags flags;
2433         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2434
2435         flags = gtk_radio_action_get_current_value (selected);
2436         modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2437 }
2438
2439 void     modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2440                                                            GtkRadioAction *selected,
2441                                                            ModestWindow *window)
2442 {
2443         gint file_format;
2444
2445         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2446
2447         file_format = gtk_radio_action_get_current_value (selected);
2448         modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2449 }
2450
2451
2452 void
2453 modest_ui_actions_on_zoom_plus (GtkAction *action,
2454                                 ModestWindow *window)
2455 {
2456         g_return_if_fail (MODEST_IS_WINDOW (window));
2457
2458         modest_window_zoom_plus (MODEST_WINDOW (window));
2459 }
2460
2461 void
2462 modest_ui_actions_on_zoom_minus (GtkAction *action,
2463                                  ModestWindow *window)
2464 {
2465         g_return_if_fail (MODEST_IS_WINDOW (window));
2466
2467         modest_window_zoom_minus (MODEST_WINDOW (window));
2468 }
2469
2470 void
2471 modest_ui_actions_on_toggle_fullscreen    (GtkToggleAction *toggle,
2472                                            ModestWindow *window)
2473 {
2474         ModestWindowMgr *mgr;
2475         gboolean fullscreen, active;
2476         g_return_if_fail (MODEST_IS_WINDOW (window));
2477
2478         mgr = modest_runtime_get_window_mgr ();
2479
2480         active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2481         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2482
2483         if (active != fullscreen) {
2484                 modest_window_mgr_set_fullscreen_mode (mgr, active);
2485                 gtk_window_present (GTK_WINDOW (window));
2486         }
2487 }
2488
2489 void
2490 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2491                                         ModestWindow *window)
2492 {
2493         ModestWindowMgr *mgr;
2494         gboolean fullscreen;
2495
2496         g_return_if_fail (MODEST_IS_WINDOW (window));
2497
2498         mgr = modest_runtime_get_window_mgr ();
2499         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2500         modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2501
2502         gtk_window_present (GTK_WINDOW (window));
2503 }
2504
2505 /*
2506  * Used by modest_ui_actions_on_details to call do_headers_action
2507  */
2508 static void
2509 headers_action_show_details (TnyHeader *header,
2510                              ModestWindow *window,
2511                              gpointer user_data)
2512
2513 {
2514         GtkWidget *dialog;
2515
2516         /* Create dialog */
2517         dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2518
2519         /* Run dialog */
2520         gtk_widget_show_all (dialog);
2521         gtk_dialog_run (GTK_DIALOG (dialog));
2522
2523         gtk_widget_destroy (dialog);
2524 }
2525
2526 /*
2527  * Show the folder details in a ModestDetailsDialog widget
2528  */
2529 static void
2530 show_folder_details (TnyFolder *folder,
2531                      GtkWindow *window)
2532 {
2533         GtkWidget *dialog;
2534
2535         /* Create dialog */
2536         dialog = modest_details_dialog_new_with_folder (window, folder);
2537
2538         /* Run dialog */
2539         gtk_widget_show_all (dialog);
2540         gtk_dialog_run (GTK_DIALOG (dialog));
2541
2542         gtk_widget_destroy (dialog);
2543 }
2544
2545 /*
2546  * Show the header details in a ModestDetailsDialog widget
2547  */
2548 void
2549 modest_ui_actions_on_details (GtkAction *action,
2550                               ModestWindow *win)
2551 {
2552         TnyList * headers_list;
2553         TnyIterator *iter;
2554         TnyHeader *header;
2555
2556         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2557                 TnyMsg *msg;
2558
2559                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2560                 if (!msg)
2561                         return;
2562                 g_object_unref (msg);
2563
2564                 headers_list = get_selected_headers (win);
2565                 if (!headers_list)
2566                         return;
2567
2568                 iter = tny_list_create_iterator (headers_list);
2569
2570                 header = TNY_HEADER (tny_iterator_get_current (iter));
2571                 headers_action_show_details (header, win, NULL);
2572                 g_object_unref (header);
2573
2574                 g_object_unref (iter);
2575                 g_object_unref (headers_list);
2576
2577         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2578                 GtkWidget *folder_view, *header_view;
2579
2580                 /* Check which widget has the focus */
2581                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2582                                                                     MODEST_WIDGET_TYPE_FOLDER_VIEW);
2583                 if (gtk_widget_is_focus (folder_view)) {
2584                         TnyFolderStore *folder_store
2585                                 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2586                         if (!folder_store) {
2587                                 g_warning ("%s: No item was selected.\n", __FUNCTION__);
2588                                 return;
2589                         }
2590                         /* Show only when it's a folder */
2591                         /* This function should not be called for account items,
2592                          * because we dim the menu item for them. */
2593                         if (TNY_IS_FOLDER (folder_store)) {
2594                                 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
2595                         }
2596
2597                         g_object_unref (folder_store);
2598
2599                 } else {
2600                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2601                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2602                         /* Show details of each header */
2603                         do_headers_action (win, headers_action_show_details, header_view);
2604                 }
2605         }
2606 }
2607
2608 void
2609 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2610                                      ModestMsgEditWindow *window)
2611 {
2612         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2613
2614         modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2615 }
2616
2617 void
2618 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2619                                       ModestMsgEditWindow *window)
2620 {
2621         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2622
2623         modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2624 }
2625
2626 void
2627 modest_ui_actions_toggle_folders_view (GtkAction *action,
2628                                        ModestMainWindow *main_window)
2629 {
2630         ModestConf *conf;
2631
2632         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2633
2634         conf = modest_runtime_get_conf ();
2635
2636         if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2637                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2638         else
2639                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2640 }
2641
2642 void
2643 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2644                                      ModestWindow *window)
2645 {
2646         gboolean active, fullscreen = FALSE;
2647         ModestWindowMgr *mgr;
2648
2649         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2650
2651         /* Check if we want to toggle the toolbar vuew in fullscreen
2652            or normal mode */
2653         if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2654                      "ViewShowToolbarFullScreen")) {
2655                 fullscreen = TRUE;
2656         }
2657
2658         /* Toggle toolbar */
2659         mgr = modest_runtime_get_window_mgr ();
2660         modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2661 }
2662
2663 void
2664 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2665                                            ModestMsgEditWindow *window)
2666 {
2667         modest_msg_edit_window_select_font (window);
2668 }
2669
2670 void
2671 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2672                                                   const gchar *display_name,
2673                                                   GtkWindow *window)
2674 {
2675         /* Do not change the application name if the widget has not
2676            the focus. This callback could be called even if the folder
2677            view has not the focus, because the handled signal could be
2678            emitted when the folder view is redrawn */
2679         if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2680                 if (display_name)
2681                         gtk_window_set_title (window, display_name);
2682                 else
2683                         gtk_window_set_title (window, " ");
2684         }
2685 }
2686
2687 void
2688 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2689 {
2690         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2691         modest_msg_edit_window_select_contacts (window);
2692 }
2693
2694 void
2695 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2696 {
2697         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2698         modest_msg_edit_window_check_names (window);
2699 }
2700
2701
2702 static GtkWidget*
2703 create_move_to_dialog (ModestWindow *win,
2704                        GtkWidget *folder_view,
2705                        GtkWidget **tree_view)
2706 {
2707         GtkWidget *dialog, *scroll;
2708
2709         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2710                                               GTK_WINDOW (win),
2711                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2712                                               GTK_STOCK_OK,
2713                                               GTK_RESPONSE_ACCEPT,
2714                                               GTK_STOCK_CANCEL,
2715                                               GTK_RESPONSE_REJECT,
2716                                               NULL);
2717
2718         /* Create scrolled window */
2719         scroll = gtk_scrolled_window_new (NULL, NULL);
2720         gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scroll),
2721                                          GTK_POLICY_AUTOMATIC,
2722                                          GTK_POLICY_AUTOMATIC);
2723
2724         /* Create folder view */
2725         *tree_view = modest_platform_create_folder_view (NULL);
2726
2727         /* It could happen that we're trying to move a message from a
2728            window (msg window for example) after the main window was
2729            closed, so we can not just get the model of the folder
2730            view */
2731         if (MODEST_IS_FOLDER_VIEW (folder_view))
2732                 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2733                                          gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2734         else
2735                 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
2736                                                  TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
2737
2738         gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2739
2740         /* Add scroll to dialog */
2741         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2742                             scroll, FALSE, FALSE, 0);
2743
2744         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2745
2746         /* Select INBOX or local account */
2747         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (*tree_view));
2748
2749         return dialog;
2750 }
2751
2752 /*
2753  * Returns TRUE if at least one of the headers of the list belongs to
2754  * a message that has been fully retrieved.
2755  */
2756 static gboolean
2757 has_retrieved_msgs (TnyList *list)
2758 {
2759         TnyIterator *iter;
2760         gboolean found = FALSE;
2761
2762         iter = tny_list_create_iterator (list);
2763         while (tny_iterator_is_done (iter) && !found) {
2764                 TnyHeader *header;
2765                 TnyHeaderFlags flags;
2766
2767                 header = TNY_HEADER (tny_iterator_get_current (iter));
2768                 flags = tny_header_get_flags (header);
2769                 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2770                         found = TRUE;
2771
2772                 if (!found)
2773                         tny_iterator_next (iter);
2774         }
2775         g_object_unref (iter);
2776
2777         return found;
2778 }
2779
2780 /*
2781  * Shows a confirmation dialog to the user when we're moving messages
2782  * from a remote server to the local storage. Returns the dialog
2783  * response. If it's other kind of movement the it always returns
2784  * GTK_RESPONSE_OK
2785  */
2786 static gint
2787 msgs_move_to_confirmation (GtkWindow *win,
2788                            TnyFolder *dest_folder,
2789                            TnyList *headers)
2790 {
2791         gint response = GTK_RESPONSE_OK;
2792
2793         /* If the destination is a local folder */
2794         if (modest_tny_folder_is_local_folder (dest_folder)) {
2795                 TnyFolder *src_folder;
2796                 TnyIterator *iter;
2797                 TnyHeader *header;
2798
2799                 /* Get source folder */
2800                 iter = tny_list_create_iterator (headers);
2801                 header = TNY_HEADER (tny_iterator_get_current (iter));
2802                 src_folder = tny_header_get_folder (header);
2803                 g_object_unref (header);
2804                 g_object_unref (iter);
2805
2806                 /* if no src_folder, message may be an attahcment */
2807                 if (src_folder == NULL)
2808                         return GTK_RESPONSE_CANCEL;
2809
2810                 /* If the source is a remote folder */
2811                 if (!modest_tny_folder_is_local_folder (src_folder)) {
2812                         const gchar *message;
2813
2814                         if (has_retrieved_msgs (headers))
2815                                 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
2816                                                     tny_list_get_length (headers));
2817                         else
2818                                 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
2819                                                     tny_list_get_length (headers));
2820
2821                         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2822                                                                             (const gchar *) message);
2823                 }
2824                 g_object_unref (src_folder);
2825         }
2826         return response;
2827 }
2828
2829
2830 static void
2831 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2832 {
2833         ModestMsgViewWindow *self = NULL;
2834
2835         g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2836         self = MODEST_MSG_VIEW_WINDOW (object);
2837
2838         /* If there are not more messages don't do anything. The
2839            viewer will show the same message */
2840         if (!modest_msg_view_window_select_first_message (self))
2841             return;
2842 }
2843
2844 void
2845 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
2846                                              gpointer user_data)
2847 {
2848         GObject *win = modest_mail_operation_get_source (mail_op);
2849
2850         /* TODO: show error message */
2851         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2852                                                 _("mail_in_ui_folder_move_target_error"));
2853         g_object_unref (win);
2854 }
2855
2856 /*
2857  * UI handler for the "Move to" action when invoked from the
2858  * ModestMainWindow
2859  */
2860 static void
2861 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2862                                           ModestMainWindow *win)
2863 {
2864         GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2865         GtkWidget *header_view = NULL;
2866         gint result;
2867         TnyFolderStore *folder_store = NULL;
2868         ModestMailOperation *mail_op = NULL;
2869
2870         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2871
2872         /* Get the folder view */
2873         folder_view = modest_main_window_get_child_widget (win,
2874                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2875
2876         /* Get header view */
2877         header_view = modest_main_window_get_child_widget (win,
2878                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2879
2880         /* Create and run the dialog */
2881         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2882         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
2883         result = gtk_dialog_run (GTK_DIALOG(dialog));
2884         g_object_ref (tree_view);
2885
2886         /* We do this to save an indentation level ;-) */
2887         if (result != GTK_RESPONSE_ACCEPT)
2888                 goto end;
2889
2890         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2891
2892         if (TNY_IS_ACCOUNT (folder_store))
2893                 goto end;
2894
2895         /* Get folder or messages to transfer */
2896         if (gtk_widget_is_focus (folder_view)) {
2897                 TnyFolderStore *src_folder;
2898                 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2899
2900                 /* Clean folder on header view before moving it */
2901                 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2902
2903                 if (TNY_IS_FOLDER (src_folder)) {
2904                         mail_op =
2905                                 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2906                                                                                G_OBJECT(win),
2907                                                                                modest_ui_actions_move_folder_error_handler,
2908                                                                                NULL);
2909                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2910
2911                         modest_mail_operation_xfer_folder (mail_op,
2912                                                            TNY_FOLDER (src_folder),
2913                                                            folder_store,
2914                                                            TRUE);
2915                         /* Unref mail operation */
2916                         g_object_unref (G_OBJECT (mail_op));
2917                 }
2918
2919                 /* Frees */
2920                 g_object_unref (G_OBJECT (src_folder));
2921         } else {
2922                 if (gtk_widget_is_focus (header_view)) {
2923                         TnyList *headers;
2924                         gint response;
2925
2926                         headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2927
2928                         /* Ask for user confirmation */
2929                         response = msgs_move_to_confirmation (GTK_WINDOW (win),
2930                                                               TNY_FOLDER (folder_store),
2931                                                               headers);
2932
2933                         /* Transfer messages */
2934                         if (response == GTK_RESPONSE_OK) {
2935                                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2936                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2937                                                                  mail_op);
2938
2939                                 modest_mail_operation_xfer_msgs (mail_op,
2940                                                                  headers,
2941                                                                  TNY_FOLDER (folder_store),
2942                                                                  TRUE,
2943                                                                  NULL,
2944                                                                  NULL);
2945
2946                                 g_object_unref (G_OBJECT (mail_op));
2947                         }
2948                         g_object_unref (headers);
2949                 }
2950         }
2951  end:
2952         if (folder_store != NULL)
2953                 g_object_unref (folder_store);
2954         gtk_widget_destroy (dialog);
2955 }
2956
2957
2958 /*
2959  * UI handler for the "Move to" action when invoked from the
2960  * ModestMsgViewWindow
2961  */
2962 static void
2963 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2964                                               ModestMsgViewWindow *win)
2965 {
2966         GtkWidget *dialog, *folder_view, *tree_view = NULL;
2967         gint result;
2968         ModestMainWindow *main_window;
2969         TnyHeader *header;
2970         TnyList *headers;
2971
2972         /* Get the folder view */
2973         main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2974         if (main_window)
2975                 folder_view = modest_main_window_get_child_widget (main_window,
2976                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
2977         else
2978                 folder_view = NULL;
2979
2980         /* Create and run the dialog */
2981         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2982         result = gtk_dialog_run (GTK_DIALOG(dialog));
2983         g_object_ref (tree_view);
2984
2985         if (result == GTK_RESPONSE_ACCEPT) {
2986                 TnyFolderStore *folder_store;
2987                 gint response;
2988
2989                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2990
2991                 /* Create header list */
2992                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2993
2994                 headers = tny_simple_list_new ();
2995                 tny_list_prepend (headers, G_OBJECT (header));
2996                 g_object_unref (header);
2997
2998                 /* Ask user for confirmation. MSG-NOT404 */
2999                 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3000                                                       TNY_FOLDER (folder_store),
3001                                                       headers);
3002
3003                 /* Transfer current msg */
3004                 if (response == GTK_RESPONSE_OK) {
3005                         ModestMailOperation *mail_op;
3006
3007                         /* Create mail op */
3008                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
3009                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3010                                                          mail_op);
3011
3012                         /* Transfer messages */
3013                         modest_mail_operation_xfer_msgs (mail_op,
3014                                                          headers,
3015                                                          TNY_FOLDER (folder_store),
3016                                                          TRUE,
3017                                                          transfer_msgs_from_viewer_cb,
3018                                                          NULL);
3019                         g_object_unref (G_OBJECT (mail_op));
3020                 }
3021                 g_object_unref (headers);
3022                 g_object_unref (folder_store);
3023         }
3024         gtk_widget_destroy (dialog);
3025 }
3026
3027 void
3028 modest_ui_actions_on_move_to (GtkAction *action,
3029                               ModestWindow *win)
3030 {
3031         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3032                           MODEST_IS_MSG_VIEW_WINDOW (win));
3033
3034         if (MODEST_IS_MAIN_WINDOW (win))
3035                 modest_ui_actions_on_main_window_move_to (action,
3036                                                           MODEST_MAIN_WINDOW (win));
3037         else
3038                 modest_ui_actions_on_msg_view_window_move_to (action,
3039                                                               MODEST_MSG_VIEW_WINDOW (win));
3040 }
3041
3042 /*
3043  * Calls #HeadersFunc for each header already selected in the main
3044  * window or the message currently being shown in the msg view window
3045  */
3046 static void
3047 do_headers_action (ModestWindow *win,
3048                    HeadersFunc func,
3049                    gpointer user_data)
3050 {
3051         TnyList *headers_list;
3052         TnyIterator *iter;
3053         TnyHeader *header;
3054         TnyFolder *folder;
3055
3056         /* Get headers */
3057         headers_list = get_selected_headers (win);
3058         if (!headers_list)
3059                 return;
3060
3061         /* Get the folder */
3062         iter = tny_list_create_iterator (headers_list);
3063         header = TNY_HEADER (tny_iterator_get_current (iter));
3064         folder = tny_header_get_folder (header);
3065         g_object_unref (header);
3066
3067         /* Call the function for each header */
3068         while (!tny_iterator_is_done (iter)) {
3069                 header = TNY_HEADER (tny_iterator_get_current (iter));
3070                 func (header, win, user_data);
3071                 g_object_unref (header);
3072                 tny_iterator_next (iter);
3073         }
3074
3075         /* Trick: do a poke status in order to speed up the signaling
3076            of observers */
3077         tny_folder_poke_status (folder);
3078
3079         /* Frees */
3080         g_object_unref (folder);
3081         g_object_unref (iter);
3082         g_object_unref (headers_list);
3083 }
3084
3085 void
3086 modest_ui_actions_view_attachment (GtkAction *action,
3087                                    ModestWindow *window)
3088 {
3089         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3090                 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3091         } else {
3092                 /* not supported window for this action */
3093                 g_return_if_reached ();
3094         }
3095 }
3096
3097 void
3098 modest_ui_actions_save_attachments (GtkAction *action,
3099                                     ModestWindow *window)
3100 {
3101         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3102                 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3103         } else {
3104                 /* not supported window for this action */
3105                 g_return_if_reached ();
3106         }
3107 }
3108
3109 void
3110 modest_ui_actions_remove_attachments (GtkAction *action,
3111                                       ModestWindow *window)
3112 {
3113         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3114                 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window));
3115         } else {
3116                 /* not supported window for this action */
3117                 g_return_if_reached ();
3118         }
3119 }
3120
3121 void
3122 modest_ui_actions_on_settings (GtkAction *action,
3123                                ModestWindow *win)
3124 {
3125         GtkWidget *dialog;
3126
3127         dialog = modest_platform_get_global_settings_dialog ();
3128         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3129         gtk_widget_show_all (dialog);
3130
3131         gtk_dialog_run (GTK_DIALOG (dialog));
3132
3133         gtk_widget_destroy (dialog);
3134 }
3135
3136 void
3137 modest_ui_actions_on_help (GtkAction *action,
3138                            ModestWindow *win)
3139 {
3140         const gchar *help_id = NULL;
3141
3142         if (MODEST_IS_MAIN_WINDOW (win)) {
3143                 const gchar *action_name;
3144                 action_name = gtk_action_get_name (action);
3145
3146                 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3147                     !strcmp (action_name, "HeaderViewCSMHelp")) {
3148                         GtkWidget *folder_view;
3149                         TnyFolderStore *folder_store;
3150                         /* Get selected folder */
3151                         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3152                                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
3153                         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3154
3155                         /* Switch help_id */
3156                         if (TNY_IS_FOLDER (folder_store)) {
3157                                 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
3158                                 case TNY_FOLDER_TYPE_NORMAL:
3159                                         help_id = "applications_email_userfolder";
3160                                         break;
3161                                 case TNY_FOLDER_TYPE_INBOX:
3162                                         help_id = "applications_email_inbox";
3163                                         break;
3164                                 case TNY_FOLDER_TYPE_OUTBOX:
3165                                         help_id = "applications_email_outbox";
3166                                         break;
3167                                 case TNY_FOLDER_TYPE_SENT:
3168                                         help_id = "applications_email_sent";
3169                                         break;
3170                                 case TNY_FOLDER_TYPE_DRAFTS:
3171                                         help_id = "applications_email_drafts";
3172                                         break;
3173                                 case TNY_FOLDER_TYPE_ARCHIVE:
3174                                         help_id = "applications_email_archive";
3175                                         break;
3176                                 default:
3177                                         help_id = NULL;
3178                                 }
3179                         }
3180                         g_object_unref (folder_store);
3181                 } else {
3182                         help_id = "applications_email_mainview";
3183                 }
3184         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3185                 help_id = "applications_email_viewer";
3186         } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3187                 help_id = "applications_email_editor";
3188
3189         modest_platform_show_help (GTK_WINDOW (win), help_id);
3190 }
3191
3192 void
3193 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3194                                             ModestWindow *window)
3195 {
3196         ModestMailOperation *mail_op;
3197         TnyList *headers;
3198
3199         /* Get headers */
3200         headers = get_selected_headers (window);
3201         if (!headers)
3202                 return;
3203
3204         /* Create mail operation */
3205         mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3206                                                                  G_OBJECT (window),
3207                                                                  modest_ui_actions_get_msgs_full_error_handler,
3208                                                                  NULL);
3209         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3210         modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3211
3212         /* Frees */
3213         g_object_unref (headers);
3214         g_object_unref (mail_op);
3215 }
3216
3217 void
3218 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3219                                           ModestWindow *window)
3220 {
3221         g_return_if_fail (MODEST_IS_WINDOW (window));
3222
3223         /* Update dimmed */
3224         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3225 }
3226
3227 void
3228 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3229                                           ModestWindow *window)
3230 {
3231         g_return_if_fail (MODEST_IS_WINDOW (window));
3232
3233         /* Update dimmed */
3234         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3235 }
3236
3237 void
3238 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3239                                           ModestWindow *window)
3240 {
3241         g_return_if_fail (MODEST_IS_WINDOW (window));
3242
3243         /* Update dimmed */
3244         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3245 }
3246
3247 void
3248 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3249                                           ModestWindow *window)
3250 {
3251         g_return_if_fail (MODEST_IS_WINDOW (window));
3252
3253         /* Update dimmed */
3254         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3255 }
3256
3257 void
3258 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3259                                           ModestWindow *window)
3260 {
3261         g_return_if_fail (MODEST_IS_WINDOW (window));
3262
3263         /* Update dimmed */
3264         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3265 }
3266
3267 void
3268 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3269                                                  ModestWindow *window)
3270 {
3271         g_return_if_fail (MODEST_IS_WINDOW (window));
3272
3273         /* Update dimmed */
3274         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3275 }
3276
3277 void
3278 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3279                                                      ModestWindow *window)
3280 {
3281         g_return_if_fail (MODEST_IS_WINDOW (window));
3282
3283         /* Update dimmed */
3284         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3285 }
3286
3287 void
3288 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3289                                                      ModestWindow *window)
3290 {
3291         g_return_if_fail (MODEST_IS_WINDOW (window));
3292
3293         /* Update dimmed */
3294         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3295 }
3296
3297 void
3298 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3299 {
3300         g_return_if_fail (MODEST_IS_WINDOW (window));
3301
3302         /* Update dimmed */
3303         modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3304 }
3305
3306 void
3307 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3308 {
3309         g_return_if_fail (MODEST_IS_WINDOW (window));
3310
3311         modest_platform_show_search_messages (GTK_WINDOW (window));
3312 }
3313
3314 void
3315 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3316 {
3317         g_return_if_fail (MODEST_IS_WINDOW (win));
3318         modest_platform_show_addressbook (GTK_WINDOW (win));
3319 }
3320
3321
3322 void
3323 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3324                                           ModestWindow *window)
3325 {
3326         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3327
3328         modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3329 }
3330
3331 static void
3332 _on_send_receive_progress_changed (ModestMailOperation  *mail_op,
3333                                    ModestMailOperationState *state,
3334                                    gpointer user_data)
3335 {
3336         g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3337
3338         /* Set send/receive operation finished */
3339         if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3340                 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));
3341
3342 }
3343
3344