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