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