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 #include "modest-protocol-info.h"
  45 #include "modest-tny-platform-factory.h"
  46 #include "modest-platform.h"
  47 #include <tny-mime-part.h>
  48 #include <tny-camel-folder.h>
  49 #include <tny-camel-imap-folder.h>
  50 #include <tny-camel-pop-folder.h>
  51
  52 #ifdef MODEST_PLATFORM_MAEMO
  53 #include "maemo/modest-osso-state-saving.h"
  54 #include "maemo/modest-maemo-utils.h"
  55 #include "maemo/modest-hildon-includes.h"
  56 #endif /* MODEST_PLATFORM_MAEMO */
  57
  58 #include "widgets/modest-ui-constants.h"
  59 #include <widgets/modest-main-window.h>
  60 #include <widgets/modest-msg-view-window.h>
  61 #include <widgets/modest-account-view-window.h>
  62 #include <widgets/modest-details-dialog.h>
  63 #include <widgets/modest-attachments-view.h>
  64 #include "widgets/modest-folder-view.h"
  65 #include "widgets/modest-global-settings-dialog.h"
  66 #include "modest-connection-specific-smtp-window.h"
  67 #include "modest-account-mgr-helpers.h"
  68 #include "modest-mail-operation.h"
  69 #include "modest-text-utils.h"
  70
  71 #ifdef MODEST_HAVE_EASYSETUP
  72 #include "easysetup/modest-easysetup-wizard.h"
  73 #endif /* MODEST_HAVE_EASYSETUP */
  74
  75 #include <modest-widget-memory.h>
  76 #include <tny-error.h>
  77 #include <tny-simple-list.h>
  78 #include <tny-msg-view.h>
  79 #include <tny-device.h>
  80 #include <tny-merge-folder.h>
  81
  82 #include <gtkhtml/gtkhtml.h>
  83
  84 typedef struct _GetMsgAsyncHelper {
  85         ModestWindow *window;
  86         ModestMailOperation *mail_op;
  87         TnyIterator *iter;
  88         guint num_ops;
  89         GFunc func;
  90         gpointer user_data;
  91 } GetMsgAsyncHelper;
  92
  93 typedef enum _ReplyForwardAction {
  94         ACTION_REPLY,
  95         ACTION_REPLY_TO_ALL,
  96         ACTION_FORWARD
  97 } ReplyForwardAction;
  98
  99 typedef struct _ReplyForwardHelper {
 100         guint reply_forward_type;
 101         ReplyForwardAction action;
 102         gchar *account_name;
 103         GtkWidget *parent_window;
 104 } ReplyForwardHelper;
 105
 106 typedef struct _MoveToHelper {
 107         GtkTreeRowReference *reference;
 108         GtkWidget *banner;
 109 } MoveToHelper;
 110
 111 typedef struct _PasteAsAttachmentHelper {
 112         ModestMsgEditWindow *window;
 113         GtkWidget *banner;
 114 } PasteAsAttachmentHelper;
 115
 116
 117 /*
 118  * The do_headers_action uses this kind of functions to perform some
 119  * action to each member of a list of headers
 120  */
 121 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
 122
 123 static void     do_headers_action     (ModestWindow *win,
 124                                        HeadersFunc func,
 125                                        gpointer user_data);
 126
 127 static void     open_msg_cb            (ModestMailOperation *mail_op,
 128                                         TnyHeader *header,
 129                                         gboolean canceled,
 130                                         TnyMsg *msg,
 131                                         GError *err,
 132                                         gpointer user_data);
 133
 134 static void     reply_forward_cb       (ModestMailOperation *mail_op,
 135                                         TnyHeader *header,
 136                                         gboolean canceled,
 137                                         TnyMsg *msg,
 138                                         GError *err,
 139                                         gpointer user_data);
 140
 141 static void     reply_forward          (ReplyForwardAction action, ModestWindow *win);
 142
 143 static void     folder_refreshed_cb    (ModestMailOperation *mail_op,
 144                                         TnyFolder *folder,
 145                                         gpointer user_data);
 146
 147 static void     on_send_receive_finished (ModestMailOperation  *mail_op,
 148                                           gpointer user_data);
 149
 150 static gint header_list_count_uncached_msgs (TnyList *header_list);
 151
 152 static gboolean connect_to_get_msg (ModestWindow *win,
 153                                     gint num_of_uncached_msgs,
 154                                     TnyAccount *account);
 155
 156 static gboolean remote_folder_is_pop (const TnyFolderStore *folder);
 157
 158 static gboolean msgs_already_deleted_from_server ( TnyList *headers,
 159                                                    const TnyFolderStore *src_folder);
 160
 161
 162 /*
 163  * This function checks whether a TnyFolderStore is a pop account
 164  */
 165 static gboolean
 166 remote_folder_is_pop (const TnyFolderStore *folder)
 167 {
 168         const gchar *proto = NULL;
 169         TnyAccount *account = NULL;
 170
 171         g_return_val_if_fail (TNY_IS_FOLDER_STORE(folder), FALSE);
 172
 173         if (TNY_IS_ACCOUNT (folder)) {
 174                 account = TNY_ACCOUNT(folder);
 175                 g_object_ref(account);
 176         } else if (TNY_IS_FOLDER (folder)) {
 177                 account = tny_folder_get_account(TNY_FOLDER(folder));
 178         }
 179
 180         if (!account && !TNY_IS_ACCOUNT(account)) {
 181                 g_warning ("%s: could not get account", __FUNCTION__);
 182                 return FALSE;
 183         }
 184
 185         proto = tny_account_get_proto(account);
 186         g_object_unref (account);
 187
 188         return proto &&
 189           (modest_protocol_info_get_transport_store_protocol (proto) == MODEST_PROTOCOL_STORE_POP);
 190 }
 191
 192 /*
 193  * This functions checks whether if a list of messages are already
 194  * deleted from the server: that is, if the server is a POP account
 195  * and all messages are already cached.
 196  */
 197 static gboolean
 198 msgs_already_deleted_from_server (TnyList *headers, const TnyFolderStore *src_folder)
 199 {
 200         g_return_val_if_fail (TNY_IS_FOLDER_STORE(src_folder), FALSE);
 201         g_return_val_if_fail (TNY_IS_LIST(headers), FALSE);
 202
 203         gboolean src_is_pop = remote_folder_is_pop (src_folder);
 204         gint uncached_msgs = header_list_count_uncached_msgs (headers);
 205
 206         return (src_is_pop && !uncached_msgs);
 207 }
 208
 209
 210 /* FIXME: this should be merged with the similar code in modest-account-view-window */
 211 /* Show the account creation wizard dialog.
 212  * returns: TRUE if an account was created. FALSE if the user cancelled.
 213  */
 214 gboolean
 215 modest_ui_actions_run_account_setup_wizard (ModestWindow *win)
 216 {
 217         gboolean result = FALSE;
 218         GtkWindow *dialog, *wizard;
 219         gint dialog_response;
 220
 221         /* Show the easy-setup wizard: */
 222         dialog = modest_window_mgr_get_modal (modest_runtime_get_window_mgr());
 223         if (dialog && MODEST_IS_EASYSETUP_WIZARD_DIALOG(dialog)) {
 224                 /* old wizard is active already;
 225                  */
 226                 gtk_window_present (GTK_WINDOW(dialog));
 227                 return FALSE;
 228         }
 229
 230
 231         /* there is no such wizard yet */
 232         wizard = GTK_WINDOW (modest_easysetup_wizard_dialog_new ());
 233         modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), wizard);
 234
 235         /* always present a main window in the background
 236          * we do it here, so we cannot end up with two wizards (as this
 237          * function might be called in modest_window_mgr_get_main_window as well */
 238         if (!win)
 239                 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
 240                                                          TRUE);  /* create if not existent */
 241
 242         /* make sure the mainwindow is visible */
 243         gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
 244         gtk_widget_show_all (GTK_WIDGET(win));
 245         gtk_window_present (GTK_WINDOW(win));
 246
 247         dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
 248         gtk_widget_destroy (GTK_WIDGET (wizard));
 249         if (gtk_events_pending ())
 250                 gtk_main_iteration ();
 251
 252         if (dialog_response == GTK_RESPONSE_CANCEL) {
 253                 result = FALSE;
 254         } else {
 255                 /* Check whether an account was created: */
 256                 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
 257         }
 258
 259         return result;
 260 }
 261
 262
 263 void
 264 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
 265 {
 266         GtkWidget *about;
 267         const gchar *authors[] = {
 268                 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
 269                 NULL
 270         };
 271         about = gtk_about_dialog_new ();
 272         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
 273         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
 274         gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
 275                                         _("Copyright (c) 2006, Nokia Corporation\n"
 276                                           "All rights reserved."));
 277         gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
 278                                        _("a modest e-mail client\n\n"
 279                                          "design and implementation: Dirk-Jan C. Binnema\n"
 280                                          "contributions from the fine people at KC and Ig\n"
 281                                          "uses the tinymail email framework written by Philip van Hoof"));
 282         gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
 283         gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
 284         gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
 285         gtk_window_set_modal (GTK_WINDOW (about), TRUE);
 286
 287         gtk_dialog_run (GTK_DIALOG (about));
 288         gtk_widget_destroy(about);
 289 }
 290
 291 /*
 292  * Gets the list of currently selected messages. If the win is the
 293  * main window, then it returns a newly allocated list of the headers
 294  * selected in the header view. If win is the msg view window, then
 295  * the value returned is a list with just a single header.
 296  *
 297  * The caller of this funcion must free the list.
 298  */
 299 static TnyList *
 300 get_selected_headers (ModestWindow *win)
 301 {
 302         if (MODEST_IS_MAIN_WINDOW(win)) {
 303                 GtkWidget *header_view;
 304
 305                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 306                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
 307                 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 308
 309         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 310                 /* for MsgViewWindows, we simply return a list with one element */
 311                 TnyHeader *header;
 312                 TnyList *list = NULL;
 313
 314                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
 315                 if (header != NULL) {
 316                         list = tny_simple_list_new ();
 317                         tny_list_prepend (list, G_OBJECT(header));
 318                         g_object_unref (G_OBJECT(header));
 319                 }
 320
 321                 return list;
 322
 323         } else
 324                 return NULL;
 325 }
 326
 327 static GtkTreeRowReference *
 328 get_next_after_selected_headers (ModestHeaderView *header_view)
 329 {
 330         GtkTreeSelection *sel;
 331         GList *selected_rows, *node;
 332         GtkTreePath *path;
 333         GtkTreeRowReference *result;
 334         GtkTreeModel *model;
 335
 336         model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
 337         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 338         selected_rows = gtk_tree_selection_get_selected_rows (sel, NULL);
 339
 340         if (selected_rows == NULL)
 341                 return NULL;
 342
 343         node = g_list_last (selected_rows);
 344         path = gtk_tree_path_copy ((GtkTreePath *) node->data);
 345         gtk_tree_path_next (path);
 346
 347         result = gtk_tree_row_reference_new (model, path);
 348
 349         gtk_tree_path_free (path);
 350         g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
 351         g_list_free (selected_rows);
 352
 353         return result;
 354 }
 355
 356 static void
 357 headers_action_mark_as_read (TnyHeader *header,
 358                              ModestWindow *win,
 359                              gpointer user_data)
 360 {
 361         TnyHeaderFlags flags;
 362
 363         g_return_if_fail (TNY_IS_HEADER(header));
 364
 365         flags = tny_header_get_flags (header);
 366         if (flags & TNY_HEADER_FLAG_SEEN) return;
 367         tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
 368 }
 369
 370 static void
 371 headers_action_mark_as_unread (TnyHeader *header,
 372                                ModestWindow *win,
 373                                gpointer user_data)
 374 {
 375         TnyHeaderFlags flags;
 376
 377         g_return_if_fail (TNY_IS_HEADER(header));
 378
 379         flags = tny_header_get_flags (header);
 380         if (flags & TNY_HEADER_FLAG_SEEN)  {
 381                 tny_header_unset_flag (header, TNY_HEADER_FLAG_SEEN);
 382         }
 383 }
 384
 385 /** After deleing a message that is currently visible in a window,
 386  * show the next message from the list, or close the window if there are no more messages.
 387  **/
 388 void
 389 modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
 390 {
 391         /* Close msg view window or select next */
 392         if (modest_msg_view_window_last_message_selected (win) &&
 393                 modest_msg_view_window_first_message_selected (win)) {
 394                 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
 395         } else if (!modest_msg_view_window_select_next_message (win)) {
 396                 gboolean ret_value;
 397                 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 398         }
 399 }
 400
 401
 402 void
 403 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
 404 {
 405         TnyList *header_list = NULL;
 406         TnyIterator *iter = NULL;
 407         TnyHeader *header = NULL;
 408         gchar *message = NULL;
 409         gchar *desc = NULL;
 410         gint response;
 411         ModestWindowMgr *mgr;
 412         GtkWidget *header_view = NULL;
 413
 414         g_return_if_fail (MODEST_IS_WINDOW(win));
 415
 416         /* Check first if the header view has the focus */
 417         if (MODEST_IS_MAIN_WINDOW (win)) {
 418                 header_view =
 419                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 420                                                              MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
 421                 if (!gtk_widget_is_focus (header_view))
 422                         return;
 423         }
 424
 425         /* Get the headers, either from the header view (if win is the main window),
 426          * or from the message view window: */
 427         header_list = get_selected_headers (win);
 428         if (!header_list) return;
 429
 430         /* Check if any of the headers are already opened, or in the process of being opened */
 431         if (MODEST_IS_MAIN_WINDOW (win)) {
 432                 gint opened_headers = 0;
 433
 434                 iter = tny_list_create_iterator (header_list);
 435                 mgr = modest_runtime_get_window_mgr ();
 436                 while (!tny_iterator_is_done (iter)) {
 437                         header = TNY_HEADER (tny_iterator_get_current (iter));
 438                         if (header) {
 439                                 if (modest_window_mgr_find_registered_header (mgr, header, NULL))
 440                                         opened_headers++;
 441                                 g_object_unref (header);
 442                         }
 443                         tny_iterator_next (iter);
 444                 }
 445                 g_object_unref (iter);
 446
 447                 if (opened_headers > 0) {
 448                         gchar *msg;
 449
 450                         msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"),
 451                                                opened_headers);
 452
 453                         modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
 454
 455                         g_free (msg);
 456                         g_object_unref (header_list);
 457                         return;
 458                 }
 459         }
 460
 461         /* Select message */
 462         if (tny_list_get_length(header_list) == 1) {
 463                 iter = tny_list_create_iterator (header_list);
 464                 header = TNY_HEADER (tny_iterator_get_current (iter));
 465                 if (header) {
 466                         desc = g_strdup_printf ("%s", tny_header_get_subject (header));
 467                         g_object_unref (header);
 468                 }
 469
 470                 g_object_unref (iter);
 471         }
 472         message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
 473                                            tny_list_get_length(header_list)), desc);
 474
 475         /* Confirmation dialog */
 476         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
 477                                                             message);
 478
 479
 480         if (response == GTK_RESPONSE_OK) {
 481                 ModestWindow *main_window = NULL;
 482                 ModestWindowMgr *mgr = NULL;
 483                 GtkTreeModel *model = NULL;
 484                 GtkTreeSelection *sel = NULL;
 485                 GList *sel_list = NULL, *tmp = NULL;
 486                 GtkTreeRowReference *next_row_reference = NULL;
 487                 GtkTreeRowReference *prev_row_reference = NULL;
 488                 GtkTreePath *next_path = NULL;
 489                 GtkTreePath *prev_path = NULL;
 490                 ModestMailOperation *mail_op = NULL;
 491
 492                 /* Find last selected row */
 493                 if (MODEST_IS_MAIN_WINDOW (win)) {
 494                         model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
 495                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 496                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 497                         for (tmp=sel_list; tmp; tmp=tmp->next) {
 498                                 if (tmp->next == NULL) {
 499                                         prev_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
 500                                         next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
 501
 502                                         gtk_tree_path_prev (prev_path);
 503                                         gtk_tree_path_next (next_path);
 504
 505                                         prev_row_reference = gtk_tree_row_reference_new (model, prev_path);
 506                                         next_row_reference = gtk_tree_row_reference_new (model, next_path);
 507                                 }
 508                         }
 509                 }
 510
 511                 /* Disable window dimming management */
 512                 modest_window_disable_dimming (MODEST_WINDOW(win));
 513
 514                 /* Remove each header. If it's a view window header_view == NULL */
 515                 mail_op = modest_mail_operation_new ((GObject *) win);
 516                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 517                                                  mail_op);
 518                 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
 519                 g_object_unref (mail_op);
 520
 521                 /* Enable window dimming management */
 522                 if (sel != NULL) {
 523                         gtk_tree_selection_unselect_all (sel);
 524                 }
 525                 modest_window_enable_dimming (MODEST_WINDOW(win));
 526
 527                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 528                         modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
 529
 530                         /* Get main window */
 531                         mgr = modest_runtime_get_window_mgr ();
 532                         main_window = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
 533                 } else {
 534                         /* Move cursor to next row */
 535                         main_window = win;
 536
 537                         /* Select next or previous row */
 538                         if (gtk_tree_row_reference_valid (next_row_reference)) {
 539 /*                              next_path = gtk_tree_row_reference_get_path (row_reference); */
 540                                 gtk_tree_selection_select_path (sel, next_path);
 541                         }
 542                         else if (gtk_tree_row_reference_valid (prev_row_reference)) {
 543                                 gtk_tree_selection_select_path (sel, prev_path);
 544                         }
 545
 546                         /* Free */
 547                         if (next_row_reference != NULL)
 548                                 gtk_tree_row_reference_free (next_row_reference);
 549                         if (next_path != NULL)
 550                                 gtk_tree_path_free (next_path);
 551                         if (prev_row_reference != NULL)
 552                                 gtk_tree_row_reference_free (prev_row_reference);
 553                         if (prev_path != NULL)
 554                                 gtk_tree_path_free (prev_path);
 555                 }
 556
 557                 /* Update toolbar dimming state */
 558                 if (main_window)
 559                         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
 560
 561                 /* Free */
 562                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 563                 g_list_free (sel_list);
 564         }
 565
 566         /* Free*/
 567         g_free(message);
 568         g_free(desc);
 569         g_object_unref (header_list);
 570 }
 571
 572
 573
 574
 575 /* delete either message or folder, based on where we are */
 576 void
 577 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
 578 {
 579         g_return_if_fail (MODEST_IS_WINDOW(win));
 580
 581         /* Check first if the header view has the focus */
 582         if (MODEST_IS_MAIN_WINDOW (win)) {
 583                 GtkWidget *w;
 584                 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 585                                                          MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
 586                 if (gtk_widget_is_focus (w)) {
 587                         modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
 588                         return;
 589                 }
 590         }
 591         modest_ui_actions_on_delete_message (action, win);
 592 }
 593
 594
 595
 596 void
 597 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
 598 {
 599         ModestWindowMgr *mgr = NULL;
 600
 601 #ifdef MODEST_PLATFORM_MAEMO
 602         modest_osso_save_state();
 603 #endif /* MODEST_PLATFORM_MAEMO */
 604
 605         g_debug ("closing down, clearing %d item(s) from operation queue",
 606                  modest_mail_operation_queue_num_elements
 607                  (modest_runtime_get_mail_operation_queue()));
 608
 609         /* cancel all outstanding operations */
 610         modest_mail_operation_queue_cancel_all
 611                 (modest_runtime_get_mail_operation_queue());
 612
 613         g_debug ("queue has been cleared");
 614
 615
 616         /* Check if there are opened editing windows */
 617         mgr = modest_runtime_get_window_mgr ();
 618         modest_window_mgr_close_all_windows (mgr);
 619
 620         /* note: when modest-tny-account-store is finalized,
 621            it will automatically set all network connections
 622            to offline */
 623
 624 /*      gtk_main_quit (); */
 625 }
 626
 627 void
 628 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
 629 {
 630         gboolean ret_value;
 631
 632         g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 633
 634 /*      if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
 635 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
 636 /*      } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
 637 /*              gboolean ret_value; */
 638 /*              g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
 639 /*      } else if (MODEST_IS_WINDOW (win)) { */
 640 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
 641 /*      } else { */
 642 /*              g_return_if_reached (); */
 643 /*      } */
 644 }
 645
 646 void
 647 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
 648 {
 649         GtkClipboard *clipboard = NULL;
 650         gchar *selection = NULL;
 651
 652         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 653         selection = gtk_clipboard_wait_for_text (clipboard);
 654
 655         /* Question: why is the clipboard being used here?
 656          * It doesn't really make a lot of sense. */
 657
 658         if (selection)
 659         {
 660                 modest_address_book_add_address (selection);
 661                 g_free (selection);
 662         }
 663 }
 664
 665 void
 666 modest_ui_actions_on_accounts (GtkAction *action,
 667                                ModestWindow *win)
 668 {
 669         /* This is currently only implemented for Maemo */
 670 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 671         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
 672                 if (!modest_ui_actions_run_account_setup_wizard (win))
 673                         g_debug ("%s: wizard was already running", __FUNCTION__);
 674
 675                 return;
 676         } else {
 677                 /* Show the list of accounts */
 678                 GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
 679                 gtk_window_set_transient_for (account_win, GTK_WINDOW (win));
 680
 681                 /* The accounts dialog must be modal */
 682                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), account_win);
 683                 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
 684         }
 685 #else
 686         GtkWidget *dialog, *label;
 687
 688         /* Create the widgets */
 689
 690         dialog = gtk_dialog_new_with_buttons ("Message",
 691                                               GTK_WINDOW(win),
 692                                               GTK_DIALOG_DESTROY_WITH_PARENT,
 693                                               GTK_STOCK_OK,
 694                                               GTK_RESPONSE_NONE,
 695                                               NULL);
 696         label = gtk_label_new ("Hello World!");
 697
 698         /* Ensure that the dialog box is destroyed when the user responds. */
 699
 700         g_signal_connect_swapped (dialog, "response",
 701                                   G_CALLBACK (gtk_widget_destroy),
 702                                   dialog);
 703
 704         /* Add the label, and show everything we've added to the dialog. */
 705
 706         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
 707                            label);
 708         gtk_widget_show_all (dialog);
 709 #endif /* MODEST_PLATFORM_MAEMO */
 710 }
 711
 712 static void
 713 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
 714 {
 715         /* Save any changes. */
 716         modest_connection_specific_smtp_window_save_server_accounts (
 717                         MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window));
 718         gtk_widget_destroy (GTK_WIDGET (window));
 719 }
 720
 721
 722
 723 void
 724 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
 725 {
 726         /* This is currently only implemented for Maemo,
 727          * because it requires an API (libconic) to detect different connection
 728          * possiblities.
 729          */
 730 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 731
 732         /* Create the window if necessary: */
 733         GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
 734         modest_connection_specific_smtp_window_fill_with_connections (
 735                 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
 736                 modest_runtime_get_account_mgr());
 737
 738         /* Show the window: */
 739         gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
 740         gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
 741         gtk_widget_show (specific_window);
 742
 743         /* Save changes when the window is hidden: */
 744         g_signal_connect (specific_window, "hide",
 745                 G_CALLBACK (on_smtp_servers_window_hide), win);
 746 #endif /* MODEST_PLATFORM_MAEMO */
 747 }
 748
 749 void
 750 modest_ui_actions_compose_msg(ModestWindow *win,
 751                               const gchar *to_str,
 752                               const gchar *cc_str,
 753                               const gchar *bcc_str,
 754                               const gchar *subject_str,
 755                               const gchar *body_str,
 756                               GSList *attachments)
 757 {
 758         gchar *account_name = NULL;
 759         TnyMsg *msg = NULL;
 760         TnyAccount *account = NULL;
 761         TnyFolder *folder = NULL;
 762         gchar *from_str = NULL, *signature = NULL, *body = NULL;
 763         gboolean use_signature = FALSE;
 764         ModestWindow *msg_win = NULL;
 765         ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
 766         ModestTnyAccountStore *store = modest_runtime_get_account_store();
 767
 768         if (win) account_name = g_strdup (modest_window_get_active_account (win));
 769         if (!account_name) account_name = modest_account_mgr_get_default_account(mgr);
 770         if (!account_name) {
 771                 g_printerr ("modest: no account found\n");
 772                 goto cleanup;
 773         }
 774         account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
 775         if (!account) {
 776                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
 777                 goto cleanup;
 778         }
 779         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 780         if (!folder) {
 781                 g_printerr ("modest: failed to find Drafts folder\n");
 782                 goto cleanup;
 783         }
 784         from_str = modest_account_mgr_get_from_string (mgr, account_name);
 785         if (!from_str) {
 786                 g_printerr ("modest: failed get from string for '%s'\n", account_name);
 787                 goto cleanup;
 788         }
 789
 790         signature = modest_account_mgr_get_signature (mgr, account_name, &use_signature);
 791         if (body_str != NULL) {
 792                 body = use_signature ? g_strconcat(body_str, "\n", signature, NULL) : g_strdup(body_str);
 793         } else {
 794                 body = use_signature ? g_strconcat("\n", signature, NULL) : g_strdup("");
 795         }
 796
 797         msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, body, NULL);
 798         if (!msg) {
 799                 g_printerr ("modest: failed to create new msg\n");
 800                 goto cleanup;
 801         }
 802
 803         /* Create and register edit window */
 804         /* This is destroyed by TODO. */
 805         msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
 806         while (attachments) {
 807                 modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
 808                                                        attachments->data);
 809                 attachments = g_slist_next(attachments);
 810         }
 811         modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win);
 812
 813         if (win) {
 814                 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
 815                                               GTK_WINDOW (win));
 816         }
 817         gtk_widget_show_all (GTK_WIDGET (msg_win));
 818
 819 cleanup:
 820         g_free (from_str);
 821         g_free (signature);
 822         g_free (body);
 823         g_free (account_name);
 824         if (account) g_object_unref (G_OBJECT(account));
 825         if (folder) g_object_unref (G_OBJECT(folder));
 826         if (msg_win) g_object_unref (G_OBJECT(msg_win));
 827         if (msg) g_object_unref (G_OBJECT(msg));
 828 }
 829
 830 void
 831 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
 832 {
 833         /* if there are no accounts yet, just show the wizard */
 834         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
 835                 if (!modest_ui_actions_run_account_setup_wizard (win))
 836                         return;
 837
 838         modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL);
 839 }
 840
 841 gboolean
 842 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
 843                                        TnyHeader *header,
 844                                        TnyMsg *msg)
 845 {
 846         ModestMailOperationStatus status;
 847
 848         /* If there is no message or the operation was not successful */
 849         status = modest_mail_operation_get_status (mail_op);
 850         if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
 851
 852                 /* Remove the header from the preregistered uids */
 853                 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
 854                                                      header);
 855
 856                 return FALSE;
 857         }
 858
 859         return TRUE;
 860 }
 861
 862 static void
 863 open_msg_cb (ModestMailOperation *mail_op,
 864              TnyHeader *header,
 865              gboolean canceled,
 866              TnyMsg *msg,
 867              GError *err,
 868              gpointer user_data)
 869 {
 870         ModestWindowMgr *mgr = NULL;
 871         ModestWindow *parent_win = NULL;
 872         ModestWindow *win = NULL;
 873         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
 874         gchar *account = NULL;
 875         TnyFolder *folder;
 876         gboolean open_in_editor = FALSE;
 877
 878         /* Do nothing if there was any problem with the mail
 879            operation. The error will be shown by the error_handler of
 880            the mail operation */
 881         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
 882                 return;
 883
 884         parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
 885         folder = tny_header_get_folder (header);
 886
 887         /* Mark header as read */
 888         headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
 889
 890         /* Gets folder type (OUTBOX headers will be opened in edit window */
 891         if (modest_tny_folder_is_local_folder (folder)) {
 892                 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
 893                 if (folder_type == TNY_FOLDER_TYPE_INVALID)
 894                         g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
 895         }
 896
 897
 898         if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
 899                 TnyTransportAccount *traccount = NULL;
 900                 ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
 901                 traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
 902                 if (traccount) {
 903                         ModestTnySendQueue *send_queue = NULL;
 904                         ModestTnySendQueueStatus status;
 905                         char *msg_id;
 906                         account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
 907                                                    TNY_ACCOUNT(traccount)));
 908                         send_queue = modest_runtime_get_send_queue(traccount);
 909                         msg_id = modest_tny_send_queue_get_msg_id (header);
 910                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
 911                         /* Only open messages in outbox with the editor if they are in Failed state */
 912                         if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
 913                                 open_in_editor = TRUE;
 914                         }
 915                         g_free(msg_id);
 916                         g_object_unref(traccount);
 917                 } else {
 918                         g_warning("Cannot get transport account for message in outbox!!");
 919                 }
 920         } else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
 921                 open_in_editor = TRUE; /* Open in editor if the message is in the Drafts folder */
 922         }
 923
 924         /* Get account */
 925         if (!account)
 926                 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
 927         if (!account)
 928                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 929
 930         if (open_in_editor) {
 931                 ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
 932                 const gchar *from_header = NULL;
 933
 934                 from_header = tny_header_get_from (header);
 935
 936                 /* we cannot edit without a valid account... */
 937                 if (!modest_account_mgr_has_accounts(mgr, TRUE)) {
 938                         if (!modest_ui_actions_run_account_setup_wizard(parent_win))
 939                                 goto cleanup;
 940                 }
 941
 942                 if (from_header) {
 943                         GSList *accounts = modest_account_mgr_account_names (mgr, TRUE);
 944                         GSList *node = NULL;
 945                         for (node = accounts; node != NULL; node = g_slist_next (node)) {
 946                                 gchar *from = modest_account_mgr_get_from_string (mgr, node->data);
 947
 948                                 if (from && (strcmp (from_header, from) == 0)) {
 949                                         g_free (account);
 950                                         account = g_strdup (node->data);
 951                                         g_free (from);
 952                                         break;
 953                                 }
 954                                 g_free (from);
 955                         }
 956                         g_slist_foreach (accounts, (GFunc) g_free, NULL);
 957                         g_slist_free (accounts);
 958                 }
 959
 960                 win = modest_msg_edit_window_new (msg, account, TRUE);
 961
 962
 963                 /* Show banner */
 964                 modest_platform_information_banner (NULL, NULL, _("mail_ib_opening_draft_message"));
 965
 966         } else {
 967                 gchar *uid = modest_tny_folder_get_header_unique_id (header);
 968
 969                 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
 970                         GtkWidget *header_view;
 971                         GtkTreeSelection *sel;
 972                         GList *sel_list = NULL;
 973                         GtkTreeModel *model;
 974
 975                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
 976                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
 977
 978                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 979                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 980
 981                         if (sel_list != NULL) {
 982                                 GtkTreeRowReference *row_reference;
 983
 984                                 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
 985                                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 986                                 g_list_free (sel_list);
 987
 988                                 win = modest_msg_view_window_new_with_header_model (
 989                                                 msg, account, (const gchar*) uid,
 990                                                 model, row_reference);
 991                                 gtk_tree_row_reference_free (row_reference);
 992                         } else {
 993                                 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
 994                         }
 995                 } else {
 996                         win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
 997                 }
 998                 g_free (uid);
 999         }
1000
1001         /* Register and show new window */
1002         if (win != NULL) {
1003                 mgr = modest_runtime_get_window_mgr ();
1004                 modest_window_mgr_register_window (mgr, win);
1005                 g_object_unref (win);
1006                 gtk_widget_show_all (GTK_WIDGET(win));
1007         }
1008
1009         /* Update toolbar dimming state */
1010         if (MODEST_IS_MAIN_WINDOW (parent_win)) {
1011                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
1012         }
1013
1014 cleanup:
1015         /* Free */
1016         g_free(account);
1017         g_object_unref (parent_win);
1018         g_object_unref (folder);
1019 }
1020
1021 void
1022 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
1023                                                gpointer user_data)
1024 {
1025         const GError *error;
1026         GObject *win = NULL;
1027         const gchar *err_msg;
1028
1029         win = modest_mail_operation_get_source (mail_op);
1030         error = modest_mail_operation_get_error (mail_op);
1031
1032         /* Select error message */
1033         if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT)
1034                 err_msg = _("emev_ni_ui_imap_msg_size_exceed_error");
1035         else
1036                 err_msg = (const gchar *) user_data;
1037
1038         /* Show error */
1039         modest_platform_run_information_dialog ((GtkWindow *) win, err_msg);
1040
1041         if (win)
1042                 g_object_unref (win);
1043 }
1044
1045 /**
1046  * Returns the account a list of headers belongs to. It returns a
1047  * *new* reference so don't forget to unref it
1048  */
1049 static TnyAccount*
1050 get_account_from_header_list (TnyList *headers)
1051 {
1052         TnyAccount *account = NULL;
1053
1054         if (tny_list_get_length (headers) > 0) {
1055                 TnyIterator *iter = tny_list_create_iterator (headers);
1056                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1057                 TnyFolder *folder = tny_header_get_folder (header);
1058                 account = tny_folder_get_account (folder);
1059                 g_object_unref (folder);
1060                 g_object_unref (header);
1061                 g_object_unref (iter);
1062         }
1063         return account;
1064 }
1065
1066 static void
1067 open_msgs_performer(gboolean canceled,
1068                     GError *err,
1069                     GtkWindow *parent_window,
1070                     TnyAccount *account,
1071                     gpointer user_data)
1072 {
1073         ModestMailOperation *mail_op;
1074         const gchar *proto_name;
1075         gchar *error_msg;
1076         ModestTransportStoreProtocol proto;
1077         TnyList *not_opened_headers;
1078
1079         not_opened_headers = TNY_LIST (user_data);
1080
1081         /* Get the error message depending on the protocol */
1082         proto_name = tny_account_get_proto (account);
1083         if (proto_name != NULL) {
1084                 proto = modest_protocol_info_get_transport_store_protocol (proto_name);
1085         } else {
1086                 proto = MODEST_PROTOCOL_STORE_MAILDIR;
1087         }
1088
1089         /* Create the error messages */
1090         if (tny_list_get_length (not_opened_headers) == 1) {
1091                 if (proto == MODEST_PROTOCOL_STORE_POP) {
1092                         error_msg = g_strdup (_("emev_ni_ui_pop3_msg_recv_error"));
1093                 } else if (proto == MODEST_PROTOCOL_STORE_IMAP) {
1094                         TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
1095                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1096                         error_msg = g_strdup_printf (_("emev_ni_ui_imap_message_not_available_in_server"),
1097                                                      tny_header_get_subject (header));
1098                         g_object_unref (header);
1099                         g_object_unref (iter);
1100                 } else {
1101                         error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1102                 }
1103         } else {
1104                 error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1105         }
1106
1107         /* Create the mail operation */
1108         mail_op =
1109                 modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
1110                                                                modest_ui_actions_get_msgs_full_error_handler,
1111                                                                error_msg, g_free);
1112         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1113                                          mail_op);
1114
1115         modest_mail_operation_get_msgs_full (mail_op,
1116                                              not_opened_headers,
1117                                              open_msg_cb,
1118                                              NULL,
1119                                              NULL);
1120
1121         /* Frees */
1122         g_object_unref (mail_op);
1123         g_object_unref (not_opened_headers);
1124         g_object_unref (account);
1125 }
1126
1127 /*
1128  * This function is used by both modest_ui_actions_on_open and
1129  * modest_ui_actions_on_header_activated. This way we always do the
1130  * same when trying to open messages.
1131  */
1132 static void
1133 open_msgs_from_headers (TnyList *headers, ModestWindow *win)
1134 {
1135         ModestWindowMgr *mgr = NULL;
1136         TnyIterator *iter = NULL, *iter_not_opened = NULL;
1137         TnyList *not_opened_headers = NULL;
1138         TnyHeaderFlags flags = 0;
1139         TnyAccount *account;
1140         gint uncached_msgs = 0;
1141
1142         g_return_if_fail (headers != NULL);
1143
1144         /* Check that only one message is selected for opening */
1145         if (tny_list_get_length (headers) != 1) {
1146                 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1147                                                         _("mcen_ib_select_one_message"));
1148                 return;
1149         }
1150
1151         mgr = modest_runtime_get_window_mgr ();
1152         iter = tny_list_create_iterator (headers);
1153
1154         /* Get the account */
1155         account = get_account_from_header_list (headers);
1156
1157         /* Look if we already have a message view for each header. If
1158            true, then remove the header from the list of headers to
1159            open */
1160         not_opened_headers = tny_simple_list_new ();
1161         while (!tny_iterator_is_done (iter)) {
1162
1163                 ModestWindow *window = NULL;
1164                 TnyHeader *header = NULL;
1165                 gboolean found = FALSE;
1166
1167                 header = TNY_HEADER (tny_iterator_get_current (iter));
1168                 if (header)
1169                         flags = tny_header_get_flags (header);
1170
1171                 window = NULL;
1172                 found = modest_window_mgr_find_registered_header (mgr, header, &window);
1173
1174                 /* Do not open again the message and present the
1175                    window to the user */
1176                 if (found) {
1177                         if (window)
1178                                 gtk_window_present (GTK_WINDOW (window));
1179                         else
1180                                 /* the header has been registered already, we don't do
1181                                  * anything but wait for the window to come up*/
1182                                 g_debug ("header %p already registered, waiting for window", header);
1183                 } else {
1184                         tny_list_append (not_opened_headers, G_OBJECT (header));
1185                 }
1186
1187                 if (header)
1188                         g_object_unref (header);
1189
1190                 tny_iterator_next (iter);
1191         }
1192         g_object_unref (iter);
1193         iter = NULL;
1194
1195         /* Open each message */
1196         if (tny_list_get_length (not_opened_headers) == 0)
1197                 goto cleanup;
1198
1199         /* If some messages would have to be downloaded, ask the user to
1200          * make a connection. It's generally easier to do this here (in the mainloop)
1201          * than later in a thread:
1202          */
1203         if (tny_list_get_length (not_opened_headers) > 0) {
1204                 uncached_msgs = header_list_count_uncached_msgs (not_opened_headers);
1205
1206                 if (uncached_msgs > 0) {
1207                         /* Allways download if we are online. */
1208                         if (!tny_device_is_online (modest_runtime_get_device ())) {
1209                                 gint response;
1210
1211                                 /* If ask for user permission to download the messages */
1212                                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1213                                                                                     ngettext("mcen_nc_get_msg",
1214                                                                                              "mcen_nc_get_msgs",
1215                                                                                              uncached_msgs));
1216
1217                                 /* End if the user does not want to continue */
1218                                 if (response == GTK_RESPONSE_CANCEL)
1219                                         goto cleanup;
1220                         }
1221                 }
1222         }
1223
1224         /* Register the headers before actually creating the windows: */
1225         iter_not_opened = tny_list_create_iterator (not_opened_headers);
1226         while (!tny_iterator_is_done (iter_not_opened)) {
1227                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
1228                 if (header) {
1229                         modest_window_mgr_register_header (mgr, header, NULL);
1230                         g_object_unref (header);
1231                 }
1232                 tny_iterator_next (iter_not_opened);
1233         }
1234         g_object_unref (iter_not_opened);
1235         iter_not_opened = NULL;
1236
1237         /* Connect to the account and perform */
1238         if (uncached_msgs > 0) {
1239                 modest_platform_connect_and_perform ((GtkWindow *) win, g_object_ref (account),
1240                                                      open_msgs_performer, g_object_ref (not_opened_headers));
1241         } else {
1242                 /* Call directly the performer, do not need to connect */
1243                 open_msgs_performer (FALSE, NULL, (GtkWindow *) win, g_object_ref (account),
1244                                      g_object_ref (not_opened_headers));
1245         }
1246 cleanup:
1247         /* Clean */
1248         if (account)
1249                 g_object_unref (account);
1250         if (not_opened_headers)
1251                 g_object_unref (not_opened_headers);
1252 }
1253
1254 void
1255 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1256 {
1257         TnyList *headers;
1258
1259         /* Get headers */
1260         headers = get_selected_headers (win);
1261         if (!headers)
1262                 return;
1263
1264         /* Open them */
1265         open_msgs_from_headers (headers, win);
1266
1267         g_object_unref(headers);
1268 }
1269
1270
1271 static void
1272 free_reply_forward_helper (gpointer data)
1273 {
1274         ReplyForwardHelper *helper;
1275
1276         helper = (ReplyForwardHelper *) data;
1277         g_free (helper->account_name);
1278         g_slice_free (ReplyForwardHelper, helper);
1279 }
1280
1281 static void
1282 reply_forward_cb (ModestMailOperation *mail_op,
1283                   TnyHeader *header,
1284                   gboolean canceled,
1285                   TnyMsg *msg,
1286                   GError *err,
1287                   gpointer user_data)
1288 {
1289         TnyMsg *new_msg;
1290         ReplyForwardHelper *rf_helper;
1291         ModestWindow *msg_win = NULL;
1292         ModestEditType edit_type;
1293         gchar *from = NULL;
1294         TnyAccount *account = NULL;
1295         ModestWindowMgr *mgr = NULL;
1296         gchar *signature = NULL;
1297         gboolean use_signature;
1298
1299         /* If there was any error. The mail operation could be NULL,
1300            this means that we already have the message downloaded and
1301            that we didn't do a mail operation to retrieve it */
1302         if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1303                 return;
1304
1305         g_return_if_fail (user_data != NULL);
1306         rf_helper = (ReplyForwardHelper *) user_data;
1307
1308         from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1309                                                    rf_helper->account_name);
1310         signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr(),
1311                                                       rf_helper->account_name,
1312                                                       &use_signature);
1313
1314         /* Create reply mail */
1315         switch (rf_helper->action) {
1316         case ACTION_REPLY:
1317                 new_msg =
1318                         modest_tny_msg_create_reply_msg (msg, header, from, signature,
1319                                                          rf_helper->reply_forward_type,
1320                                                          MODEST_TNY_MSG_REPLY_MODE_SENDER);
1321                 break;
1322         case ACTION_REPLY_TO_ALL:
1323                 new_msg =
1324                         modest_tny_msg_create_reply_msg (msg, header, from, signature, rf_helper->reply_forward_type,
1325                                                          MODEST_TNY_MSG_REPLY_MODE_ALL);
1326                 edit_type = MODEST_EDIT_TYPE_REPLY;
1327                 break;
1328         case ACTION_FORWARD:
1329                 new_msg =
1330                         modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1331                 edit_type = MODEST_EDIT_TYPE_FORWARD;
1332                 break;
1333         default:
1334                 g_return_if_reached ();
1335                 return;
1336         }
1337
1338         g_free (signature);
1339
1340         if (!new_msg) {
1341                 g_printerr ("modest: failed to create message\n");
1342                 goto cleanup;
1343         }
1344
1345         account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1346                                                                        rf_helper->account_name,
1347                                                                        TNY_ACCOUNT_TYPE_STORE);
1348         if (!account) {
1349                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1350                 goto cleanup;
1351         }
1352
1353         /* Create and register the windows */
1354         msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
1355         mgr = modest_runtime_get_window_mgr ();
1356         modest_window_mgr_register_window (mgr, msg_win);
1357
1358         if (rf_helper->parent_window != NULL) {
1359                 gdouble parent_zoom;
1360
1361                 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1362                 modest_window_set_zoom (msg_win, parent_zoom);
1363         }
1364
1365         /* Show edit window */
1366         gtk_widget_show_all (GTK_WIDGET (msg_win));
1367
1368 cleanup:
1369         if (msg_win)
1370                 g_object_unref (msg_win);
1371         if (new_msg)
1372                 g_object_unref (G_OBJECT (new_msg));
1373         if (account)
1374                 g_object_unref (G_OBJECT (account));
1375 /*      g_object_unref (msg); */
1376         free_reply_forward_helper (rf_helper);
1377 }
1378
1379 /* Checks a list of headers. If any of them are not currently
1380  * downloaded (CACHED) then returns TRUE else returns FALSE.
1381  */
1382 static gint
1383 header_list_count_uncached_msgs (TnyList *header_list)
1384 {
1385         TnyIterator *iter;
1386         gint uncached_messages = 0;
1387
1388         iter = tny_list_create_iterator (header_list);
1389         while (!tny_iterator_is_done (iter)) {
1390                 TnyHeader *header;
1391
1392                 header = TNY_HEADER (tny_iterator_get_current (iter));
1393                 if (header) {
1394                         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1395                                 uncached_messages ++;
1396                         g_object_unref (header);
1397                 }
1398
1399                 tny_iterator_next (iter);
1400         }
1401         g_object_unref (iter);
1402
1403         return uncached_messages;
1404 }
1405
1406 /* Returns FALSE if the user does not want to download the
1407  * messages. Returns TRUE if the user allowed the download.
1408  */
1409 static gboolean
1410 connect_to_get_msg (ModestWindow *win,
1411                     gint num_of_uncached_msgs,
1412                     TnyAccount *account)
1413 {
1414         GtkResponseType response;
1415
1416         /* Allways download if we are online. */
1417         if (tny_device_is_online (modest_runtime_get_device ()))
1418                 return TRUE;
1419
1420         /* If offline, then ask for user permission to download the messages */
1421         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1422                         ngettext("mcen_nc_get_msg",
1423                         "mcen_nc_get_msgs",
1424                         num_of_uncached_msgs));
1425
1426         if (response == GTK_RESPONSE_CANCEL)
1427                 return FALSE;
1428
1429         return modest_platform_connect_and_wait((GtkWindow *) win, account);
1430 }
1431
1432 /*
1433  * Common code for the reply and forward actions
1434  */
1435 static void
1436 reply_forward (ReplyForwardAction action, ModestWindow *win)
1437 {
1438         ModestMailOperation *mail_op = NULL;
1439         TnyList *header_list = NULL;
1440         ReplyForwardHelper *rf_helper = NULL;
1441         guint reply_forward_type;
1442         gboolean continue_download = TRUE;
1443         gboolean do_retrieve = TRUE;
1444
1445         g_return_if_fail (MODEST_IS_WINDOW(win));
1446
1447         /* we need an account when editing */
1448         if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1449                 if (!modest_ui_actions_run_account_setup_wizard (win))
1450                         return;
1451         }
1452
1453         header_list = get_selected_headers (win);
1454         if (!header_list)
1455                 return;
1456
1457         reply_forward_type =
1458                 modest_conf_get_int (modest_runtime_get_conf (),
1459                                      (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1460                                      NULL);
1461
1462         /* check if we need to download msg before asking about it */
1463         do_retrieve = (action == ACTION_FORWARD) ||
1464                         (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1465
1466         if (do_retrieve){
1467                 gint num_of_unc_msgs;
1468
1469                 /* check that the messages have been previously downloaded */
1470                 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
1471                 /* If there are any uncached message ask the user
1472                  * whether he/she wants to download them. */
1473                 if (num_of_unc_msgs) {
1474                         TnyAccount *account = get_account_from_header_list (header_list);
1475                         continue_download = connect_to_get_msg (win, num_of_unc_msgs, account);
1476                         g_object_unref (account);
1477                 }
1478         }
1479
1480         if (!continue_download) {
1481                 g_object_unref (header_list);
1482                 return;
1483         }
1484
1485         /* We assume that we can only select messages of the
1486            same folder and that we reply all of them from the
1487            same account. In fact the interface currently only
1488            allows single selection */
1489
1490         /* Fill helpers */
1491         rf_helper = g_slice_new0 (ReplyForwardHelper);
1492         rf_helper->reply_forward_type = reply_forward_type;
1493         rf_helper->action = action;
1494         rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1495
1496         if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1497                 rf_helper->parent_window = GTK_WIDGET (win);
1498         if (!rf_helper->account_name)
1499                 rf_helper->account_name =
1500                         modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1501
1502         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1503                 TnyMsg *msg;
1504                 TnyHeader *header;
1505                 /* Get header and message. Do not free them here, the
1506                    reply_forward_cb must do it */
1507                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1508                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1509                 if (!msg || !header) {
1510                         if (msg)
1511                                 g_object_unref (msg);
1512                         g_printerr ("modest: no message found\n");
1513                         return;
1514                 } else {
1515                         reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
1516                 }
1517                 if (header)
1518                         g_object_unref (header);
1519         } else {
1520                 TnyHeader *header;
1521                 TnyIterator *iter;
1522
1523                 /* Only reply/forward to one message */
1524                 iter = tny_list_create_iterator (header_list);
1525                 header = TNY_HEADER (tny_iterator_get_current (iter));
1526                 g_object_unref (iter);
1527
1528                 if (header) {
1529                         /* Retrieve messages */
1530                         if (do_retrieve) {
1531                                 mail_op =
1532                                         modest_mail_operation_new_with_error_handling (G_OBJECT(win),
1533                                                                                        modest_ui_actions_get_msgs_full_error_handler,
1534                                                                                        NULL, NULL);
1535                                 modest_mail_operation_queue_add (
1536                                         modest_runtime_get_mail_operation_queue (), mail_op);
1537
1538                                 modest_mail_operation_get_msg (mail_op,
1539                                                                header,
1540                                                                reply_forward_cb,
1541                                                                rf_helper);
1542                                 /* Clean */
1543                                 g_object_unref(mail_op);
1544                         } else {
1545                                 /* we put a ref here to prevent double unref as the reply
1546                                  * forward callback unrefs the header at its end */
1547                                 reply_forward_cb (NULL, header, FALSE, NULL, NULL, rf_helper);
1548                         }
1549
1550
1551                         g_object_unref (header);
1552                 }
1553
1554         }
1555
1556         /* Free */
1557         g_object_unref (header_list);
1558 }
1559
1560 void
1561 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1562 {
1563         g_return_if_fail (MODEST_IS_WINDOW(win));
1564
1565         reply_forward (ACTION_REPLY, win);
1566 }
1567
1568 void
1569 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1570 {
1571         g_return_if_fail (MODEST_IS_WINDOW(win));
1572
1573         reply_forward (ACTION_FORWARD, win);
1574 }
1575
1576 void
1577 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1578 {
1579         g_return_if_fail (MODEST_IS_WINDOW(win));
1580
1581         reply_forward (ACTION_REPLY_TO_ALL, win);
1582 }
1583
1584 void
1585 modest_ui_actions_on_next (GtkAction *action,
1586                            ModestWindow *window)
1587 {
1588         if (MODEST_IS_MAIN_WINDOW (window)) {
1589                 GtkWidget *header_view;
1590
1591                 header_view = modest_main_window_get_child_widget (
1592                                 MODEST_MAIN_WINDOW(window),
1593                                 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1594                 if (!header_view)
1595                         return;
1596
1597                 modest_header_view_select_next (
1598                                 MODEST_HEADER_VIEW(header_view));
1599         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1600                 modest_msg_view_window_select_next_message (
1601                                 MODEST_MSG_VIEW_WINDOW (window));
1602         } else {
1603                 g_return_if_reached ();
1604         }
1605 }
1606
1607 void
1608 modest_ui_actions_on_prev (GtkAction *action,
1609                            ModestWindow *window)
1610 {
1611         g_return_if_fail (MODEST_IS_WINDOW(window));
1612
1613         if (MODEST_IS_MAIN_WINDOW (window)) {
1614                 GtkWidget *header_view;
1615                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1616                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1617                 if (!header_view)
1618                         return;
1619
1620                 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1621         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1622                 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1623         } else {
1624                 g_return_if_reached ();
1625         }
1626 }
1627
1628 void
1629 modest_ui_actions_on_sort (GtkAction *action,
1630                            ModestWindow *window)
1631 {
1632         g_return_if_fail (MODEST_IS_WINDOW(window));
1633
1634         if (MODEST_IS_MAIN_WINDOW (window)) {
1635                 GtkWidget *header_view;
1636                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1637                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1638                 if (!header_view) {
1639                         modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1640
1641                         return;
1642                 }
1643
1644                 /* Show sorting dialog */
1645                 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1646         }
1647 }
1648
1649 static void
1650 new_messages_arrived (ModestMailOperation *self,
1651                       TnyList *new_headers,
1652                       gpointer user_data)
1653 {
1654         GObject *source;
1655
1656         source = modest_mail_operation_get_source (self);
1657
1658         /* Notify new messages have been downloaded. Do not notify if
1659            the send&receive was invoked by the user, i.e, if the mail
1660            operation has a source (the main window) */
1661         if ((new_headers != NULL) && (tny_list_get_length (new_headers) > 0) && !source)
1662                 modest_platform_on_new_headers_received (new_headers);
1663
1664         if (source)
1665                 g_object_unref (source);
1666 }
1667
1668 typedef struct {
1669         TnyAccount *account;
1670         ModestWindow *win;
1671         gchar *account_name;
1672 } SendReceiveInfo;
1673
1674 static void
1675 do_send_receive_performer (gboolean canceled,
1676                            GError *err,
1677                            GtkWindow *parent_window,
1678                            TnyAccount *account,
1679                            gpointer user_data)
1680 {
1681         ModestMailOperation *mail_op;
1682         SendReceiveInfo *info;
1683
1684         info = (SendReceiveInfo *) user_data;
1685
1686         if (err || canceled) {
1687
1688                 goto clean;
1689         }
1690
1691         /* Set send/receive operation in progress */
1692         if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
1693                 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
1694         }
1695
1696         mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (info->win),
1697                                                                  modest_ui_actions_send_receive_error_handler,
1698                                                                  NULL, NULL);
1699
1700         if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
1701                 g_signal_connect (G_OBJECT(mail_op), "operation-finished",
1702                                   G_CALLBACK (on_send_receive_finished),
1703                                   info->win);
1704
1705         /* Send & receive. */
1706         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1707         modest_mail_operation_update_account (mail_op, info->account_name, new_messages_arrived, info->win);
1708         g_object_unref (G_OBJECT (mail_op));
1709
1710  clean:
1711         /* Frees */
1712         if (info->account_name)
1713                 g_free (info->account_name);
1714         if (info->win)
1715                 g_object_unref (info->win);
1716         if (info->account)
1717                 g_object_unref (info->account);
1718         g_slice_free (SendReceiveInfo, info);
1719 }
1720
1721 /*
1722  * This function performs the send & receive required actions. The
1723  * window is used to create the mail operation. Typically it should
1724  * always be the main window, but we pass it as argument in order to
1725  * be more flexible.
1726  */
1727 void
1728 modest_ui_actions_do_send_receive (const gchar *account_name,
1729                                    ModestWindow *win)
1730 {
1731         gchar *acc_name = NULL;
1732         SendReceiveInfo *info;
1733         ModestTnyAccountStore *acc_store;
1734
1735         /* If no account name was provided then get the current account, and if
1736            there is no current account then pick the default one: */
1737         if (!account_name) {
1738                 if (win)
1739                         acc_name = g_strdup (modest_window_get_active_account (win));
1740                 if (!acc_name)
1741                         acc_name  = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1742                 if (!acc_name) {
1743                         g_printerr ("modest: cannot get default account\n");
1744                         return;
1745                 }
1746         } else {
1747                 acc_name = g_strdup (account_name);
1748         }
1749
1750         acc_store = modest_runtime_get_account_store ();
1751
1752         /* Create the info for the connect and perform */
1753         info = g_slice_new (SendReceiveInfo);
1754         info->account_name = acc_name;
1755         info->win = (win) ? g_object_ref (win) : NULL;
1756         info->account = modest_tny_account_store_get_server_account (acc_store, acc_name,
1757                                                                      TNY_ACCOUNT_TYPE_STORE);
1758
1759         /* Invoke the connect and perform */
1760         modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL, info->account,
1761                                              do_send_receive_performer, info);
1762 }
1763
1764
1765 static void
1766 modest_ui_actions_do_cancel_send (const gchar *account_name,
1767                                   ModestWindow *win)
1768 {
1769         TnyTransportAccount *transport_account;
1770         TnySendQueue *send_queue = NULL;
1771         GError *error = NULL;
1772
1773         /* Get transport account */
1774         transport_account =
1775                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1776                                       (modest_runtime_get_account_store(),
1777                                        account_name,
1778                                        TNY_ACCOUNT_TYPE_TRANSPORT));
1779         if (!transport_account) {
1780                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1781                 goto frees;
1782         }
1783
1784         /* Get send queue*/
1785         send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1786         if (!TNY_IS_SEND_QUEUE(send_queue)) {
1787                 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1788                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1789                              "modest: could not find send queue for account\n");
1790         } else {
1791                 /* Keeep messages in outbox folder */
1792                 tny_send_queue_cancel (send_queue, FALSE, &error);
1793         }
1794
1795  frees:
1796         if (transport_account != NULL)
1797                 g_object_unref (G_OBJECT (transport_account));
1798 }
1799
1800 static void
1801 modest_ui_actions_cancel_send_all (ModestWindow *win)
1802 {
1803         GSList *account_names, *iter;
1804
1805         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1806                                                           TRUE);
1807
1808         iter = account_names;
1809         while (iter) {
1810                 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1811                 iter = g_slist_next (iter);
1812         }
1813
1814         modest_account_mgr_free_account_names (account_names);
1815         account_names = NULL;
1816 }
1817
1818 void
1819 modest_ui_actions_cancel_send (GtkAction *action,  ModestWindow *win)
1820
1821 {
1822         /* Check if accounts exist */
1823         gboolean accounts_exist =
1824                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1825
1826         /* If not, allow the user to create an account before trying to send/receive. */
1827         if (!accounts_exist)
1828                 modest_ui_actions_on_accounts (NULL, win);
1829
1830         /* Cancel all sending operaitons */
1831         modest_ui_actions_cancel_send_all (win);
1832 }
1833
1834 /*
1835  * Refreshes all accounts. This function will be used by automatic
1836  * updates
1837  */
1838 void
1839 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1840 {
1841         GSList *account_names, *iter;
1842
1843         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1844                                                           TRUE);
1845
1846         iter = account_names;
1847         while (iter) {
1848                 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1849                 iter = g_slist_next (iter);
1850         }
1851
1852         modest_account_mgr_free_account_names (account_names);
1853         account_names = NULL;
1854 }
1855
1856 /*
1857  * Handler of the click on Send&Receive button in the main toolbar
1858  */
1859 void
1860 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1861 {
1862         /* Check if accounts exist */
1863         gboolean accounts_exist =
1864                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1865
1866         /* If not, allow the user to create an account before trying to send/receive. */
1867         if (!accounts_exist)
1868                 modest_ui_actions_on_accounts (NULL, win);
1869
1870         /* Refresh the active account */
1871         modest_ui_actions_do_send_receive (NULL, win);
1872 }
1873
1874
1875 void
1876 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1877 {
1878         ModestConf *conf;
1879         GtkWidget *header_view;
1880
1881         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1882
1883         header_view = modest_main_window_get_child_widget (main_window,
1884                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1885         if (!header_view)
1886                 return;
1887
1888         conf = modest_runtime_get_conf ();
1889
1890         /* what is saved/restored is depending on the style; thus; we save with
1891          * old style, then update the style, and restore for this new style
1892          */
1893         modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1894
1895         if (modest_header_view_get_style
1896             (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1897                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1898                                               MODEST_HEADER_VIEW_STYLE_TWOLINES);
1899         else
1900                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1901                                               MODEST_HEADER_VIEW_STYLE_DETAILS);
1902
1903         modest_widget_memory_restore (conf, G_OBJECT(header_view),
1904                                       MODEST_CONF_HEADER_VIEW_KEY);
1905 }
1906
1907
1908 void
1909 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1910                                       TnyHeader *header,
1911                                       ModestMainWindow *main_window)
1912 {
1913         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1914         g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1915
1916         /* in the case the folder is empty, show the empty folder message and focus
1917          * folder view */
1918         if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
1919                 if (modest_header_view_is_empty (header_view)) {
1920                         TnyFolder *folder = modest_header_view_get_folder (header_view);
1921                         GtkWidget *folder_view =
1922                                 modest_main_window_get_child_widget (main_window,
1923                                                                      MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
1924                         if (folder != NULL)
1925                                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
1926                         gtk_widget_grab_focus (GTK_WIDGET (folder_view));
1927                         return;
1928                 }
1929         }
1930         /* If no header has been selected then exit */
1931         if (!header)
1932                 return;
1933
1934         /* Update focus */
1935         if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1936             gtk_widget_grab_focus (GTK_WIDGET(header_view));
1937
1938         /* Update toolbar dimming state */
1939         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1940 }
1941
1942 void
1943 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1944                                        TnyHeader *header,
1945                                        ModestMainWindow *main_window)
1946 {
1947         TnyList *headers;
1948
1949         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1950
1951         if (!header)
1952                 return;
1953
1954         if (modest_header_view_count_selected_headers (header_view) > 1) {
1955                 hildon_banner_show_information (NULL, NULL, _("mcen_ib_select_one_message"));
1956                 return;
1957         }
1958
1959
1960 /*      headers = tny_simple_list_new (); */
1961 /*      tny_list_prepend (headers, G_OBJECT (header)); */
1962         headers = modest_header_view_get_selected_headers (header_view);
1963
1964         open_msgs_from_headers (headers, MODEST_WINDOW (main_window));
1965
1966         g_object_unref (headers);
1967 }
1968
1969 static void
1970 set_active_account_from_tny_account (TnyAccount *account,
1971                                      ModestWindow *window)
1972 {
1973         const gchar *server_acc_name = tny_account_get_id (account);
1974
1975         /* We need the TnyAccount provided by the
1976            account store because that is the one that
1977            knows the name of the Modest account */
1978         TnyAccount *modest_server_account = modest_server_account =
1979                 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1980                                                              MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1981                                                              server_acc_name);
1982         if (!modest_server_account) {
1983                 g_warning ("%s: could not get tny account\n", __FUNCTION__);
1984                 return;
1985         }
1986
1987         /* Update active account, but only if it's not a pseudo-account */
1988         if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
1989             (!modest_tny_account_is_memory_card_account(modest_server_account))) {
1990                 const gchar *modest_acc_name =
1991                         modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1992                 if (modest_acc_name)
1993                         modest_window_set_active_account (window, modest_acc_name);
1994         }
1995
1996         g_object_unref (modest_server_account);
1997 }
1998
1999
2000 static void
2001 folder_refreshed_cb (ModestMailOperation *mail_op,
2002                      TnyFolder *folder,
2003                      gpointer user_data)
2004 {
2005         ModestMainWindow *win = NULL;
2006         GtkWidget *header_view;
2007         gboolean folder_empty = FALSE;
2008         gboolean all_marked_as_deleted = FALSE;
2009
2010         g_return_if_fail (TNY_IS_FOLDER (folder));
2011
2012         win = MODEST_MAIN_WINDOW (user_data);
2013         header_view =
2014                 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2015
2016         if (header_view) {
2017                 TnyFolder *current_folder;
2018
2019                 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
2020                 if (current_folder != NULL && folder != current_folder) {
2021                         g_object_unref (current_folder);
2022                         return;
2023                 }
2024                 g_object_unref (current_folder);
2025         }
2026
2027         /* Check if folder is empty and set headers view contents style */
2028         folder_empty = (tny_folder_get_all_count (folder) == 0);
2029         all_marked_as_deleted = modest_header_view_is_empty (MODEST_HEADER_VIEW(header_view));
2030         if (folder_empty || all_marked_as_deleted)
2031                 modest_main_window_set_contents_style (win,
2032                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2033 }
2034
2035 void
2036 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2037                                                TnyFolderStore *folder_store,
2038                                                gboolean selected,
2039                                                ModestMainWindow *main_window)
2040 {
2041         ModestConf *conf;
2042         GtkWidget *header_view;
2043
2044         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2045
2046         header_view = modest_main_window_get_child_widget(main_window,
2047                                                           MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2048         if (!header_view)
2049                 return;
2050
2051         conf = modest_runtime_get_conf ();
2052
2053         if (TNY_IS_ACCOUNT (folder_store)) {
2054                 if (selected) {
2055                         set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2056
2057                         /* Show account details */
2058                         modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2059                 }
2060         } else {
2061                 if (TNY_IS_FOLDER (folder_store) && selected) {
2062
2063                         /* Update the active account */
2064                         TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2065                         if (account) {
2066                                 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2067                                 g_object_unref (account);
2068                                 account = NULL;
2069                         }
2070
2071                         /* Set the header style by default, it could
2072                            be changed later by the refresh callback to
2073                            empty */
2074                         modest_main_window_set_contents_style (main_window,
2075                                                                MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2076
2077                         /* Set folder on header view. This function
2078                            will call tny_folder_refresh_async so we
2079                            pass a callback that will be called when
2080                            finished. We use that callback to set the
2081                            empty view if there are no messages */
2082                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2083                                                        TNY_FOLDER (folder_store),
2084                                                        folder_refreshed_cb,
2085                                                        main_window);
2086
2087                         /* Restore configuration. We need to do this
2088                            *after* the set_folder because the widget
2089                            memory asks the header view about its
2090                            folder  */
2091                         modest_widget_memory_restore (modest_runtime_get_conf (),
2092                                                       G_OBJECT(header_view),
2093                                                       MODEST_CONF_HEADER_VIEW_KEY);
2094                 } else {
2095                         /* Update the active account */
2096                         //modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
2097                         /* Save only if we're seeing headers */
2098                         if (modest_main_window_get_contents_style (main_window) ==
2099                             MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2100                                 modest_widget_memory_save (conf, G_OBJECT (header_view),
2101                                                            MODEST_CONF_HEADER_VIEW_KEY);
2102                         modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2103                 }
2104         }
2105
2106         /* Update toolbar dimming state */
2107         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2108 }
2109
2110 void
2111 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2112                                      ModestWindow *win)
2113 {
2114         GtkWidget *dialog;
2115         gchar *txt, *item;
2116         gboolean online;
2117
2118         item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2119
2120         online = tny_device_is_online (modest_runtime_get_device());
2121
2122         if (online) {
2123                 /* already online -- the item is simply not there... */
2124                 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2125                                                  GTK_DIALOG_MODAL,
2126                                                  GTK_MESSAGE_WARNING,
2127                                                  GTK_BUTTONS_NONE,
2128                                                  _("The %s you selected cannot be found"),
2129                                                  item);
2130                 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2131                 gtk_dialog_run (GTK_DIALOG(dialog));
2132         } else {
2133                 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2134                                                       GTK_WINDOW (win),
2135                                                       GTK_DIALOG_MODAL,
2136                                                       _("mcen_bd_dialog_cancel"),
2137                                                       GTK_RESPONSE_REJECT,
2138                                                       _("mcen_bd_dialog_ok"),
2139                                                       GTK_RESPONSE_ACCEPT,
2140                                                       NULL);
2141                 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2142                                          "Do you want to get online?"), item);
2143                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
2144                                     gtk_label_new (txt), FALSE, FALSE, 0);
2145                 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2146                 g_free (txt);
2147
2148                 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2149                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2150                         /* TODO: Comment about why is this commented out: */
2151                         /* modest_platform_connect_and_wait (); */
2152                 }
2153         }
2154         gtk_widget_destroy (dialog);
2155 }
2156
2157 void
2158 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2159                                      ModestWindow *win)
2160 {
2161         /* g_message ("%s %s", __FUNCTION__, link); */
2162 }
2163
2164
2165 void
2166 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2167                                         ModestWindow *win)
2168 {
2169         modest_platform_activate_uri (link);
2170 }
2171
2172 void
2173 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2174                                           ModestWindow *win)
2175 {
2176         modest_platform_show_uri_popup (link);
2177 }
2178
2179 void
2180 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2181                                              ModestWindow *win)
2182 {
2183         modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2184 }
2185
2186 void
2187 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2188                                           const gchar *address,
2189                                           ModestWindow *win)
2190 {
2191         /* g_message ("%s %s", __FUNCTION__, address); */
2192 }
2193
2194 static void
2195 on_save_to_drafts_cb (ModestMailOperation *mail_op,
2196                       TnyMsg *saved_draft,
2197                       gpointer user_data)
2198 {
2199         ModestMsgEditWindow *edit_window;
2200         ModestMainWindow *win;
2201
2202         /* FIXME. Make the header view sensitive again. This is a
2203          * temporary hack. See modest_ui_actions_on_save_to_drafts()
2204          * for details */
2205         win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2206                                          modest_runtime_get_window_mgr(), FALSE));
2207         if (win != NULL) {
2208                 GtkWidget *hdrview = modest_main_window_get_child_widget(
2209                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2210                 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2211         }
2212
2213         edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2214
2215         /* If there was any error do nothing */
2216         if (modest_mail_operation_get_error (mail_op) != NULL)
2217                 return;
2218
2219         modest_msg_edit_window_set_draft (edit_window, saved_draft);
2220 }
2221
2222 void
2223 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2224 {
2225         TnyTransportAccount *transport_account;
2226         ModestMailOperation *mail_operation;
2227         MsgData *data;
2228         gchar *account_name, *from;
2229         ModestAccountMgr *account_mgr;
2230         char *info_text;
2231
2232         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
2233
2234         data = modest_msg_edit_window_get_msg_data (edit_window);
2235
2236         account_name = g_strdup (data->account_name);
2237         account_mgr = modest_runtime_get_account_mgr();
2238         if (!account_name)
2239                 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2240         if (!account_name)
2241                 account_name = modest_account_mgr_get_default_account (account_mgr);
2242         if (!account_name) {
2243                 g_printerr ("modest: no account found\n");
2244                 modest_msg_edit_window_free_msg_data (edit_window, data);
2245                 return;
2246         }
2247
2248         if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2249                 account_name = g_strdup (data->account_name);
2250         }
2251
2252         transport_account =
2253                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2254                                       (modest_runtime_get_account_store(),
2255                                        account_name,
2256                                        TNY_ACCOUNT_TYPE_TRANSPORT));
2257         if (!transport_account) {
2258                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2259                 g_free (account_name);
2260                 modest_msg_edit_window_free_msg_data (edit_window, data);
2261                 return;
2262         }
2263         from = modest_account_mgr_get_from_string (account_mgr, account_name);
2264
2265         /* Create the mail operation */
2266         mail_operation = modest_mail_operation_new (G_OBJECT(edit_window));
2267         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2268
2269         modest_mail_operation_save_to_drafts (mail_operation,
2270                                               transport_account,
2271                                               data->draft_msg,
2272                                               from,
2273                                               data->to,
2274                                               data->cc,
2275                                               data->bcc,
2276                                               data->subject,
2277                                               data->plain_body,
2278                                               data->html_body,
2279                                               data->attachments,
2280                                               data->images,
2281                                               data->priority_flags,
2282                                               on_save_to_drafts_cb,
2283                                               edit_window);
2284         info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
2285         modest_platform_information_banner (NULL, NULL, info_text);
2286
2287         /* Frees */
2288         g_free (info_text);
2289         g_free (from);
2290         g_free (account_name);
2291         g_object_unref (G_OBJECT (transport_account));
2292         g_object_unref (G_OBJECT (mail_operation));
2293
2294         modest_msg_edit_window_free_msg_data (edit_window, data);
2295         modest_msg_edit_window_reset_modified (edit_window);
2296
2297         /* ** FIXME **
2298          * If the drafts folder is selected then make the header view
2299          * insensitive while the message is being saved to drafts
2300          * (it'll be sensitive again in on_save_to_drafts_cb()). This
2301          * is not very clean but it avoids letting the drafts folder
2302          * in an inconsistent state: the user could edit the message
2303          * being saved and undesirable things would happen.
2304          * In the average case the user won't notice anything at
2305          * all. In the worst case (the user is editing a really big
2306          * file from Drafts) the header view will be insensitive
2307          * during the saving process (10 or 20 seconds, depending on
2308          * the message). Anyway this is just a quick workaround: once
2309          * we find a better solution it should be removed
2310          * See NB#65125 (commend #18) for details.
2311          */
2312         ModestMainWindow *win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2313                 modest_runtime_get_window_mgr(), FALSE));
2314         if (win != NULL) {
2315                 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
2316                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
2317                 if (view != NULL) {
2318                         TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
2319                         if (folder) {
2320                                 if (modest_tny_folder_is_local_folder(folder)) {
2321                                         TnyFolderType folder_type;
2322                                         folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
2323                                         if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
2324                                                 GtkWidget *hdrview = modest_main_window_get_child_widget(
2325                                                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2326                                                 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
2327                                         }
2328                                 }
2329                         }
2330                         if (folder != NULL) g_object_unref(folder);
2331                 }
2332         }
2333 }
2334
2335 /* For instance, when clicking the Send toolbar button when editing a message: */
2336 void
2337 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2338 {
2339         TnyTransportAccount *transport_account = NULL;
2340
2341         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
2342
2343         if (!modest_msg_edit_window_check_names (edit_window, TRUE))
2344                 return;
2345
2346         /* FIXME: Code added just for testing. The final version will
2347            use the send queue provided by tinymail and some
2348            classifier */
2349         MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
2350
2351         ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
2352         gchar *account_name = g_strdup (data->account_name);
2353         if (!account_name)
2354                 g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2355
2356         if (!account_name)
2357                 account_name = modest_account_mgr_get_default_account (account_mgr);
2358
2359         if (!account_name) {
2360                 modest_msg_edit_window_free_msg_data (edit_window, data);
2361                 /* Run account setup wizard */
2362                 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window)))
2363                         return;
2364         }
2365
2366         /* Get the currently-active transport account for this modest account: */
2367 /*      TnyTransportAccount *transport_account = */
2368 /*              TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection */
2369 /*                                    (modest_runtime_get_account_store(), */
2370 /*                                     account_name)); */
2371         if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
2372                 transport_account = TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2373                                                           (modest_runtime_get_account_store(),
2374                                                            account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
2375         }
2376
2377         if (!transport_account) {
2378                 /* Run account setup wizard */
2379                 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
2380                         return;
2381         }
2382
2383         gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
2384
2385         /* Create the mail operation */
2386         ModestMailOperation *mail_operation = modest_mail_operation_new (G_OBJECT(edit_window));
2387         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2388
2389         modest_mail_operation_send_new_mail (mail_operation,
2390                                              transport_account,
2391                                              data->draft_msg,
2392                                              from,
2393                                              data->to,
2394                                              data->cc,
2395                                              data->bcc,
2396                                              data->subject,
2397                                              data->plain_body,
2398                                              data->html_body,
2399                                              data->attachments,
2400                                              data->images,
2401                                              data->priority_flags);
2402
2403         /* Free data: */
2404         g_free (from);
2405         g_free (account_name);
2406         g_object_unref (G_OBJECT (transport_account));
2407         g_object_unref (G_OBJECT (mail_operation));
2408
2409         modest_msg_edit_window_free_msg_data (edit_window, data);
2410         modest_msg_edit_window_set_sent (edit_window, TRUE);
2411
2412         /* Save settings and close the window: */
2413         modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2414 }
2415
2416 void
2417 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2418                                   ModestMsgEditWindow *window)
2419 {
2420         ModestMsgEditFormatState *format_state = NULL;
2421
2422         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2423         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2424
2425         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2426                 return;
2427
2428         format_state = modest_msg_edit_window_get_format_state (window);
2429         g_return_if_fail (format_state != NULL);
2430
2431         format_state->bold = gtk_toggle_action_get_active (action);
2432         modest_msg_edit_window_set_format_state (window, format_state);
2433         g_free (format_state);
2434
2435 }
2436
2437 void
2438 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2439                                      ModestMsgEditWindow *window)
2440 {
2441         ModestMsgEditFormatState *format_state = NULL;
2442
2443         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2444         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2445
2446         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2447                 return;
2448
2449         format_state = modest_msg_edit_window_get_format_state (window);
2450         g_return_if_fail (format_state != NULL);
2451
2452         format_state->italics = gtk_toggle_action_get_active (action);
2453         modest_msg_edit_window_set_format_state (window, format_state);
2454         g_free (format_state);
2455
2456 }
2457
2458 void
2459 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2460                                      ModestMsgEditWindow *window)
2461 {
2462         ModestMsgEditFormatState *format_state = NULL;
2463
2464         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2465         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2466
2467         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2468                 return;
2469
2470         format_state = modest_msg_edit_window_get_format_state (window);
2471         g_return_if_fail (format_state != NULL);
2472
2473         format_state->bullet = gtk_toggle_action_get_active (action);
2474         modest_msg_edit_window_set_format_state (window, format_state);
2475         g_free (format_state);
2476
2477 }
2478
2479 void
2480 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2481                                      GtkRadioAction *selected,
2482                                      ModestMsgEditWindow *window)
2483 {
2484         ModestMsgEditFormatState *format_state = NULL;
2485         GtkJustification value;
2486
2487         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2488
2489         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2490                 return;
2491
2492         value = gtk_radio_action_get_current_value (selected);
2493
2494         format_state = modest_msg_edit_window_get_format_state (window);
2495         g_return_if_fail (format_state != NULL);
2496
2497         format_state->justification = value;
2498         modest_msg_edit_window_set_format_state (window, format_state);
2499         g_free (format_state);
2500 }
2501
2502 void
2503 modest_ui_actions_on_select_editor_color (GtkAction *action,
2504                                           ModestMsgEditWindow *window)
2505 {
2506         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2507         g_return_if_fail (GTK_IS_ACTION (action));
2508
2509         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2510                 return;
2511
2512         modest_msg_edit_window_select_color (window);
2513 }
2514
2515 void
2516 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2517                                                      ModestMsgEditWindow *window)
2518 {
2519         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2520         g_return_if_fail (GTK_IS_ACTION (action));
2521
2522         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2523                 return;
2524
2525         modest_msg_edit_window_select_background_color (window);
2526 }
2527
2528 void
2529 modest_ui_actions_on_insert_image (GtkAction *action,
2530                                    ModestMsgEditWindow *window)
2531 {
2532         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2533         g_return_if_fail (GTK_IS_ACTION (action));
2534
2535         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2536                 return;
2537
2538         modest_msg_edit_window_insert_image (window);
2539 }
2540
2541 void
2542 modest_ui_actions_on_attach_file (GtkAction *action,
2543                                   ModestMsgEditWindow *window)
2544 {
2545         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2546         g_return_if_fail (GTK_IS_ACTION (action));
2547
2548         modest_msg_edit_window_offer_attach_file (window);
2549 }
2550
2551 void
2552 modest_ui_actions_on_remove_attachments (GtkAction *action,
2553                                          ModestMsgEditWindow *window)
2554 {
2555         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2556         g_return_if_fail (GTK_IS_ACTION (action));
2557
2558         modest_msg_edit_window_remove_attachments (window, NULL);
2559 }
2560
2561 static void
2562 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2563                                             gpointer user_data)
2564 {
2565         ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2566         const GError *error = modest_mail_operation_get_error (mail_op);
2567
2568         if(error) {
2569                 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2570                                                     _("mail_in_ui_folder_create_error"));
2571         }
2572 }
2573
2574 static void
2575 modest_ui_actions_create_folder(GtkWidget *parent_window,
2576                                 GtkWidget *folder_view)
2577 {
2578         TnyFolderStore *parent_folder;
2579
2580         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2581
2582         if (parent_folder) {
2583                 gboolean finished = FALSE;
2584                 gint result;
2585                 gchar *folder_name = NULL, *suggested_name = NULL;
2586                 const gchar *proto_str = NULL;
2587                 TnyAccount *account;
2588
2589                 if (TNY_IS_ACCOUNT (parent_folder))
2590                         account = g_object_ref (parent_folder);
2591                 else
2592                         account = tny_folder_get_account (TNY_FOLDER (parent_folder));
2593                 proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2594
2595                 if (proto_str && modest_protocol_info_get_transport_store_protocol (proto_str) ==
2596                     MODEST_PROTOCOL_STORE_POP) {
2597                         finished = TRUE;
2598                         hildon_banner_show_information (NULL, NULL, _("mail_in_ui_folder_create_error"));
2599                 }
2600                 g_object_unref (account);
2601
2602                 /* Run the new folder dialog */
2603                 while (!finished) {
2604                         result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2605                                                                         parent_folder,
2606                                                                         suggested_name,
2607                                                                         &folder_name);
2608
2609                         g_free (suggested_name);
2610                         suggested_name = NULL;
2611
2612                         if (result == GTK_RESPONSE_ACCEPT) {
2613                                 ModestMailOperation *mail_op;
2614                                 TnyFolder *new_folder = NULL;
2615
2616                                 mail_op  = modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
2617                                                                                           modest_ui_actions_new_folder_error_handler,
2618                                                                                           parent_window, NULL);
2619
2620                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2621                                                                  mail_op);
2622                                 new_folder = modest_mail_operation_create_folder (mail_op,
2623                                                                                   parent_folder,
2624                                                                                   (const gchar *) folder_name);
2625                                 if (new_folder) {
2626                                         modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2627                                                                           new_folder, TRUE);
2628
2629                                         g_object_unref (new_folder);
2630                                         finished = TRUE;
2631                                 }
2632                                 g_object_unref (mail_op);
2633                         } else {
2634                                 finished = TRUE;
2635                         }
2636
2637                         suggested_name = folder_name;
2638                         folder_name = NULL;
2639                 }
2640
2641                 g_object_unref (parent_folder);
2642         }
2643 }
2644
2645 void
2646 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2647 {
2648         GtkWidget *folder_view;
2649
2650         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2651
2652         folder_view = modest_main_window_get_child_widget (main_window,
2653                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2654         if (!folder_view)
2655                 return;
2656
2657         modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2658 }
2659
2660 static void
2661 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2662                                                gpointer user_data)
2663 {
2664         ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2665         const GError *error = NULL;
2666         const gchar *message = NULL;
2667
2668         /* Get error message */
2669         error = modest_mail_operation_get_error (mail_op);
2670         if (!error)
2671                 g_return_if_reached ();
2672
2673         switch (error->code) {
2674         case MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS:
2675                 message = _CS("ckdg_ib_folder_already_exists");
2676                 break;
2677         default:
2678                 g_warning ("%s: BUG: unexpected error:[%d]: %s", __FUNCTION__,
2679                            error->code, error->message);
2680                 return;
2681         }
2682
2683         modest_platform_information_banner (GTK_WIDGET (window), NULL, message);
2684 }
2685
2686 void
2687 modest_ui_actions_on_rename_folder (GtkAction *action,
2688                                      ModestMainWindow *main_window)
2689 {
2690         TnyFolderStore *folder;
2691         GtkWidget *folder_view;
2692         GtkWidget *header_view;
2693
2694         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2695
2696         folder_view = modest_main_window_get_child_widget (main_window,
2697                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2698         if (!folder_view)
2699                 return;
2700
2701         header_view = modest_main_window_get_child_widget (main_window,
2702                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2703
2704         if (!header_view)
2705                 return;
2706
2707         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2708
2709         if (!folder)
2710                 return;
2711
2712         if (TNY_IS_FOLDER (folder)) {
2713                 gchar *folder_name;
2714                 gint response;
2715                 const gchar *current_name;
2716                 TnyFolderStore *parent;
2717                 gboolean do_rename = TRUE;
2718
2719                 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2720                 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
2721                 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window),
2722                                                                      parent, current_name,
2723                                                                      &folder_name);
2724                 g_object_unref (parent);
2725
2726                 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
2727                         do_rename = FALSE;
2728                 } else if (modest_platform_is_network_folderstore(folder) &&
2729                            !tny_device_is_online (modest_runtime_get_device())) {
2730                         TnyAccount *account = tny_folder_get_account(TNY_FOLDER(folder));
2731                         do_rename = modest_platform_connect_and_wait(GTK_WINDOW(main_window), account);
2732                         g_object_unref(account);
2733                 }
2734
2735                 if (do_rename) {
2736                         ModestMailOperation *mail_op;
2737                         GtkTreeSelection *sel = NULL;
2738
2739                         mail_op =
2740                                 modest_mail_operation_new_with_error_handling (G_OBJECT(main_window),
2741                                                                                modest_ui_actions_rename_folder_error_handler,
2742                                                                                main_window, NULL);
2743
2744                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2745                                                          mail_op);
2746
2747                         /* Clear the headers view */
2748                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2749                         gtk_tree_selection_unselect_all (sel);
2750
2751                         /* Select *after* the changes */
2752                         modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2753                                                           TNY_FOLDER(folder), TRUE);
2754
2755                         /* Actually rename the folder */
2756                         modest_mail_operation_rename_folder (mail_op,
2757                                                              TNY_FOLDER (folder),
2758                                                              (const gchar *) folder_name);
2759
2760                         g_object_unref (mail_op);
2761                         g_free (folder_name);
2762                 }
2763         }
2764         g_object_unref (folder);
2765 }
2766
2767 static void
2768 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2769                                                gpointer user_data)
2770 {
2771         GObject *win = modest_mail_operation_get_source (mail_op);
2772
2773         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2774                                                 _("mail_in_ui_folder_delete_error"));
2775         g_object_unref (win);
2776 }
2777
2778 static gboolean
2779 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2780 {
2781         TnyFolderStore *folder;
2782         GtkWidget *folder_view;
2783         gint response;
2784         gchar *message;
2785         gboolean do_delete = TRUE;
2786
2787         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (main_window), FALSE);
2788
2789         folder_view = modest_main_window_get_child_widget (main_window,
2790                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2791         if (!folder_view)
2792                 return FALSE;
2793
2794         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2795
2796         /* Show an error if it's an account */
2797         if (!TNY_IS_FOLDER (folder)) {
2798                 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2799                                                         _("mail_in_ui_folder_delete_error"));
2800                 g_object_unref (G_OBJECT (folder));
2801                 return FALSE;
2802         }
2803
2804         /* Ask the user */
2805         message =  g_strdup_printf (_("mcen_nc_delete_folder_text"),
2806                                     tny_folder_get_name (TNY_FOLDER (folder)));
2807         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2808                                                             (const gchar *) message);
2809         g_free (message);
2810
2811         if (response != GTK_RESPONSE_OK) {
2812                 do_delete = FALSE;
2813         } else if (modest_platform_is_network_folderstore(folder) &&
2814                    !tny_device_is_online (modest_runtime_get_device())) {
2815                 TnyAccount *account = tny_folder_get_account(TNY_FOLDER(folder));
2816                 do_delete = modest_platform_connect_and_wait(GTK_WINDOW(main_window), account);
2817                 g_object_unref(account);
2818         }
2819
2820         if (do_delete) {
2821                 ModestMailOperation *mail_op;
2822                 GtkTreeSelection *sel;
2823
2824                 /* Unselect the folder before deleting it to free the headers */
2825                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2826                 gtk_tree_selection_unselect_all (sel);
2827
2828                 /* Create the mail operation */
2829                 mail_op =
2830                         modest_mail_operation_new_with_error_handling (G_OBJECT(main_window),
2831                                                                        modest_ui_actions_delete_folder_error_handler,
2832                                                                        NULL, NULL);
2833
2834                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2835                                                  mail_op);
2836                 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2837                 g_object_unref (G_OBJECT (mail_op));
2838         }
2839
2840         g_object_unref (G_OBJECT (folder));
2841
2842         return do_delete;
2843 }
2844
2845 void
2846 modest_ui_actions_on_delete_folder (GtkAction *action,
2847                                      ModestMainWindow *main_window)
2848 {
2849         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2850
2851         if (delete_folder (main_window, FALSE)) {
2852                 GtkWidget *folder_view;
2853
2854                 folder_view = modest_main_window_get_child_widget (main_window,
2855                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2856                 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
2857         }
2858 }
2859
2860 void
2861 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2862 {
2863         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2864
2865         delete_folder (main_window, TRUE);
2866 }
2867
2868
2869 static void
2870 show_error (GtkWidget *parent_widget, const gchar* text)
2871 {
2872         hildon_banner_show_information(parent_widget, NULL, text);
2873
2874 #if 0
2875         GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); */
2876         /*
2877           GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
2878           (GtkDialogFlags)0,
2879           GTK_MESSAGE_ERROR,
2880           GTK_BUTTONS_OK,
2881           text ));
2882         */
2883
2884         gtk_dialog_run (dialog);
2885         gtk_widget_destroy (GTK_WIDGET (dialog));
2886 #endif
2887 }
2888
2889 void
2890 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2891                                          const gchar* server_account_name,
2892                                          gchar **username,
2893                                          gchar **password,
2894                                          gboolean *cancel,
2895                                          gboolean *remember,
2896                                          ModestMainWindow *main_window)
2897 {
2898         g_return_if_fail(server_account_name);
2899
2900         /* Initalize output parameters: */
2901         if (cancel)
2902                 *cancel = FALSE;
2903
2904         if (remember)
2905                 *remember = TRUE;
2906
2907 #ifdef MODEST_PLATFORM_MAEMO
2908         /* Maemo uses a different (awkward) button order,
2909          * It should probably just use gtk_alternative_dialog_button_order ().
2910          */
2911         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2912                                               NULL,
2913                                               GTK_DIALOG_MODAL,
2914                                               _("mcen_bd_dialog_ok"),
2915                                               GTK_RESPONSE_ACCEPT,
2916                                               _("mcen_bd_dialog_cancel"),
2917                                               GTK_RESPONSE_REJECT,
2918                                               NULL);
2919 #else
2920         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2921                                               NULL,
2922                                               GTK_DIALOG_MODAL,
2923                                               GTK_STOCK_CANCEL,
2924                                               GTK_RESPONSE_REJECT,
2925                                               GTK_STOCK_OK,
2926                                               GTK_RESPONSE_ACCEPT,
2927                                               NULL);
2928 #endif /* MODEST_PLATFORM_MAEMO */
2929
2930         gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2931
2932         gchar *server_name = modest_account_mgr_get_server_account_hostname (
2933                 modest_runtime_get_account_mgr(), server_account_name);
2934         if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2935                 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2936                 if (cancel)
2937                         *cancel = TRUE;
2938                 return;
2939         }
2940
2941         /* This causes a warning because the logical ID has no %s in it,
2942          * though the translation does, but there is not much we can do about that: */
2943         gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2944         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2945                             FALSE, FALSE, 0);
2946         g_free (txt);
2947         g_free (server_name);
2948         server_name = NULL;
2949
2950         /* username: */
2951         gchar *initial_username = modest_account_mgr_get_server_account_username (
2952                 modest_runtime_get_account_mgr(), server_account_name);
2953
2954         GtkWidget *entry_username = gtk_entry_new ();
2955         if (initial_username)
2956                 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2957         /* Dim this if a connection has ever succeeded with this username,
2958          * as per the UI spec: */
2959         const gboolean username_known =
2960                 modest_account_mgr_get_server_account_username_has_succeeded(
2961                         modest_runtime_get_account_mgr(), server_account_name);
2962         gtk_widget_set_sensitive (entry_username, !username_known);
2963
2964 #ifdef MODEST_PLATFORM_MAEMO
2965         /* Auto-capitalization is the default, so let's turn it off: */
2966         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2967
2968         /* Create a size group to be used by all captions.
2969          * Note that HildonCaption does not create a default size group if we do not specify one.
2970          * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2971         GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2972
2973         GtkWidget *caption = hildon_caption_new (sizegroup,
2974                 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2975         gtk_widget_show (entry_username);
2976         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2977                 FALSE, FALSE, MODEST_MARGIN_HALF);
2978         gtk_widget_show (caption);
2979 #else
2980         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2981                             TRUE, FALSE, 0);
2982 #endif /* MODEST_PLATFORM_MAEMO */
2983
2984         /* password: */
2985         GtkWidget *entry_password = gtk_entry_new ();
2986         gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2987         /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2988
2989 #ifdef MODEST_PLATFORM_MAEMO
2990         /* Auto-capitalization is the default, so let's turn it off: */
2991         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2992                 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2993
2994         caption = hildon_caption_new (sizegroup,
2995                 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2996         gtk_widget_show (entry_password);
2997         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2998                 FALSE, FALSE, MODEST_MARGIN_HALF);
2999         gtk_widget_show (caption);
3000         g_object_unref (sizegroup);
3001 #else
3002         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
3003                             TRUE, FALSE, 0);
3004 #endif /* MODEST_PLATFORM_MAEMO */
3005
3006         if (initial_username != NULL)
3007                 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
3008
3009 /* This is not in the Maemo UI spec:
3010         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
3011         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
3012                             TRUE, FALSE, 0);
3013 */
3014
3015         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3016
3017         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
3018                 if (username) {
3019                         *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
3020
3021                         modest_account_mgr_set_server_account_username (
3022                                  modest_runtime_get_account_mgr(), server_account_name,
3023                                  *username);
3024
3025                         const gboolean username_was_changed =
3026                                 (strcmp (*username, initial_username) != 0);
3027                         if (username_was_changed) {
3028                                 g_warning ("%s: tinymail does not yet support changing the "
3029                                         "username in the get_password() callback.\n", __FUNCTION__);
3030                         }
3031                 }
3032
3033                 if (password) {
3034                         *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
3035
3036                         /* We do not save the password in the configuration,
3037                          * because this function is only called for passwords that should
3038                          * not be remembered:
3039                         modest_server_account_set_password (
3040                                  modest_runtime_get_account_mgr(), server_account_name,
3041                                  *password);
3042                         */
3043                 }
3044
3045                 if (cancel)
3046                         *cancel   = FALSE;
3047
3048         } else {
3049                 show_error(GTK_WIDGET (main_window), _("mail_ib_login_cancelled"));
3050
3051                 if (username)
3052                         *username = NULL;
3053
3054                 if (password)
3055                         *password = NULL;
3056
3057                 if (cancel)
3058                         *cancel   = TRUE;
3059         }
3060
3061 /* This is not in the Maemo UI spec:
3062         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
3063                 *remember = TRUE;
3064         else
3065                 *remember = FALSE;
3066 */
3067
3068         gtk_widget_destroy (dialog);
3069
3070         /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
3071 }
3072
3073 void
3074 modest_ui_actions_on_cut (GtkAction *action,
3075                           ModestWindow *window)
3076 {
3077         GtkWidget *focused_widget;
3078         GtkClipboard *clipboard;
3079
3080         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3081         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3082         if (GTK_IS_EDITABLE (focused_widget)) {
3083                 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
3084                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3085                 gtk_clipboard_store (clipboard);
3086         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3087                 GtkTextBuffer *buffer;
3088
3089                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3090                 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
3091                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3092                 gtk_clipboard_store (clipboard);
3093         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
3094                 TnyList *header_list = modest_header_view_get_selected_headers (
3095                                 MODEST_HEADER_VIEW (focused_widget));
3096                 gboolean continue_download = FALSE;
3097                 gint num_of_unc_msgs;
3098
3099                 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
3100
3101                 if (num_of_unc_msgs) {
3102                         TnyAccount *account = get_account_from_header_list (header_list);
3103                         continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
3104                         g_object_unref (account);
3105                 }
3106
3107                 if (num_of_unc_msgs == 0 || continue_download) {
3108 /*                      modest_platform_information_banner (
3109                                         NULL, NULL, _CS("mcen_ib_getting_items"));*/
3110                         modest_header_view_cut_selection (
3111                                         MODEST_HEADER_VIEW (focused_widget));
3112                 }
3113
3114                 g_object_unref (header_list);
3115         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3116                 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
3117         }
3118 }
3119
3120 void
3121 modest_ui_actions_on_copy (GtkAction *action,
3122                            ModestWindow *window)
3123 {
3124         GtkClipboard *clipboard;
3125         GtkWidget *focused_widget;
3126         gboolean copied = TRUE;
3127
3128         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3129         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3130
3131         if (GTK_IS_LABEL (focused_widget)) {
3132                 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
3133                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3134                 gtk_clipboard_store (clipboard);
3135         } else if (GTK_IS_EDITABLE (focused_widget)) {
3136                 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
3137                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3138                 gtk_clipboard_store (clipboard);
3139         } else if (GTK_IS_HTML (focused_widget)) {
3140                 gtk_html_copy (GTK_HTML (focused_widget));
3141                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3142                 gtk_clipboard_store (clipboard);
3143         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3144                 GtkTextBuffer *buffer;
3145                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3146                 gtk_text_buffer_copy_clipboard (buffer, clipboard);
3147                 gtk_clipboard_set_can_store (clipboard, NULL, 0);
3148                 gtk_clipboard_store (clipboard);
3149         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
3150                 TnyList *header_list = modest_header_view_get_selected_headers (
3151                                 MODEST_HEADER_VIEW (focused_widget));
3152                 gboolean continue_download = FALSE;
3153                 gint num_of_unc_msgs;
3154
3155                 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
3156
3157                 if (num_of_unc_msgs) {
3158                         TnyAccount *account = get_account_from_header_list (header_list);
3159                         continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
3160                         g_object_unref (account);
3161                 }
3162
3163                 if (num_of_unc_msgs == 0 || continue_download) {
3164                         modest_platform_information_banner (
3165                                         NULL, NULL, _CS("mcen_ib_getting_items"));
3166                         modest_header_view_copy_selection (
3167                                         MODEST_HEADER_VIEW (focused_widget));
3168                 } else
3169                         copied = FALSE;
3170
3171                 g_object_unref (header_list);
3172
3173         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3174                 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
3175         }
3176
3177         /* Show information banner if there was a copy to clipboard */
3178         if(copied)
3179                 modest_platform_information_banner (
3180                                 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
3181 }
3182
3183 void
3184 modest_ui_actions_on_undo (GtkAction *action,
3185                            ModestWindow *window)
3186 {
3187         ModestEmailClipboard *clipboard = NULL;
3188
3189         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3190                 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
3191         } else if (MODEST_IS_MAIN_WINDOW (window)) {
3192                 /* Clear clipboard source */
3193                 clipboard = modest_runtime_get_email_clipboard ();
3194                 modest_email_clipboard_clear (clipboard);
3195         }
3196         else {
3197                 g_return_if_reached ();
3198         }
3199 }
3200
3201 void
3202 modest_ui_actions_on_redo (GtkAction *action,
3203                            ModestWindow *window)
3204 {
3205         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3206                 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
3207         }
3208         else {
3209                 g_return_if_reached ();
3210         }
3211 }
3212
3213
3214 static void
3215 destroy_information_note (ModestMailOperation *mail_op, gpointer user_data)
3216 {
3217         /* destroy information note */
3218         gtk_widget_destroy (GTK_WIDGET(user_data));
3219 }
3220
3221
3222 static void
3223 paste_as_attachment_free (gpointer data)
3224 {
3225         PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
3226
3227         gtk_widget_destroy (helper->banner);
3228         g_object_unref (helper->banner);
3229         g_free (helper);
3230 }
3231
3232 static void
3233 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
3234                             TnyHeader *header,
3235                             TnyMsg *msg,
3236                             gpointer userdata)
3237 {
3238         PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
3239         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
3240
3241         if (msg == NULL)
3242                 return;
3243
3244         modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
3245
3246 }
3247
3248 void
3249 modest_ui_actions_on_paste (GtkAction *action,
3250                             ModestWindow *window)
3251 {
3252         GtkWidget *focused_widget = NULL;
3253         GtkWidget *inf_note = NULL;
3254         ModestMailOperation *mail_op = NULL;
3255
3256         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3257         if (GTK_IS_EDITABLE (focused_widget)) {
3258                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
3259         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3260                 ModestEmailClipboard *e_clipboard = NULL;
3261                 e_clipboard = modest_runtime_get_email_clipboard ();
3262                 if (modest_email_clipboard_cleared (e_clipboard)) {
3263                         GtkTextBuffer *buffer;
3264                         GtkClipboard *clipboard;
3265
3266                         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3267                         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3268                         gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
3269                 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3270                         ModestMailOperation *mail_op;
3271                         TnyFolder *src_folder;
3272                         TnyList *data;
3273                         gboolean delete;
3274                         PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
3275                         helper->window = MODEST_MSG_EDIT_WINDOW (window);
3276                         helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3277                                                                            _CS("ckct_nw_pasting"));
3278                         modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
3279                         mail_op = modest_mail_operation_new (G_OBJECT (window));
3280                         if (helper->banner != NULL) {
3281                                 g_object_ref (G_OBJECT (helper->banner));
3282                                 gtk_window_set_modal (GTK_WINDOW (helper->banner), FALSE);
3283                                 gtk_widget_show (GTK_WIDGET (helper->banner));
3284                         }
3285
3286                         if (data != NULL) {
3287                                 modest_mail_operation_get_msgs_full (mail_op,
3288                                                                      data,
3289                                                                      (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
3290                                                                      helper,
3291                                                                      paste_as_attachment_free);
3292                         }
3293                 }
3294         } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3295                 ModestEmailClipboard *clipboard = NULL;
3296                 TnyFolder *src_folder = NULL;
3297                 TnyFolderStore *folder_store = NULL;
3298                 TnyList *data = NULL;
3299                 gboolean delete = FALSE;
3300
3301                 /* Check clipboard source */
3302                 clipboard = modest_runtime_get_email_clipboard ();
3303                 if (modest_email_clipboard_cleared (clipboard))
3304                         return;
3305
3306                 /* Get elements to paste */
3307                 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
3308
3309                 /* Create a new mail operation */
3310                 mail_op = modest_mail_operation_new (G_OBJECT(window));
3311
3312                 /* Get destination folder */
3313                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
3314
3315                 /* transfer messages  */
3316                 if (data != NULL) {
3317                         gint response = 0;
3318
3319                         /* Ask for user confirmation */
3320                         response =
3321                                 modest_ui_actions_msgs_move_to_confirmation (window,
3322                                                                              TNY_FOLDER (folder_store),
3323                                                                              delete,
3324                                                                              data);
3325
3326                         if (response == GTK_RESPONSE_OK) {
3327                                 /* Launch notification */
3328                                 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3329                                                                              _CS("ckct_nw_pasting"));
3330                                 if (inf_note != NULL)  {
3331                                         gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3332                                         gtk_widget_show (GTK_WIDGET(inf_note));
3333                                 }
3334
3335                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3336                                 modest_mail_operation_xfer_msgs (mail_op,
3337                                                                  data,
3338                                                                  TNY_FOLDER (folder_store),
3339                                                                  delete,
3340                                                                  destroy_information_note,
3341                                                                  inf_note);
3342                         } else {
3343                                 g_object_unref (mail_op);
3344                         }
3345
3346                 } else if (src_folder != NULL) {
3347                         /* Launch notification */
3348                         inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3349                                                                      _CS("ckct_nw_pasting"));
3350                         if (inf_note != NULL)  {
3351                                 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3352                                 gtk_widget_show (GTK_WIDGET(inf_note));
3353                         }
3354
3355                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3356                         modest_mail_operation_xfer_folder (mail_op,
3357                                                            src_folder,
3358                                                            folder_store,
3359                                                            delete,
3360                                                            destroy_information_note,
3361                                                            inf_note);
3362                 }
3363
3364                 /* Free */
3365                 if (data != NULL)
3366                         g_object_unref (data);
3367                 if (src_folder != NULL)
3368                         g_object_unref (src_folder);
3369                 if (folder_store != NULL)
3370                         g_object_unref (folder_store);
3371         }
3372 }
3373
3374
3375 void
3376 modest_ui_actions_on_select_all (GtkAction *action,
3377                                  ModestWindow *window)
3378 {
3379         GtkWidget *focused_widget;
3380
3381         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3382         if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
3383                 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
3384         } else if (GTK_IS_LABEL (focused_widget)) {
3385                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
3386         } else if (GTK_IS_EDITABLE (focused_widget)) {
3387                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
3388         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3389                 GtkTextBuffer *buffer;
3390                 GtkTextIter start, end;
3391
3392                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3393                 gtk_text_buffer_get_start_iter (buffer, &start);
3394                 gtk_text_buffer_get_end_iter (buffer, &end);
3395                 gtk_text_buffer_select_range (buffer, &start, &end);
3396         } else if (GTK_IS_HTML (focused_widget)) {
3397                 gtk_html_select_all (GTK_HTML (focused_widget));
3398         } else if (MODEST_IS_MAIN_WINDOW (window)) {
3399                 GtkWidget *header_view = focused_widget;
3400                 GtkTreeSelection *selection = NULL;
3401
3402                 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
3403                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3404                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3405                 }
3406
3407                 /* Disable window dimming management */
3408                 modest_window_disable_dimming (MODEST_WINDOW(window));
3409
3410                 /* Select all messages */
3411                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
3412                 gtk_tree_selection_select_all (selection);
3413
3414                 /* Set focuse on header view */
3415                 gtk_widget_grab_focus (header_view);
3416
3417
3418                 /* Enable window dimming management */
3419                 modest_window_enable_dimming (MODEST_WINDOW(window));
3420                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
3421         }
3422
3423 }
3424
3425 void
3426 modest_ui_actions_on_mark_as_read (GtkAction *action,
3427                                    ModestWindow *window)
3428 {
3429         g_return_if_fail (MODEST_IS_WINDOW(window));
3430
3431         /* Mark each header as read */
3432         do_headers_action (window, headers_action_mark_as_read, NULL);
3433 }
3434
3435 void
3436 modest_ui_actions_on_mark_as_unread (GtkAction *action,
3437                                      ModestWindow *window)
3438 {
3439         g_return_if_fail (MODEST_IS_WINDOW(window));
3440
3441         /* Mark each header as read */
3442         do_headers_action (window, headers_action_mark_as_unread, NULL);
3443 }
3444
3445 void
3446 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
3447                                   GtkRadioAction *selected,
3448                                   ModestWindow *window)
3449 {
3450         gint value;
3451
3452         value = gtk_radio_action_get_current_value (selected);
3453         if (MODEST_IS_WINDOW (window)) {
3454                 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
3455         }
3456 }
3457
3458 void
3459 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
3460                                                GtkRadioAction *selected,
3461                                                ModestWindow *window)
3462 {
3463         TnyHeaderFlags flags;
3464         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3465
3466         flags = gtk_radio_action_get_current_value (selected);
3467         modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
3468 }
3469
3470 void
3471 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
3472                                                   GtkRadioAction *selected,
3473                                                   ModestWindow *window)
3474 {
3475         gint file_format;
3476
3477         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3478
3479         file_format = gtk_radio_action_get_current_value (selected);
3480         modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
3481 }
3482
3483
3484 void
3485 modest_ui_actions_on_zoom_plus (GtkAction *action,
3486                                 ModestWindow *window)
3487 {
3488         g_return_if_fail (MODEST_IS_WINDOW (window));
3489
3490         modest_window_zoom_plus (MODEST_WINDOW (window));
3491 }
3492
3493 void
3494 modest_ui_actions_on_zoom_minus (GtkAction *action,
3495                                  ModestWindow *window)
3496 {
3497         g_return_if_fail (MODEST_IS_WINDOW (window));
3498
3499         modest_window_zoom_minus (MODEST_WINDOW (window));
3500 }
3501
3502 void
3503 modest_ui_actions_on_toggle_fullscreen    (GtkToggleAction *toggle,
3504                                            ModestWindow *window)
3505 {
3506         ModestWindowMgr *mgr;
3507         gboolean fullscreen, active;
3508         g_return_if_fail (MODEST_IS_WINDOW (window));
3509
3510         mgr = modest_runtime_get_window_mgr ();
3511
3512         active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
3513         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3514
3515         if (active != fullscreen) {
3516                 modest_window_mgr_set_fullscreen_mode (mgr, active);
3517                 gtk_window_present (GTK_WINDOW (window));
3518         }
3519 }
3520
3521 void
3522 modest_ui_actions_on_change_fullscreen (GtkAction *action,
3523                                         ModestWindow *window)
3524 {
3525         ModestWindowMgr *mgr;
3526         gboolean fullscreen;
3527
3528         g_return_if_fail (MODEST_IS_WINDOW (window));
3529
3530         mgr = modest_runtime_get_window_mgr ();
3531         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3532         modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
3533
3534         gtk_window_present (GTK_WINDOW (window));
3535 }
3536
3537 /*
3538  * Used by modest_ui_actions_on_details to call do_headers_action
3539  */
3540 static void
3541 headers_action_show_details (TnyHeader *header,
3542                              ModestWindow *window,
3543                              gpointer user_data)
3544
3545 {
3546         GtkWidget *dialog;
3547
3548         /* Create dialog */
3549         dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
3550
3551         /* Run dialog */
3552         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3553         gtk_widget_show_all (dialog);
3554         gtk_dialog_run (GTK_DIALOG (dialog));
3555
3556         gtk_widget_destroy (dialog);
3557 }
3558
3559 /*
3560  * Show the folder details in a ModestDetailsDialog widget
3561  */
3562 static void
3563 show_folder_details (TnyFolder *folder,
3564                      GtkWindow *window)
3565 {
3566         GtkWidget *dialog;
3567
3568         /* Create dialog */
3569         dialog = modest_details_dialog_new_with_folder (window, folder);
3570
3571         /* Run dialog */
3572         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3573         gtk_widget_show_all (dialog);
3574         gtk_dialog_run (GTK_DIALOG (dialog));
3575
3576         gtk_widget_destroy (dialog);
3577 }
3578
3579 /*
3580  * Show the header details in a ModestDetailsDialog widget
3581  */
3582 void
3583 modest_ui_actions_on_details (GtkAction *action,
3584                               ModestWindow *win)
3585 {
3586         TnyList * headers_list;
3587         TnyIterator *iter;
3588         TnyHeader *header;
3589
3590         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3591                 TnyMsg *msg;
3592
3593                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3594                 if (!msg)
3595                         return;
3596                 g_object_unref (msg);
3597
3598                 headers_list = get_selected_headers (win);
3599                 if (!headers_list)
3600                         return;
3601
3602                 iter = tny_list_create_iterator (headers_list);
3603
3604                 header = TNY_HEADER (tny_iterator_get_current (iter));
3605                 if (header) {
3606                         headers_action_show_details (header, win, NULL);
3607                         g_object_unref (header);
3608                 }
3609
3610                 g_object_unref (iter);
3611                 g_object_unref (headers_list);
3612
3613         } else if (MODEST_IS_MAIN_WINDOW (win)) {
3614                 GtkWidget *folder_view, *header_view;
3615
3616                 /* Check which widget has the focus */
3617                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3618                                                                     MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3619                 if (gtk_widget_is_focus (folder_view)) {
3620                         TnyFolderStore *folder_store
3621                                 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3622                         if (!folder_store) {
3623                                 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3624                                 return;
3625                         }
3626                         /* Show only when it's a folder */
3627                         /* This function should not be called for account items,
3628                          * because we dim the menu item for them. */
3629                         if (TNY_IS_FOLDER (folder_store)) {
3630                                 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3631                         }
3632
3633                         g_object_unref (folder_store);
3634
3635                 } else {
3636                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3637                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3638                         /* Show details of each header */
3639                         do_headers_action (win, headers_action_show_details, header_view);
3640                 }
3641         }
3642 }
3643
3644 void
3645 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3646                                      ModestMsgEditWindow *window)
3647 {
3648         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3649
3650         modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3651 }
3652
3653 void
3654 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3655                                       ModestMsgEditWindow *window)
3656 {
3657         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3658
3659         modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3660 }
3661
3662 void
3663 modest_ui_actions_toggle_folders_view (GtkAction *action,
3664                                        ModestMainWindow *main_window)
3665 {
3666         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3667
3668         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3669                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3670         else
3671                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3672 }
3673
3674 void
3675 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3676                                      ModestWindow *window)
3677 {
3678         gboolean active, fullscreen = FALSE;
3679         ModestWindowMgr *mgr;
3680
3681         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3682
3683         /* Check if we want to toggle the toolbar vuew in fullscreen
3684            or normal mode */
3685         if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3686                      "ViewShowToolbarFullScreen")) {
3687                 fullscreen = TRUE;
3688         }
3689
3690         /* Toggle toolbar */
3691         mgr = modest_runtime_get_window_mgr ();
3692         modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
3693 }
3694
3695 void
3696 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3697                                            ModestMsgEditWindow *window)
3698 {
3699         modest_msg_edit_window_select_font (window);
3700 }
3701
3702 void
3703 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3704                                                   const gchar *display_name,
3705                                                   GtkWindow *window)
3706 {
3707         /* This is usually used to change the title of the main window, which
3708          * is the one that holds the folder view. Note that this change can
3709          * happen even when the widget doesn't have the focus. */
3710         if (display_name)
3711                 gtk_window_set_title (window, display_name);
3712         else
3713                 gtk_window_set_title (window, " ");
3714 }
3715
3716 void
3717 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3718 {
3719         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3720         modest_msg_edit_window_select_contacts (window);
3721 }
3722
3723 void
3724 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3725 {
3726         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3727         modest_msg_edit_window_check_names (window, FALSE);
3728 }
3729
3730 static void
3731 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3732 {
3733         modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3734                                          GTK_WIDGET (user_data));
3735 }
3736
3737 /*
3738  * This function is used to track changes in the selection of the
3739  * folder view that is inside the "move to" dialog to enable/disable
3740  * the OK button because we do not want the user to select a disallowed
3741  * destination for a folder.
3742  * The user also not desired to be able to use NEW button on items where
3743  * folder creation is not possibel.
3744  */
3745 static void
3746 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
3747                                             TnyFolderStore *folder_store,
3748                                             gboolean selected,
3749                                             gpointer user_data)
3750 {
3751         GtkWidget *dialog = NULL;
3752         GtkWidget *ok_button = NULL, *new_button = NULL;
3753         GList *children = NULL;
3754         gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
3755         gboolean moving_folder = FALSE;
3756         gboolean is_local_account = TRUE;
3757         GtkWidget *folder_view = NULL;
3758         ModestTnyFolderRules rules;
3759
3760         if (!selected)
3761                 return;
3762
3763         /* Get the OK button */
3764         dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
3765         if (!dialog)
3766                 return;
3767
3768         children = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
3769         ok_button = GTK_WIDGET (children->next->next->data);
3770         new_button = GTK_WIDGET (children->next->data);
3771         g_list_free (children);
3772
3773         /* check if folder_store is an remote account */
3774         if (TNY_IS_ACCOUNT (folder_store)) {
3775                 TnyAccount *local_account = NULL;
3776                 TnyAccount *mmc_account = NULL;
3777                 ModestTnyAccountStore *account_store = NULL;
3778
3779                 account_store = modest_runtime_get_account_store ();
3780                 local_account = modest_tny_account_store_get_local_folders_account (account_store);
3781                 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
3782
3783                 if ((gpointer) local_account != (gpointer) folder_store &&
3784                     (gpointer) mmc_account != (gpointer) folder_store) {
3785                         is_local_account = FALSE;
3786                         /* New button should be dimmed on remote
3787                            account root */
3788                         new_sensitive = FALSE;
3789                 }
3790                 g_object_unref (local_account);
3791         }
3792
3793         /* Check the target folder rules */
3794         if (TNY_IS_FOLDER (folder_store)) {
3795                 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
3796                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
3797                         ok_sensitive = FALSE;
3798                         new_sensitive = FALSE;
3799                         goto end;
3800                 }
3801         }
3802
3803         /* Check if we're moving a folder */
3804         if (MODEST_IS_MAIN_WINDOW (user_data)) {
3805                 /* Get the widgets */
3806                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
3807                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3808                 if (gtk_widget_is_focus (folder_view))
3809                         moving_folder = TRUE;
3810         }
3811
3812         if (moving_folder) {
3813                 TnyFolderStore *moved_folder = NULL, *parent = NULL;
3814
3815                 /* Get the folder to move */
3816                 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3817
3818                 /* Check that we're not moving to the same folder */
3819                 if (TNY_IS_FOLDER (moved_folder)) {
3820                         parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
3821                         if (parent == folder_store)
3822                                 ok_sensitive = FALSE;
3823                         g_object_unref (parent);
3824                 }
3825
3826                 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
3827                         /* Do not allow to move to an account unless it's the
3828                            local folders account */
3829                         if (!is_local_account)
3830                                 ok_sensitive = FALSE;
3831                 }
3832
3833                 if (ok_sensitive && (moved_folder == folder_store)) {
3834                         /* Do not allow to move to itself */
3835                         ok_sensitive = FALSE;
3836                 }
3837                 g_object_unref (moved_folder);
3838         } else {
3839                 TnyHeader *header = NULL;
3840                 TnyFolder *src_folder = NULL;
3841
3842                 /* Moving a message */
3843                 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
3844                         header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (user_data));
3845                         src_folder = tny_header_get_folder (header);
3846                         g_object_unref (header);
3847                 } else {
3848                         src_folder =
3849                                 TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
3850                 }
3851
3852                 /* Do not allow to move the msg to the same folder */
3853                 /* Do not allow to move the msg to an account */
3854                 if ((gpointer) src_folder == (gpointer) folder_store ||
3855                     TNY_IS_ACCOUNT (folder_store))
3856                         ok_sensitive = FALSE;
3857                 g_object_unref (src_folder);
3858         }
3859
3860  end:
3861         /* Set sensitivity of the OK button */
3862         gtk_widget_set_sensitive (ok_button, ok_sensitive);
3863         /* Set sensitivity of the NEW button */
3864         gtk_widget_set_sensitive (new_button, new_sensitive);
3865 }
3866
3867 static GtkWidget*
3868 create_move_to_dialog (GtkWindow *win,
3869                        GtkWidget *folder_view,
3870                        GtkWidget **tree_view)
3871 {
3872         GtkWidget *dialog, *scroll;
3873         GtkWidget *new_button;
3874
3875         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3876                                               GTK_WINDOW (win),
3877                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3878                                               NULL);
3879
3880         gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
3881         /* We do this manually so GTK+ does not associate a response ID for
3882          * the button. */
3883         new_button = gtk_button_new_from_stock (_("mcen_bd_new"));
3884         gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3885         gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_cancel"), GTK_RESPONSE_REJECT);
3886
3887         /* Create scrolled window */
3888         scroll = gtk_scrolled_window_new (NULL, NULL);
3889         gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scroll),
3890                                          GTK_POLICY_AUTOMATIC,
3891                                          GTK_POLICY_AUTOMATIC);
3892
3893         /* Create folder view */
3894         *tree_view = modest_platform_create_folder_view (NULL);
3895
3896         /* Track changes in the selection to
3897          * disable the OK button whenever "Move to" is not possible
3898          * disbale NEW button whenever New is not possible */
3899         g_signal_connect (*tree_view,
3900                           "folder_selection_changed",
3901                           G_CALLBACK (on_move_to_dialog_folder_selection_changed),
3902                           win);
3903
3904         /* Listen to clicks on New button */
3905         g_signal_connect (G_OBJECT (new_button),
3906                           "clicked",
3907                           G_CALLBACK(create_move_to_dialog_on_new_folder),
3908                           *tree_view);
3909
3910         /* It could happen that we're trying to move a message from a
3911            window (msg window for example) after the main window was
3912            closed, so we can not just get the model of the folder
3913            view */
3914         if (MODEST_IS_FOLDER_VIEW (folder_view)) {
3915                 const gchar *visible_id = NULL;
3916
3917                 modest_folder_view_set_style (MODEST_FOLDER_VIEW (*tree_view),
3918                                               MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
3919                 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
3920                                                MODEST_FOLDER_VIEW(*tree_view));
3921
3922                 visible_id =
3923                         modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
3924
3925                 /* Show the same account than the one that is shown in the main window */
3926                 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(*tree_view),
3927                                                                              visible_id);
3928         } else {
3929                 const gchar *active_account_name = NULL;
3930                 ModestAccountMgr *mgr = NULL;
3931                 ModestAccountData *acc_data = NULL;
3932
3933                 modest_folder_view_set_style (MODEST_FOLDER_VIEW (*tree_view),
3934                                               MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
3935                 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3936                                                  TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3937
3938                 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
3939                 mgr = modest_runtime_get_account_mgr ();
3940                 acc_data = modest_account_mgr_get_account_data (mgr, active_account_name);
3941
3942                 /* Set the new visible & active account */
3943                 if (acc_data && acc_data->store_account) {
3944                         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (*tree_view),
3945                                                                                      acc_data->store_account->account_name);
3946                         modest_account_mgr_free_account_data (mgr, acc_data);
3947                 }
3948         }
3949
3950         /* Hide special folders */
3951         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3952
3953         gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3954
3955         /* Add scroll to dialog */
3956         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3957                             scroll, TRUE, TRUE, 0);
3958
3959         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3960         gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3961
3962         return dialog;
3963 }
3964
3965 /*
3966  * Returns TRUE if at least one of the headers of the list belongs to
3967  * a message that has been fully retrieved.
3968  */
3969 #if 0 /* no longer in use. delete in 2007.10 */
3970 static gboolean
3971 has_retrieved_msgs (TnyList *list)
3972 {
3973         TnyIterator *iter;
3974         gboolean found = FALSE;
3975
3976         iter = tny_list_create_iterator (list);
3977         while (!tny_iterator_is_done (iter) && !found) {
3978                 TnyHeader *header;
3979                 TnyHeaderFlags flags = 0;
3980
3981                 header = TNY_HEADER (tny_iterator_get_current (iter));
3982                 if (header) {
3983                         flags = tny_header_get_flags (header);
3984                         if (flags & TNY_HEADER_FLAG_CACHED)
3985 /*                      if (!(flags & TNY_HEADER_FLAG_PARTIAL)) */
3986                                 found = TRUE;
3987
3988                         g_object_unref (header);
3989                 }
3990
3991                 if (!found)
3992                         tny_iterator_next (iter);
3993         }
3994         g_object_unref (iter);
3995
3996         return found;
3997 }
3998 #endif /* 0 */
3999
4000
4001 /*
4002  * Shows a confirmation dialog to the user when we're moving messages
4003  * from a remote server to the local storage. Returns the dialog
4004  * response. If it's other kind of movement then it always returns
4005  * GTK_RESPONSE_OK
4006  *
4007  * This one is used by the next functions:
4008  *      modest_ui_actions_on_paste                      - commented out
4009  *      drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
4010  */
4011 gint
4012 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
4013                                              TnyFolder *dest_folder,
4014                                              gboolean delete,
4015                                              TnyList *headers)
4016 {
4017         gint response = GTK_RESPONSE_OK;
4018         TnyAccount *account = NULL;
4019         TnyFolder *src_folder = NULL;
4020         TnyIterator *iter = NULL;
4021         TnyHeader *header = NULL;
4022
4023         /* return with OK if the destination is a remote folder */
4024         if (modest_tny_folder_is_remote_folder (dest_folder))
4025                 return GTK_RESPONSE_OK;
4026
4027         /* Get source folder */
4028         iter = tny_list_create_iterator (headers);
4029         header = TNY_HEADER (tny_iterator_get_current (iter));
4030         if (header) {
4031                 src_folder = tny_header_get_folder (header);
4032                 g_object_unref (header);
4033         }
4034         g_object_unref (iter);
4035
4036         /* if no src_folder, message may be an attahcment */
4037         if (src_folder == NULL)
4038                 return GTK_RESPONSE_CANCEL;
4039
4040         /* If the source is a local or MMC folder */
4041         if (!modest_tny_folder_is_remote_folder (src_folder)) {
4042                 g_object_unref (src_folder);
4043                 return GTK_RESPONSE_OK;
4044         }
4045
4046         /* Get the account */
4047         account = tny_folder_get_account (src_folder);
4048
4049         /* now if offline we ask the user */
4050         if(connect_to_get_msg (win, tny_list_get_length (headers), account))
4051                 response = GTK_RESPONSE_OK;
4052         else
4053                 response = GTK_RESPONSE_CANCEL;
4054
4055         /* Frees */
4056         g_object_unref (src_folder);
4057         g_object_unref (account);
4058
4059         return response;
4060 }
4061
4062
4063
4064 static void
4065 move_to_cb (ModestMailOperation *mail_op, gpointer user_data)
4066 {
4067         MoveToHelper *helper = (MoveToHelper *) user_data;
4068
4069         /* Note that the operation could have failed, in that case do
4070            nothing */
4071         if (modest_mail_operation_get_status (mail_op) ==
4072             MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
4073
4074                 GObject *object = modest_mail_operation_get_source (mail_op);
4075                 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
4076                         ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
4077
4078                         if (!modest_msg_view_window_select_next_message (self))
4079                                 if (!modest_msg_view_window_select_previous_message (self))
4080                                         /* No more messages to view, so close this window */
4081                                         modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
4082                 } else if (MODEST_IS_MAIN_WINDOW (object) && helper->reference != NULL) {
4083                         GtkWidget *header_view;
4084                         GtkTreePath *path;
4085                         GtkTreeSelection *sel;
4086
4087                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
4088                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4089                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
4090                         path = gtk_tree_row_reference_get_path (helper->reference);
4091                         gtk_tree_selection_select_path (sel, path);
4092                         gtk_tree_path_free (path);
4093                 }
4094                 g_object_unref (object);
4095         }
4096
4097         /* Close the "Pasting" information banner */
4098         gtk_widget_destroy (GTK_WIDGET(helper->banner));
4099         if (helper->reference != NULL)
4100                 gtk_tree_row_reference_free (helper->reference);
4101         g_free (helper);
4102 }
4103
4104 void
4105 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
4106                                              gpointer user_data)
4107 {
4108         ModestWindow *main_window = NULL;
4109         GObject *win = NULL;
4110         const GError *error = NULL;
4111         const gchar *message = NULL;
4112
4113         /* Get error message */
4114         error = modest_mail_operation_get_error (mail_op);
4115         if (error != NULL && error->message != NULL) {
4116                 message = error->message;
4117         } else {
4118                 message = _("mail_in_ui_folder_move_target_error");
4119         }
4120
4121         /* Disable next automatic folder selection */
4122         main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
4123                                                          FALSE); /* don't create */
4124         if (main_window) {
4125                 GtkWidget *folder_view = NULL;
4126
4127                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
4128                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4129                 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
4130
4131                 if (user_data && TNY_IS_FOLDER (user_data)) {
4132                         modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
4133                                                           TNY_FOLDER (user_data), FALSE);
4134                 }
4135         }
4136
4137         /* Show notification dialog */
4138         win = modest_mail_operation_get_source (mail_op);
4139         modest_platform_run_information_dialog ((GtkWindow *) win, message);
4140         if (win)
4141                 g_object_unref (win);
4142 }
4143
4144 void
4145 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
4146                                               gpointer user_data)
4147 {
4148         GObject *win = modest_mail_operation_get_source (mail_op);
4149         const GError *error = modest_mail_operation_get_error (mail_op);
4150
4151         g_return_if_fail (error != NULL);
4152         if (error->message != NULL)
4153                 g_printerr ("modest: %s\n", error->message);
4154         else
4155                 g_printerr ("modest: unkonw error on send&receive operation");
4156
4157         /* Show error message */
4158 /*      if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
4159 /*              modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
4160 /*                                                      _CS("sfil_ib_unable_to_receive")); */
4161 /*      else  */
4162 /*              modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
4163 /*                                                      _CS("sfil_ib_unable_to_send")); */
4164         g_object_unref (win);
4165 }
4166
4167 static void
4168 open_msg_for_purge_cb (ModestMailOperation *mail_op,
4169                        TnyHeader *header,
4170                        gboolean canceled,
4171                        TnyMsg *msg,
4172                        GError *err,
4173                        gpointer user_data)
4174 {
4175         TnyList *parts;
4176         TnyIterator *iter;
4177         gint pending_purges = 0;
4178         gboolean some_purged = FALSE;
4179         ModestWindow *win = MODEST_WINDOW (user_data);
4180         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
4181
4182         /* If there was any error */
4183         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
4184                 modest_window_mgr_unregister_header (mgr, header);
4185                 return;
4186         }
4187
4188         /* Once the message has been retrieved for purging, we check if
4189          * it's all ok for purging */
4190
4191         parts = tny_simple_list_new ();
4192         tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
4193         iter = tny_list_create_iterator (parts);
4194
4195         while (!tny_iterator_is_done (iter)) {
4196                 TnyMimePart *part;
4197                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
4198                 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
4199                         if (tny_mime_part_is_purged (part))
4200                                 some_purged = TRUE;
4201                         else
4202                                 pending_purges++;
4203                 }
4204
4205                 if (part)
4206                         g_object_unref (part);
4207
4208                 tny_iterator_next (iter);
4209         }
4210         g_object_unref (iter);
4211
4212
4213         if (pending_purges>0) {
4214                 gint response;
4215                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
4216
4217                 if (response == GTK_RESPONSE_OK) {
4218                         modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
4219                         iter = tny_list_create_iterator (parts);
4220                         while (!tny_iterator_is_done (iter)) {
4221                                 TnyMimePart *part;
4222
4223                                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
4224                                 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
4225                                         tny_mime_part_set_purged (part);
4226
4227                                 if (part)
4228                                         g_object_unref (part);
4229
4230                                 tny_iterator_next (iter);
4231                         }
4232
4233                         tny_msg_rewrite_cache (msg);
4234                 }
4235      /* } else { */
4236                 /* This string no longer exists, refer to NB#75415 for more info */
4237                 /* modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged")); */
4238         }
4239         g_object_unref (iter);
4240
4241         modest_window_mgr_unregister_header (mgr, header);
4242
4243         g_object_unref (parts);
4244 }
4245
4246 static void
4247 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
4248                                                      ModestMainWindow *win)
4249 {
4250         GtkWidget *header_view;
4251         TnyList *header_list;
4252         TnyIterator *iter;
4253         TnyHeader *header;
4254         TnyHeaderFlags flags;
4255         ModestWindow *msg_view_window =  NULL;
4256         gboolean found;
4257
4258         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
4259
4260         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4261                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4262
4263         header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
4264         if (!header_list) {
4265                 g_warning ("%s: no header selected", __FUNCTION__);
4266                 return;
4267         }
4268
4269         if (tny_list_get_length (header_list) == 1) {
4270                 iter = tny_list_create_iterator (header_list);
4271                 header = TNY_HEADER (tny_iterator_get_current (iter));
4272                 g_object_unref (iter);
4273         } else
4274                 return;
4275
4276         if (!header || !TNY_IS_HEADER(header)) {
4277                 g_warning ("%s: header is not valid", __FUNCTION__);
4278                 return;
4279         }
4280
4281         found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
4282                                                           header, &msg_view_window);
4283         flags = tny_header_get_flags (header);
4284         if (!(flags & TNY_HEADER_FLAG_CACHED))
4285                 return;
4286         if (found) {
4287                 if (msg_view_window != NULL)
4288                         modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
4289                 else {
4290                         /* do nothing; uid was registered before, so window is probably on it's way */
4291                         g_warning ("debug: header %p has already been registered", header);
4292                 }
4293         } else {
4294                 ModestMailOperation *mail_op = NULL;
4295                 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
4296                 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
4297                                                                          modest_ui_actions_get_msgs_full_error_handler,
4298                                                                          NULL, NULL);
4299                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4300                 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
4301
4302                 g_object_unref (mail_op);
4303         }
4304         if (header)
4305                 g_object_unref (header);
4306         if (header_list)
4307                 g_object_unref (header_list);
4308 }
4309
4310 /**
4311  * Utility function that transfer messages from both the main window
4312  * and the msg view window when using the "Move to" dialog
4313  */
4314 static void
4315 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
4316                                               ModestWindow *win)
4317 {
4318         TnyList *headers = NULL;
4319         TnyAccount *dst_account = NULL;
4320         const gchar *proto_str = NULL;
4321         gboolean dst_is_pop = FALSE;
4322
4323         if (!TNY_IS_FOLDER (dst_folder)) {
4324                 modest_platform_information_banner (GTK_WIDGET (win),
4325                                                     NULL,
4326                                                     _CS("ckdg_ib_unable_to_move_to_current_location"));
4327                 return;
4328         }
4329
4330         dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
4331         proto_str = tny_account_get_proto (dst_account);
4332
4333         /* tinymail will return NULL for local folders it seems */
4334         dst_is_pop = proto_str &&
4335                 (modest_protocol_info_get_transport_store_protocol (proto_str) ==
4336                  MODEST_PROTOCOL_STORE_POP);
4337
4338         g_object_unref (dst_account);
4339
4340         /* Get selected headers */
4341         headers = get_selected_headers (MODEST_WINDOW (win));
4342         if (!headers) {
4343                 g_warning ("%s: no headers selected", __FUNCTION__);
4344                 return;
4345         }
4346
4347
4348         if (dst_is_pop) {
4349                 modest_platform_information_banner (GTK_WIDGET (win),
4350                                                     NULL,
4351                                                     ngettext("mail_in_ui_folder_move_target_error",
4352                                                              "mail_in_ui_folder_move_targets_error",
4353                                                              tny_list_get_length (headers)));
4354                 g_object_unref (headers);
4355                 return;
4356         }
4357
4358         MoveToHelper *helper = g_new0 (MoveToHelper, 1);
4359         helper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
4360                                                            _CS("ckct_nw_pasting"));
4361         if (helper->banner != NULL)  {
4362                 gtk_window_set_modal (GTK_WINDOW(helper->banner), FALSE);
4363                 gtk_widget_show (GTK_WIDGET(helper->banner));
4364         }
4365
4366         if (MODEST_IS_MAIN_WINDOW (win)) {
4367                 GtkWidget *header_view =
4368                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
4369                                                              MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4370                 helper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
4371         }
4372
4373         ModestMailOperation *mail_op =
4374                 modest_mail_operation_new_with_error_handling (G_OBJECT(win),
4375                                                                modest_ui_actions_move_folder_error_handler,
4376                                                                NULL, NULL);
4377         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4378                                          mail_op);
4379
4380         modest_mail_operation_xfer_msgs (mail_op,
4381                                          headers,
4382                                          TNY_FOLDER (dst_folder),
4383                                          TRUE,
4384                                          move_to_cb,
4385                                          helper);
4386
4387         g_object_unref (G_OBJECT (mail_op));
4388         g_object_unref (headers);
4389 }
4390
4391 /*
4392  * UI handler for the "Move to" action when invoked from the
4393  * ModestMainWindow
4394  */
4395 static void
4396 modest_ui_actions_on_main_window_move_to (GtkAction *action,
4397                                           GtkWidget *folder_view,
4398                                           TnyFolderStore *dst_folder,
4399                                           ModestMainWindow *win)
4400 {
4401         ModestHeaderView *header_view = NULL;
4402         ModestMailOperation *mail_op = NULL;
4403         TnyFolderStore *src_folder;
4404         gboolean online = (tny_device_is_online (modest_runtime_get_device()));
4405
4406         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
4407
4408         /* Get the source folder */
4409         src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4410
4411         /* Get header view */
4412         header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW));
4413
4414         /* Get folder or messages to transfer */
4415         if (gtk_widget_is_focus (folder_view)) {
4416                 GtkTreeSelection *sel;
4417                 gboolean do_xfer = TRUE;
4418
4419                 /* Allow only to transfer folders to the local root folder */
4420                 if (TNY_IS_ACCOUNT (dst_folder) &&
4421                     !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder)) {
4422                         do_xfer = FALSE;
4423                 } else if (!TNY_IS_FOLDER (src_folder)) {
4424                         g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
4425                         do_xfer = FALSE;
4426                 } else if (!online && modest_platform_is_network_folderstore(src_folder)) {
4427                         guint num_headers = tny_folder_get_all_count(TNY_FOLDER (src_folder));
4428                         TnyAccount *account = tny_folder_get_account (TNY_FOLDER (src_folder));
4429                         if (!connect_to_get_msg(MODEST_WINDOW (win), num_headers, account))
4430                                 do_xfer = FALSE;
4431                         g_object_unref (account);
4432                 }
4433
4434                 if (do_xfer) {
4435                         MoveToHelper *helper = g_new0 (MoveToHelper, 1);
4436                         helper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
4437                                                                            _CS("ckct_nw_pasting"));
4438                         if (helper->banner != NULL)  {
4439                                 gtk_window_set_modal (GTK_WINDOW(helper->banner), FALSE);
4440                                 gtk_widget_show (GTK_WIDGET(helper->banner));
4441                         }
4442                         /* Clean folder on header view before moving it */
4443                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
4444                         gtk_tree_selection_unselect_all (sel);
4445
4446                         /* Let gtk events run. We need that the folder
4447                            view frees its reference to the source
4448                            folder *before* issuing the mail operation
4449                            so we need the signal handler of selection
4450                            changed to happen before the mail
4451                            operation */
4452                         while (gtk_events_pending ())
4453                                 gtk_main_iteration ();
4454
4455                         mail_op =
4456                           modest_mail_operation_new_with_error_handling (G_OBJECT(win),
4457                                                                          modest_ui_actions_move_folder_error_handler,
4458                                                                          src_folder, NULL);
4459                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4460                                                          mail_op);
4461
4462                         /* Select *after* the changes */
4463                         /* TODO: this function hangs UI after transfer */
4464 /*                      modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view), */
4465 /*                                                        TNY_FOLDER (src_folder), TRUE); */
4466
4467                         modest_mail_operation_xfer_folder (mail_op,
4468                                                            TNY_FOLDER (src_folder),
4469                                                            dst_folder,
4470                                                            TRUE,
4471                                                            move_to_cb,
4472                                                            helper);
4473                         /* Unref mail operation */
4474                         g_object_unref (G_OBJECT (mail_op));
4475                 }
4476         } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
4477                 gboolean do_xfer = TRUE;
4478                 /* Ask for confirmation if the source folder is remote and we're not connected */
4479                 if (!online && modest_platform_is_network_folderstore(src_folder)) {
4480                         TnyList *headers = modest_header_view_get_selected_headers(header_view);
4481                         if (!msgs_already_deleted_from_server(headers, src_folder)) {
4482                                 guint num_headers = tny_list_get_length(headers);
4483                                 TnyAccount *account = get_account_from_header_list (headers);
4484                                 if (!connect_to_get_msg(MODEST_WINDOW (win), num_headers, account))
4485                                         do_xfer = FALSE;
4486                                 g_object_unref (account);
4487                         }
4488                         g_object_unref(headers);
4489                 }
4490                 if (do_xfer) /* Transfer messages */
4491                         modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
4492         }
4493
4494     if (src_folder)
4495         g_object_unref (src_folder);
4496 }
4497
4498
4499 /*
4500  * UI handler for the "Move to" action when invoked from the
4501  * ModestMsgViewWindow
4502  */
4503 static void
4504 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
4505                                               TnyFolderStore *dst_folder,
4506                                               ModestMsgViewWindow *win)
4507 {
4508         TnyHeader *header = NULL;
4509         TnyFolder *src_folder = NULL;
4510         TnyAccount *account = NULL;
4511         gboolean do_xfer = FALSE;
4512
4513         /* Create header list */
4514         header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
4515         src_folder = TNY_FOLDER (tny_header_get_folder(header));
4516         g_object_unref (header);
4517
4518         account = tny_folder_get_account (src_folder);
4519         if (!modest_platform_is_network_folderstore(TNY_FOLDER_STORE(src_folder))) {
4520                 /* Transfer if the source folder is local */
4521                 do_xfer = TRUE;
4522         } else if (remote_folder_is_pop(TNY_FOLDER_STORE(src_folder))) {
4523                 /* Transfer if the source folder is POP (as it means
4524                  * that the message is already downloaded) */
4525                 do_xfer = TRUE;
4526         } else if (connect_to_get_msg(MODEST_WINDOW(win), 1, account)) {
4527                 /* Transfer after asking confirmation */
4528                 do_xfer = TRUE;
4529         }
4530
4531         if (do_xfer) {
4532                 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
4533         }
4534         g_object_unref (account);
4535         g_object_unref (src_folder);
4536 }
4537
4538 void
4539 modest_ui_actions_on_move_to (GtkAction *action,
4540                               ModestWindow *win)
4541 {
4542         GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
4543         gint result = 0;
4544         TnyFolderStore *dst_folder = NULL;
4545         ModestMainWindow *main_window;
4546
4547         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
4548                           MODEST_IS_MSG_VIEW_WINDOW (win));
4549
4550         /* Get the main window if exists */
4551         if (MODEST_IS_MAIN_WINDOW (win))
4552                 main_window = MODEST_MAIN_WINDOW (win);
4553         else
4554                 main_window =
4555                         MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
4556                                                                                FALSE)); /* don't create */
4557
4558         /* Get the folder view widget if exists */
4559         if (main_window)
4560                 folder_view = modest_main_window_get_child_widget (main_window,
4561                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4562         else
4563                 folder_view = NULL;
4564
4565         /* Create and run the dialog */
4566         dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
4567         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
4568         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
4569         result = gtk_dialog_run (GTK_DIALOG(dialog));
4570         g_object_ref (tree_view);
4571         gtk_widget_destroy (dialog);
4572
4573         if (result != GTK_RESPONSE_ACCEPT)
4574                 return;
4575
4576         dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
4577         /* Do window specific stuff */
4578         if (MODEST_IS_MAIN_WINDOW (win)) {
4579                 modest_ui_actions_on_main_window_move_to (action,
4580                                                           folder_view,
4581                                                           dst_folder,
4582                                                           MODEST_MAIN_WINDOW (win));
4583         } else {
4584                 modest_ui_actions_on_msg_view_window_move_to (action,
4585                                                               dst_folder,
4586                                                               MODEST_MSG_VIEW_WINDOW (win));
4587         }
4588
4589         if (dst_folder)
4590                 g_object_unref (dst_folder);
4591 }
4592
4593 /*
4594  * Calls #HeadersFunc for each header already selected in the main
4595  * window or the message currently being shown in the msg view window
4596  */
4597 static void
4598 do_headers_action (ModestWindow *win,
4599                    HeadersFunc func,
4600                    gpointer user_data)
4601 {
4602         TnyList *headers_list = NULL;
4603         TnyIterator *iter = NULL;
4604         TnyHeader *header = NULL;
4605         TnyFolder *folder = NULL;
4606
4607         /* Get headers */
4608         headers_list = get_selected_headers (win);
4609         if (!headers_list)
4610                 return;
4611
4612         /* Get the folder */
4613         iter = tny_list_create_iterator (headers_list);
4614         header = TNY_HEADER (tny_iterator_get_current (iter));
4615         if (header) {
4616                 folder = tny_header_get_folder (header);
4617                 g_object_unref (header);
4618         }
4619
4620         /* Call the function for each header */
4621         while (!tny_iterator_is_done (iter)) {
4622                 header = TNY_HEADER (tny_iterator_get_current (iter));
4623                 func (header, win, user_data);
4624                 g_object_unref (header);
4625                 tny_iterator_next (iter);
4626         }
4627
4628         /* Trick: do a poke status in order to speed up the signaling
4629            of observers */
4630         tny_folder_poke_status (folder);
4631
4632         /* Frees */
4633         g_object_unref (folder);
4634         g_object_unref (iter);
4635         g_object_unref (headers_list);
4636 }
4637
4638 void
4639 modest_ui_actions_view_attachment (GtkAction *action,
4640                                    ModestWindow *window)
4641 {
4642         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4643                 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
4644         } else {
4645                 /* not supported window for this action */
4646                 g_return_if_reached ();
4647         }
4648 }
4649
4650 void
4651 modest_ui_actions_save_attachments (GtkAction *action,
4652                                     ModestWindow *window)
4653 {
4654         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4655                 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
4656         } else {
4657                 /* not supported window for this action */
4658                 g_return_if_reached ();
4659         }
4660 }
4661
4662 void
4663 modest_ui_actions_remove_attachments (GtkAction *action,
4664                                       ModestWindow *window)
4665 {
4666         if (MODEST_IS_MAIN_WINDOW (window)) {
4667                 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
4668         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4669                 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
4670         } else {
4671                 /* not supported window for this action */
4672                 g_return_if_reached ();
4673         }
4674 }
4675
4676 void
4677 modest_ui_actions_on_settings (GtkAction *action,
4678                                ModestWindow *win)
4679 {
4680         GtkWidget *dialog;
4681
4682         dialog = modest_platform_get_global_settings_dialog ();
4683         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
4684         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
4685         gtk_widget_show_all (dialog);
4686
4687         gtk_dialog_run (GTK_DIALOG (dialog));
4688
4689         gtk_widget_destroy (dialog);
4690 }
4691
4692 void
4693 modest_ui_actions_on_help (GtkAction *action,
4694                            GtkWindow *win)
4695 {
4696         const gchar *help_id;
4697
4698         g_return_if_fail (action);
4699         g_return_if_fail (win && GTK_IS_WINDOW(win));
4700
4701         help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
4702
4703         if (help_id)
4704                 modest_platform_show_help (GTK_WINDOW (win), help_id);
4705         else
4706                 g_warning ("%s: no help for window %p", __FUNCTION__, win);
4707 }
4708
4709 static void
4710 retrieve_msg_contents_performer (gboolean canceled,
4711                                  GError *err,
4712                                  GtkWindow *parent_window,
4713                                  TnyAccount *account,
4714                                  gpointer user_data)
4715 {
4716         ModestMailOperation *mail_op;
4717         TnyList *headers = TNY_LIST (user_data);
4718
4719         if (err || canceled) {
4720                 /* Show an error ? */
4721                 goto out;
4722         }
4723
4724         /* Create mail operation */
4725         mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
4726                                                                  modest_ui_actions_get_msgs_full_error_handler,
4727                                                                  NULL, NULL);
4728         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4729         modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
4730
4731         /* Frees */
4732         g_object_unref (mail_op);
4733  out:
4734         g_object_unref (headers);
4735         g_object_unref (account);
4736 }
4737
4738 void
4739 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
4740                                             ModestWindow *window)
4741 {
4742         TnyList *headers = NULL;
4743         TnyAccount *account = NULL;
4744         TnyIterator *iter = NULL;
4745         TnyHeader *header = NULL;
4746         TnyFolder *folder = NULL;
4747
4748         /* Get headers */
4749         headers = get_selected_headers (window);
4750         if (!headers)
4751                 return;
4752
4753         /* Pick the account */
4754         iter = tny_list_create_iterator (headers);
4755         header = TNY_HEADER (tny_iterator_get_current (iter));
4756         folder = tny_header_get_folder (header);
4757         account = tny_folder_get_account (folder);
4758         g_object_unref (folder);
4759         g_object_unref (header);
4760         g_object_unref (iter);
4761
4762         /* Connect and perform the message retrieval */
4763         modest_platform_connect_and_perform ((GtkWindow *) window,
4764                                              g_object_ref (account),
4765                                              retrieve_msg_contents_performer,
4766                                              g_object_ref (headers));
4767
4768         /* Frees */
4769         g_object_unref (account);
4770         g_object_unref (headers);
4771 }
4772
4773 void
4774 modest_ui_actions_on_email_menu_activated (GtkAction *action,
4775                                           ModestWindow *window)
4776 {
4777         g_return_if_fail (MODEST_IS_WINDOW (window));
4778
4779         /* Update dimmed */
4780         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4781 }
4782
4783 void
4784 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
4785                                           ModestWindow *window)
4786 {
4787         g_return_if_fail (MODEST_IS_WINDOW (window));
4788
4789         /* Update dimmed */
4790         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4791 }
4792
4793 void
4794 modest_ui_actions_on_view_menu_activated (GtkAction *action,
4795                                           ModestWindow *window)
4796 {
4797         g_return_if_fail (MODEST_IS_WINDOW (window));
4798
4799         /* Update dimmed */
4800         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4801 }
4802
4803 void
4804 modest_ui_actions_on_format_menu_activated (GtkAction *action,
4805                                             ModestWindow *window)
4806 {
4807         g_return_if_fail (MODEST_IS_WINDOW (window));
4808
4809         /* Update dimmed */
4810         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4811 }
4812
4813 void
4814 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
4815                                           ModestWindow *window)
4816 {
4817         g_return_if_fail (MODEST_IS_WINDOW (window));
4818
4819         /* Update dimmed */
4820         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4821 }
4822
4823 void
4824 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
4825                                           ModestWindow *window)
4826 {
4827         g_return_if_fail (MODEST_IS_WINDOW (window));
4828
4829         /* Update dimmed */
4830         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4831 }
4832
4833 void
4834 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
4835                                                  ModestWindow *window)
4836 {
4837         g_return_if_fail (MODEST_IS_WINDOW (window));
4838
4839         /* Update dimmed */
4840         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4841 }
4842
4843 void
4844 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
4845                                                      ModestWindow *window)
4846 {
4847         g_return_if_fail (MODEST_IS_WINDOW (window));
4848
4849         /* Update dimmed */
4850         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4851 }
4852
4853 void
4854 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
4855                                                      ModestWindow *window)
4856 {
4857         g_return_if_fail (MODEST_IS_WINDOW (window));
4858
4859         /* Update dimmed */
4860         modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4861 }
4862
4863 void
4864 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
4865 {
4866         g_return_if_fail (MODEST_IS_WINDOW (window));
4867
4868         /* Update dimmed */
4869         modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
4870 }
4871
4872 void
4873 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
4874 {
4875         g_return_if_fail (MODEST_IS_WINDOW (window));
4876
4877         modest_platform_show_search_messages (GTK_WINDOW (window));
4878 }
4879
4880 void
4881 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
4882 {
4883         g_return_if_fail (MODEST_IS_WINDOW (win));
4884         modest_platform_show_addressbook (GTK_WINDOW (win));
4885 }
4886
4887
4888 void
4889 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
4890                                           ModestWindow *window)
4891 {
4892         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4893
4894         modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
4895 }
4896
4897 static void
4898 on_send_receive_finished (ModestMailOperation  *mail_op,
4899                            gpointer user_data)
4900 {
4901         GtkWidget *header_view, *folder_view;
4902         TnyFolderStore *folder_store;
4903         ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
4904
4905         /* Set send/receive operation finished */
4906         modest_main_window_notify_send_receive_completed (main_win);
4907
4908         /* Don't refresh the current folder if there were any errors */
4909         if (modest_mail_operation_get_status (mail_op) !=
4910             MODEST_MAIL_OPERATION_STATUS_SUCCESS)
4911                 return;
4912
4913         /* Refresh the current folder if we're viewing a window. We do
4914            this because the user won't be able to see the new mails in
4915            the selected folder after a Send&Receive because it only
4916            performs a poke_status, i.e, only the number of read/unread
4917            messages is updated, but the new headers are not
4918            downloaded */
4919         folder_view = modest_main_window_get_child_widget (main_win,
4920                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4921         if (!folder_view)
4922                 return;
4923
4924         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4925
4926         /* Do not need to refresh INBOX again because the
4927            update_account does it always automatically */
4928         if (folder_store && TNY_IS_FOLDER (folder_store) &&
4929             tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
4930
4931                 header_view = modest_main_window_get_child_widget (main_win,
4932                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4933
4934                 /* We do not need to set the contents style
4935                    because it hasn't changed. We also do not
4936                    need to save the widget status. Just force
4937                    a refresh */
4938                 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
4939                                                TNY_FOLDER (folder_store),
4940                                                folder_refreshed_cb,
4941                                                main_win);
4942         }
4943
4944         if (folder_store)
4945                 g_object_unref (folder_store);
4946 }
4947
4948
4949 void
4950 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
4951                                                 TnyHeader *header,
4952                                                 TnyMsg *msg,
4953                                                 GError *err,
4954                                                 gpointer user_data)
4955 {
4956         const gchar* server_name = NULL;
4957         TnyTransportAccount *server_account;
4958         gchar *message = NULL;
4959
4960         /* Don't show anything if the user cancelled something */
4961         if (err->code == TNY_TRANSPORT_ACCOUNT_ERROR_SEND_USER_CANCEL)
4962                 return;
4963
4964         /* Get the server name: */
4965         server_account =
4966                 TNY_TRANSPORT_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self)));
4967         if (server_account) {
4968                 server_name = tny_account_get_hostname (TNY_ACCOUNT (server_account));
4969
4970                 g_object_unref (server_account);
4971                 server_account = NULL;
4972         }
4973
4974         g_return_if_fail (server_name);
4975
4976         /* Show the appropriate message text for the GError: */
4977         switch (err->code) {
4978         case TNY_TRANSPORT_ACCOUNT_ERROR_SEND_HOST_LOOKUP_FAILED:
4979                 message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
4980                 break;
4981         case TNY_TRANSPORT_ACCOUNT_ERROR_SEND_SERVICE_UNAVAILABLE:
4982                 message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
4983                 break;
4984         case TNY_TRANSPORT_ACCOUNT_ERROR_SEND_AUTHENTICATION_NOT_SUPPORTED:
4985                 message = g_strdup_printf (_("emev_ni_ui_smtp_authentication_fail_error"), server_name);
4986                 break;
4987         case TNY_TRANSPORT_ACCOUNT_ERROR_SEND:
4988                 message = g_strdup (_("emev_ib_ui_smtp_send_error"));
4989                 break;
4990         default:
4991                 g_return_if_reached ();
4992         }
4993
4994         /* TODO if the username or the password where not defined we
4995            should show the Accounts Settings dialog or the Connection
4996            specific SMTP server window */
4997
4998         modest_platform_run_information_dialog (NULL, message);
4999         g_free (message);
5000 }
5001
5002 void
5003 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
5004                                                 gchar *msg_id,
5005                                                 guint status,
5006                                                 gpointer user_data)
5007 {
5008         ModestMainWindow *main_window = NULL;
5009         ModestWindowMgr *mgr = NULL;
5010         GtkWidget *folder_view = NULL, *header_view = NULL;
5011         TnyFolderStore *selected_folder = NULL;
5012         TnyFolderType folder_type;
5013
5014         mgr = modest_runtime_get_window_mgr ();
5015         main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (mgr,
5016                                                                              FALSE));/* don't create */
5017         if (!main_window)
5018                 return;
5019
5020         /* Check if selected folder is OUTBOX */
5021         folder_view = modest_main_window_get_child_widget (main_window,
5022                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5023         header_view = modest_main_window_get_child_widget (main_window,
5024                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5025
5026         selected_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5027         if (!TNY_IS_FOLDER (selected_folder))
5028                 goto frees;
5029
5030         /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
5031 #if GTK_CHECK_VERSION(2, 8, 0)
5032         folder_type = modest_tny_folder_guess_folder_type (TNY_FOLDER (selected_folder));
5033         if (folder_type ==  TNY_FOLDER_TYPE_OUTBOX) {
5034                 GtkTreeViewColumn *tree_column;
5035
5036                 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
5037                                                         TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
5038                 gtk_tree_view_column_queue_resize (tree_column);
5039         }
5040 #else
5041         gtk_widget_queue_draw (header_view);
5042 #endif
5043
5044         /* Free */
5045  frees:
5046         if (selected_folder != NULL)
5047                 g_object_unref (selected_folder);
5048 }
5049
5050 void
5051 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
5052                                                TnyAccount *account)
5053 {
5054         ModestTransportStoreProtocol proto;
5055         const gchar *proto_name;
5056         gchar *error_note = NULL;
5057
5058         proto_name = tny_account_get_proto (account);
5059         proto = modest_protocol_info_get_transport_store_protocol (proto_name);
5060
5061         switch (proto) {
5062         case MODEST_PROTOCOL_STORE_POP:
5063                 error_note = g_strdup_printf (_("emev_ni_ui_pop3_msg_connect_error"),
5064                                               tny_account_get_hostname (account));
5065                 break;
5066         case MODEST_PROTOCOL_STORE_IMAP:
5067                 error_note = g_strdup_printf (_("emev_ni_ui_imap_connect_server_error"),
5068                                               tny_account_get_hostname (account));
5069                 break;
5070         case MODEST_PROTOCOL_STORE_MAILDIR:
5071         case MODEST_PROTOCOL_STORE_MBOX:
5072                 error_note = g_strdup (_("emev_nc_mailbox_notavailable"));
5073                 break;
5074         default:
5075                 g_warning ("%s: This should not be reached", __FUNCTION__);
5076         }
5077
5078         if (error_note) {
5079                 modest_platform_run_information_dialog (parent_window, error_note);
5080                 g_free (error_note);
5081         }
5082 }