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