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 <string.h>
  36 #include <modest-runtime.h>
  37 #include <modest-tny-folder.h>
  38 #include <modest-tny-msg.h>
  39 #include <modest-tny-account.h>
  40 #include <modest-address-book.h>
  41
  42 #include "modest-ui-actions.h"
  43
  44 #include "modest-tny-platform-factory.h"
  45 #include "modest-platform.h"
  46
  47 #ifdef MODEST_PLATFORM_MAEMO
  48 #include "maemo/modest-osso-state-saving.h"
  49 #include "maemo/modest-maemo-ui-constants.h"
  50 #endif /* MODEST_PLATFORM_MAEMO */
  51
  52
  53 #include <widgets/modest-main-window.h>
  54 #include <widgets/modest-msg-view-window.h>
  55 #include <widgets/modest-account-view-window.h>
  56 #include <widgets/modest-details-dialog.h>
  57
  58 #include "modest-account-mgr-helpers.h"
  59 #include "modest-mail-operation.h"
  60 #include "modest-text-utils.h"
  61
  62 #ifdef MODEST_HAVE_EASYSETUP
  63 #include "easysetup/modest-easysetup-wizard.h"
  64 #endif /* MODEST_HAVE_EASYSETUP */
  65
  66 #include <modest-widget-memory.h>
  67 #include <tny-error.h>
  68 #include <tny-simple-list.h>
  69 #include <tny-msg-view.h>
  70 #include <tny-device.h>
  71
  72 typedef struct _GetMsgAsyncHelper {
  73         ModestWindow *window;
  74         ModestMailOperation *mail_op;
  75         TnyIterator *iter;
  76         guint num_ops;
  77         GFunc func;
  78         gpointer user_data;
  79 } GetMsgAsyncHelper;
  80
  81 typedef enum _ReplyForwardAction {
  82         ACTION_REPLY,
  83         ACTION_REPLY_TO_ALL,
  84         ACTION_FORWARD
  85 } ReplyForwardAction;
  86
  87 typedef struct _ReplyForwardHelper {
  88 guint reply_forward_type;
  89         ReplyForwardAction action;
  90         gchar *account_name;
  91         guint pending_ops;
  92 } ReplyForwardHelper;
  93
  94 typedef struct _HeaderActivatedHelper {
  95         GtkTreeModel *model;
  96         GtkTreeIter iter;
  97         TnyFolder *folder;
  98 } HeaderActivatedHelper;
  99
 100 /*
 101  * The do_headers_action uses this kind of functions to perform some
 102  * action to each member of a list of headers
 103  */
 104 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
 105
 106 static void
 107 do_headers_action (ModestWindow *win,
 108                    HeadersFunc func,
 109                    gpointer user_data);
 110
 111
 112 static void     open_msg_func          (const GObject *obj, const TnyMsg *msg, gpointer user_data);
 113
 114 static void     reply_forward_func     (const GObject *obj, const TnyMsg *msg, gpointer user_data);
 115
 116 static void     reply_forward          (ReplyForwardAction action, ModestWindow *win);
 117
 118 static gchar*   ask_for_folder_name    (GtkWindow *parent_window, const gchar *title);
 119
 120 void
 121 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
 122 {
 123         GtkWidget *about;
 124         const gchar *authors[] = {
 125                 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
 126                 NULL
 127         };
 128         about = gtk_about_dialog_new ();
 129         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
 130         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
 131         gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
 132                                         _("Copyright (c) 2006, Nokia Corporation\n"
 133                                           "All rights reserved."));
 134         gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
 135                                        _("a modest e-mail client\n\n"
 136                                          "design and implementation: Dirk-Jan C. Binnema\n"
 137                                          "contributions from the fine people at KC and Ig\n"
 138                                          "uses the tinymail email framework written by Philip van Hoof"));
 139         gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
 140         gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
 141
 142         gtk_dialog_run (GTK_DIALOG (about));
 143         gtk_widget_destroy(about);
 144 }
 145
 146
 147 static TnyList *
 148 get_selected_headers (ModestWindow *win)
 149 {
 150         if (MODEST_IS_MAIN_WINDOW(win)) {
 151                 GtkWidget *header_view;
 152
 153                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 154                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 155                 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 156
 157         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 158                 /* for MsgViewWindows, we simply return a list with one element */
 159                 TnyMsg *msg;
 160                 TnyHeader *header;
 161                 TnyList *list = NULL;
 162
 163                 msg  = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
 164                 if (msg) {
 165                         header = tny_msg_get_header (msg);
 166                         list = tny_simple_list_new ();
 167                         tny_list_prepend (list, G_OBJECT(header));
 168                         g_object_unref (G_OBJECT(header));
 169                 }
 170                 return list;
 171
 172         } else
 173                 return NULL;
 174 }
 175
 176 static void
 177 headers_action_delete (TnyHeader *header,
 178                        ModestWindow *win,
 179                        gpointer user_data)
 180 {
 181         ModestMailOperation *mail_op;
 182
 183         /* TODO: add confirmation dialog */
 184         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE, G_OBJECT(win));
 185         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 186                                          mail_op);
 187
 188         /* Always delete. TODO: Move to trash still not supported */
 189         modest_mail_operation_remove_msg (mail_op, header, FALSE);
 190         g_object_unref (G_OBJECT (mail_op));
 191 }
 192
 193 void
 194 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
 195 {
 196         g_return_if_fail (MODEST_IS_WINDOW(win));
 197
 198         if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
 199                 gboolean ret_value;
 200                 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 201                 return;
 202         }
 203
 204         /* Remove each header */
 205         do_headers_action (win, headers_action_delete, NULL);
 206
 207         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 208                 gtk_widget_destroy (GTK_WIDGET(win));
 209         }
 210 }
 211
 212
 213 void
 214 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
 215 {
 216         #ifdef MODEST_PLATFORM_MAEMO
 217         modest_osso_save_state();
 218         #endif /* MODEST_PLATFORM_MAEMO */
 219
 220         gtk_main_quit ();
 221 }
 222
 223 void
 224 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
 225 {
 226         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 227                 gtk_widget_destroy (GTK_WIDGET (win));
 228         } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
 229                 gboolean ret_value;
 230                 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
 231         } else if (MODEST_IS_WINDOW (win)) {
 232                 gtk_widget_destroy (GTK_WIDGET (win));
 233         } else {
 234                 g_return_if_reached ();
 235         }
 236 }
 237
 238 void
 239 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
 240 {
 241         GtkClipboard *clipboard = NULL;
 242         gchar *selection = NULL;
 243
 244         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 245         selection = gtk_clipboard_wait_for_text (clipboard);
 246
 247         modest_address_book_add_address (selection);
 248         g_free (selection);
 249 }
 250
 251 void
 252 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
 253 {
 254
 255         /* This is currently only implemented for Maemo,
 256          * because it requires a providers preset file which is not publically available.
 257          */
 258 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 259         GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
 260                                 TRUE /* enabled accounts only */);
 261         gboolean accounts_exist = account_names != NULL;
 262         g_slist_free (account_names);
 263
 264         if (!accounts_exist) {
 265                 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
 266                 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
 267                 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
 268                 gtk_dialog_run (GTK_DIALOG (wizard));
 269                 gtk_widget_destroy (GTK_WIDGET (wizard));
 270         } else  {
 271                 /* Show the list of accounts: */
 272                 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
 273                 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
 274                 gtk_dialog_run (account_win);
 275                 gtk_widget_destroy (GTK_WIDGET(account_win));
 276         }
 277 #else
 278         GtkWidget *dialog, *label;
 279
 280         /* Create the widgets */
 281
 282         dialog = gtk_dialog_new_with_buttons ("Message",
 283                                               GTK_WINDOW(win),
 284                                               GTK_DIALOG_DESTROY_WITH_PARENT,
 285                                               GTK_STOCK_OK,
 286                                               GTK_RESPONSE_NONE,
 287                                               NULL);
 288         label = gtk_label_new ("Hello World!");
 289
 290         /* Ensure that the dialog box is destroyed when the user responds. */
 291
 292         g_signal_connect_swapped (dialog, "response",
 293                                   G_CALLBACK (gtk_widget_destroy),
 294                                   dialog);
 295
 296         /* Add the label, and show everything we've added to the dialog. */
 297
 298         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
 299                            label);
 300         gtk_widget_show_all (dialog);
 301 #endif /* MODEST_PLATFORM_MAEMO */
 302 }
 303
 304 void
 305 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
 306 {
 307         ModestWindow *msg_win;
 308         TnyMsg *msg = NULL;
 309         TnyFolder *folder = NULL;
 310         gchar *account_name = NULL;
 311         gchar *from_str = NULL;
 312 /*      GError *err = NULL; */
 313         TnyAccount *account = NULL;
 314         ModestWindowMgr *mgr;
 315         gchar *signature = NULL;
 316
 317         account_name = g_strdup(modest_window_get_active_account (win));
 318         if (!account_name)
 319                 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 320         if (!account_name) {
 321                 g_printerr ("modest: no account found\n");
 322                 goto cleanup;
 323         }
 324
 325         account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
 326                                                                        account_name,
 327                                                                        TNY_ACCOUNT_TYPE_STORE);
 328         if (!account) {
 329                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
 330                 goto cleanup;
 331         }
 332
 333         from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
 334         if (!from_str) {
 335                 g_printerr ("modest: failed get from string for '%s'\n", account_name);
 336                 goto cleanup;
 337         }
 338
 339         if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
 340                                          MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
 341                 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
 342                                                            MODEST_ACCOUNT_SIGNATURE, FALSE);
 343         } else {
 344                 signature = g_strdup ("");
 345         }
 346
 347         msg = modest_tny_msg_new ("", from_str, "", "", "", signature, NULL);
 348         if (!msg) {
 349                 g_printerr ("modest: failed to create new msg\n");
 350                 goto cleanup;
 351         }
 352
 353         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 354         if (!folder) {
 355                 g_printerr ("modest: failed to find Drafts folder\n");
 356                 goto cleanup;
 357         }
 358
 359 /*      tny_folder_add_msg (folder, msg, &err); */
 360 /*      if (err) { */
 361 /*              g_printerr ("modest: error adding msg to Drafts folder: %s", */
 362 /*                          err->message); */
 363 /*              g_error_free (err); */
 364 /*              goto cleanup; */
 365 /*      } */
 366
 367         /* Create and register edit window */
 368         msg_win = modest_msg_edit_window_new (msg, account_name);
 369         mgr = modest_runtime_get_window_mgr ();
 370         modest_window_mgr_register_window (mgr, msg_win);
 371
 372         if (win)
 373                 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
 374                                               GTK_WINDOW (win));
 375         gtk_widget_show_all (GTK_WIDGET (msg_win));
 376
 377 cleanup:
 378         g_free (account_name);
 379         g_free (from_str);
 380         g_free (signature);
 381         if (account)
 382                 g_object_unref (G_OBJECT(account));
 383         if (msg)
 384                 g_object_unref (G_OBJECT(msg));
 385         if (folder)
 386                 g_object_unref (G_OBJECT(folder));
 387 }
 388
 389 static void
 390 headers_action_open (TnyHeader *header,
 391                      ModestWindow *win,
 392                      gpointer user_data)
 393 {
 394         modest_ui_actions_on_header_activated (MODEST_HEADER_VIEW (user_data),
 395                                                header,
 396                                                MODEST_MAIN_WINDOW (win));
 397 }
 398
 399 void
 400 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
 401 {
 402         GtkWidget *header_view;
 403
 404         /* Get header view */
 405         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 406                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 407
 408         /* Open each message */
 409         do_headers_action (win, headers_action_open, header_view);
 410 }
 411
 412
 413 static void
 414 open_msg_func (const GObject *obj, const TnyMsg *msg, gpointer user_data)
 415 {
 416         ModestWindowMgr *mgr = NULL;
 417         ModestWindow *parent_win = NULL;
 418         ModestWindow *win = NULL;
 419         HeaderActivatedHelper *helper = NULL;
 420         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
 421         gchar *account = NULL;
 422
 423         g_return_if_fail (MODEST_IS_WINDOW(obj));
 424         g_return_if_fail (user_data != NULL);
 425         parent_win = MODEST_WINDOW(obj);
 426         helper = (HeaderActivatedHelper *) user_data;
 427
 428         /* Get account */
 429         account =  g_strdup(modest_window_get_active_account(MODEST_WINDOW(parent_win)));
 430         if (!account)
 431                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 432
 433         /* Gets foldert type (OUTBOX headers will be opened in edit window */
 434         if (modest_tny_folder_is_local_folder (helper->folder))
 435                 folder_type = modest_tny_folder_get_local_folder_type (helper->folder);
 436
 437         switch (folder_type) {
 438         case TNY_FOLDER_TYPE_DRAFTS:
 439                 win = modest_msg_edit_window_new ((TnyMsg *) msg, account);
 440                 break;
 441         default:
 442                 if (helper->model != NULL)
 443                         win = modest_msg_view_window_new_with_header_model ((TnyMsg *) msg, account, helper->model, helper->iter);
 444                 else
 445                         win = modest_msg_view_window_new ((TnyMsg *) msg, account);
 446         }
 447
 448         /* Register and show new window */
 449         if (win != NULL) {
 450                 mgr = modest_runtime_get_window_mgr ();
 451                 modest_window_mgr_register_window (mgr, win);
 452                 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
 453                 gtk_widget_show_all (GTK_WIDGET(win));
 454         }
 455
 456         /* Free */
 457         g_free(account);
 458 /*      g_object_unref (G_OBJECT(msg)); */
 459         g_object_unref (G_OBJECT(helper->folder));
 460         g_slice_free (HeaderActivatedHelper, helper);
 461 }
 462
 463 static void
 464 reply_forward_func (const GObject *obj, const TnyMsg *msg, gpointer user_data)
 465 {
 466         TnyMsg *new_msg;
 467         ReplyForwardHelper *rf_helper;
 468         ModestWindow *msg_win;
 469         ModestEditType edit_type;
 470         gchar *from;
 471         GError *err = NULL;
 472         TnyFolder *folder = NULL;
 473         TnyAccount *account = NULL;
 474         ModestWindowMgr *mgr;
 475         gchar *signature = NULL;
 476
 477         g_return_if_fail (user_data != NULL);
 478         rf_helper = (ReplyForwardHelper *) user_data;
 479
 480         rf_helper->pending_ops--;
 481
 482         from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
 483                                                    rf_helper->account_name);
 484         if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
 485                                          rf_helper->account_name,
 486                                          MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
 487                 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
 488                                                            rf_helper->account_name,
 489                                                            MODEST_ACCOUNT_SIGNATURE, FALSE);
 490         }
 491
 492         /* Create reply mail */
 493         switch (rf_helper->action) {
 494         case ACTION_REPLY:
 495                 new_msg =
 496                         modest_tny_msg_create_reply_msg ((TnyMsg *) msg,  from, signature,
 497                                                          rf_helper->reply_forward_type,
 498                                                          MODEST_TNY_MSG_REPLY_MODE_SENDER);
 499                 break;
 500         case ACTION_REPLY_TO_ALL:
 501                 new_msg =
 502                         modest_tny_msg_create_reply_msg ((TnyMsg *) msg, from, signature, rf_helper->reply_forward_type,
 503                                                          MODEST_TNY_MSG_REPLY_MODE_ALL);
 504                 edit_type = MODEST_EDIT_TYPE_REPLY;
 505                 break;
 506         case ACTION_FORWARD:
 507                 new_msg =
 508                         modest_tny_msg_create_forward_msg ((TnyMsg *) msg, from, signature, rf_helper->reply_forward_type);
 509                 edit_type = MODEST_EDIT_TYPE_FORWARD;
 510                 break;
 511         default:
 512                 g_return_if_reached ();
 513                 return;
 514         }
 515
 516         g_free (signature);
 517
 518         if (!new_msg) {
 519                 g_printerr ("modest: failed to create message\n");
 520                 goto cleanup;
 521         }
 522
 523         account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
 524                                                                        rf_helper->account_name,
 525                                                                        TNY_ACCOUNT_TYPE_STORE);
 526         if (!account) {
 527                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
 528                 goto cleanup;
 529         }
 530
 531         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 532         if (!folder) {
 533                 g_printerr ("modest: failed to find Drafts folder\n");
 534                 goto cleanup;
 535         }
 536
 537         tny_folder_add_msg (folder, (TnyMsg *) msg, &err);
 538         if (err) {
 539                 g_printerr ("modest: error adding msg to Drafts folder: %s",
 540                             err->message);
 541                 g_error_free (err);
 542                 goto cleanup;
 543         }
 544
 545         /* Create and register the windows */
 546         msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
 547         mgr = modest_runtime_get_window_mgr ();
 548         modest_window_mgr_register_window (mgr, msg_win);
 549
 550         /* Show edit window */
 551         gtk_widget_show_all (GTK_WIDGET (msg_win));
 552
 553 cleanup:
 554         if (new_msg)
 555                 g_object_unref (G_OBJECT (new_msg));
 556         if (folder)
 557                 g_object_unref (G_OBJECT (folder));
 558         if (account)
 559                 g_object_unref (G_OBJECT (account));
 560
 561         if (rf_helper->pending_ops == 0) {
 562                 g_free (rf_helper->account_name);
 563                 g_slice_free (ReplyForwardHelper, rf_helper);
 564         }
 565 }
 566 /*
 567  * Common code for the reply and forward actions
 568  */
 569 static void
 570 reply_forward (ReplyForwardAction action, ModestWindow *win)
 571 {
 572         ModestMailOperation *mail_op = NULL;
 573         TnyList *header_list = NULL;
 574         ReplyForwardHelper *rf_helper = NULL;
 575         guint reply_forward_type;
 576
 577         g_return_if_fail (MODEST_IS_WINDOW(win));
 578
 579         header_list = get_selected_headers (win);
 580         if (!header_list)
 581                 return;
 582
 583         reply_forward_type = modest_conf_get_int (modest_runtime_get_conf (),
 584                                                   (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
 585                                                   NULL);
 586         /* We assume that we can only select messages of the
 587            same folder and that we reply all of them from the
 588            same account. In fact the interface currently only
 589            allows single selection */
 590
 591         /* Fill helpers */
 592         rf_helper = g_slice_new0 (ReplyForwardHelper);
 593         rf_helper->reply_forward_type = reply_forward_type;
 594         rf_helper->action = action;
 595         rf_helper->pending_ops = tny_list_get_length (header_list);
 596         rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
 597         if (!rf_helper->account_name)
 598                 rf_helper->account_name =
 599                         modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 600
 601         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 602                 TnyMsg *msg;
 603                 msg = modest_msg_view_window_get_message(MODEST_MSG_VIEW_WINDOW(win));
 604                 if (!msg) {
 605                         g_printerr ("modest: no message found\n");
 606                         return;
 607                 } else
 608                         reply_forward_func (G_OBJECT(win), msg, rf_helper);
 609         } else {
 610
 611                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
 612                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
 613                 modest_mail_operation_process_msg (mail_op, header_list, reply_forward_func, rf_helper);
 614
 615                 /* Clean */
 616                 g_object_unref(mail_op);
 617         }
 618 }
 619
 620 void
 621 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
 622 {
 623         g_return_if_fail (MODEST_IS_WINDOW(win));
 624
 625         reply_forward (ACTION_REPLY, win);
 626 }
 627
 628 void
 629 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
 630 {
 631         g_return_if_fail (MODEST_IS_WINDOW(win));
 632
 633         reply_forward (ACTION_FORWARD, win);
 634 }
 635
 636 void
 637 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
 638 {
 639         g_return_if_fail (MODEST_IS_WINDOW(win));
 640
 641         reply_forward (ACTION_REPLY_TO_ALL, win);
 642 }
 643
 644 void
 645 modest_ui_actions_on_next (GtkAction *action,
 646                            ModestWindow *window)
 647 {
 648         if (MODEST_IS_MAIN_WINDOW (window)) {
 649                 GtkWidget *header_view;
 650
 651                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
 652                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 653                 if (!header_view)
 654                         return;
 655
 656                 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
 657         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
 658                 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
 659         } else {
 660                 g_return_if_reached ();
 661         }
 662 }
 663
 664 void
 665 modest_ui_actions_on_prev (GtkAction *action,
 666                            ModestWindow *window)
 667 {
 668         g_return_if_fail (MODEST_IS_WINDOW(window));
 669
 670         if (MODEST_IS_MAIN_WINDOW (window)) {
 671                 GtkWidget *header_view;
 672                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
 673                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 674                 if (!header_view)
 675                         return;
 676
 677                 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
 678         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
 679                 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
 680         } else {
 681                 g_return_if_reached ();
 682         }
 683 }
 684
 685 void
 686 modest_ui_actions_on_sort (GtkAction *action,
 687                            ModestWindow *window)
 688 {
 689         g_return_if_fail (MODEST_IS_WINDOW(window));
 690
 691         if (MODEST_IS_MAIN_WINDOW (window)) {
 692                 GtkWidget *header_view;
 693                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
 694                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 695                 if (!header_view)
 696                         return;
 697
 698                 /* Show sorting dialog */
 699                 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
 700         }
 701 }
 702
 703
 704 static gboolean
 705 action_send (const gchar* account_name)
 706 {
 707         TnyAccount *tny_account;
 708         ModestTnySendQueue *send_queue;
 709
 710         g_return_val_if_fail (account_name, FALSE);
 711
 712         /* Get the transport account according to the open connection,
 713          * because the account might specify connection-specific SMTP servers.
 714          */
 715         tny_account =
 716                 modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
 717                                                                      account_name);
 718         if (!tny_account) {
 719                 g_printerr ("modest: cannot get tny transport account for %s\n", account_name);
 720                 return FALSE;
 721         }
 722
 723         send_queue = modest_tny_send_queue_new (TNY_CAMEL_TRANSPORT_ACCOUNT(tny_account));
 724         if (!send_queue) {
 725                 g_object_unref (G_OBJECT(tny_account));
 726                 g_printerr ("modest: cannot get send queue for %s\n", account_name);
 727                 return FALSE;
 728         }
 729
 730         modest_tny_send_queue_flush (send_queue);
 731
 732         g_object_unref (G_OBJECT(send_queue));
 733         g_object_unref (G_OBJECT(tny_account));
 734
 735         return TRUE;
 736 }
 737
 738
 739 static gboolean
 740 action_receive (const gchar* account_name,
 741                 ModestWindow *win)
 742 {
 743         TnyAccount *tny_account;
 744         ModestMailOperation *mail_op;
 745
 746         g_return_val_if_fail (account_name, FALSE);
 747
 748         tny_account =
 749                 modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
 750                                                                      account_name,
 751                                                                      TNY_ACCOUNT_TYPE_STORE);
 752         if (!tny_account) {
 753                 g_printerr ("modest: cannot get tny store account for %s\n", account_name);
 754                 return FALSE;
 755         }
 756
 757         /* Create the mail operation */
 758         /* TODO: The spec wants us to first do any pending deletions, before receiving. */
 759         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
 760         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
 761         modest_mail_operation_update_account (mail_op, TNY_STORE_ACCOUNT(tny_account));
 762
 763         g_object_unref (G_OBJECT(tny_account));
 764         g_object_unref (G_OBJECT (mail_op));
 765
 766         return TRUE;
 767 }
 768
 769 /** Check that an appropriate connection is open.
 770  */
 771 gboolean check_for_connection (const gchar *account_name)
 772 {
 773         TnyDevice *device = modest_runtime_get_device ();
 774
 775 /*
 776         g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
 777
 778         TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);
 779 */
 780
 781         if (tny_device_is_online (device))
 782                 return TRUE;
 783         else {
 784                 modest_platform_connect_and_wait (NULL);
 785
 786                 /* TODO: Wait until a result. */
 787                 return TRUE;
 788         }
 789 }
 790
 791 /*
 792  * This function performs the send & receive required actions. The
 793  * window it's used to create the mail operation. Tipically it should
 794  * be allways the main window, but we pass it as argument in order to
 795  * be more flexible.
 796  */
 797 void
 798 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
 799 {
 800         gchar *acc_name = NULL;
 801
 802         /* If no account name was provided get the current account, if
 803            there is none either then pick the default one */
 804         if (!account_name) {
 805                 acc_name = g_strdup (modest_window_get_active_account(win));
 806                 if (!acc_name)
 807                         acc_name  = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 808                 if (!acc_name) {
 809                         g_printerr ("modest: cannot get default account\n");
 810                         return;
 811                 }
 812         } else {
 813                 acc_name = g_strdup (account_name);
 814         }
 815
 816         /* Send & receive. Do not continue if no suitable connection
 817            is open */
 818         if (check_for_connection (acc_name)) {
 819                 /* As per the UI spec,
 820                  * for POP accounts, we should receive,
 821                  * for IMAP we should synchronize everything, including receiving,
 822                  * for SMTP we should send,
 823                  * first receiving, then sending:
 824                  */
 825                 if (!action_receive(acc_name, win))
 826                         g_printerr ("modest: failed to receive\n");
 827                 if (!action_send(acc_name))
 828                         g_printerr ("modest: failed to send\n");
 829         }
 830         /* Free */
 831         g_free (acc_name);
 832 }
 833
 834 /*
 835  * Refreshes all accounts. This function will be used by automatic
 836  * updates
 837  */
 838 void
 839 modest_ui_actions_do_send_receive_all (ModestWindow *win)
 840 {
 841         GSList *account_names, *iter;
 842
 843         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
 844                                                           TRUE);
 845
 846         iter = account_names;
 847         while (iter) {
 848                 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
 849                 iter = g_slist_next (iter);
 850         }
 851
 852         g_slist_foreach (account_names, (GFunc) g_free, NULL);
 853         g_slist_free (account_names);
 854 }
 855
 856 /*
 857  * Handler of the click on Send&Receive button in the main toolbar
 858  */
 859 void
 860 modest_ui_actions_on_send_receive (GtkAction *action,  ModestWindow *win)
 861 {
 862         /* Check that at least one account exists: */
 863         GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
 864                                 TRUE /* enabled accounts only */);
 865         gboolean accounts_exist = account_names != NULL;
 866         g_slist_free (account_names);
 867
 868         /* If not, allow the user to create an account before trying to send/receive. */
 869         if (!accounts_exist)
 870                 modest_ui_actions_on_accounts (NULL, win);
 871
 872         /* Refresh the active account */
 873         modest_ui_actions_do_send_receive (NULL, win);
 874 }
 875
 876
 877 void
 878 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
 879 {
 880         ModestConf *conf;
 881         GtkWidget *header_view;
 882
 883         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 884
 885         header_view = modest_main_window_get_child_widget (main_window,
 886                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 887         if (!header_view)
 888                 return;
 889
 890         conf = modest_runtime_get_conf ();
 891
 892         /* what is saved/restored is depending on the style; thus; we save with
 893          * old style, then update the style, and restore for this new style
 894          */
 895         modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
 896
 897         if (modest_header_view_get_style
 898             (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
 899                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
 900                                               MODEST_HEADER_VIEW_STYLE_TWOLINES);
 901         else
 902                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
 903                                               MODEST_HEADER_VIEW_STYLE_DETAILS);
 904
 905         modest_widget_memory_restore (conf, G_OBJECT(header_view),
 906                                       MODEST_CONF_HEADER_VIEW_KEY);
 907 }
 908
 909
 910 void
 911 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
 912                                       TnyHeader *header,
 913                                       ModestMainWindow *main_window)
 914 {
 915         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 916
 917         /* If no header has been selected then exit */
 918         if (!header)
 919                 return;
 920
 921         /* Update Main window title */
 922         if (GTK_WIDGET_HAS_FOCUS (header_view)) {
 923                 const gchar *subject = tny_header_get_subject (header);
 924                 if (subject && strcmp (subject, ""))
 925                         gtk_window_set_title (GTK_WINDOW (main_window), subject);
 926                 else
 927                         gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
 928         }
 929 }
 930
 931 void
 932 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
 933                                        TnyHeader *header,
 934                                        ModestMainWindow *main_window)
 935 {
 936         ModestMailOperation *mail_op = NULL;
 937         HeaderActivatedHelper *helper = NULL;
 938         ModestWindowMgr *mgr = NULL;
 939         ModestWindow *win = NULL;
 940         GtkTreeModel *model = NULL;
 941         GtkTreeIter iter;
 942         GtkTreeSelection *sel = NULL;
 943         GList *sel_list = NULL;
 944
 945         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 946
 947         if (!header)
 948                 return;
 949
 950         /* Look if we already have a message view for that header */
 951         mgr = modest_runtime_get_window_mgr ();
 952         win = modest_window_mgr_find_window_by_msguid (mgr, tny_header_get_uid (header));
 953         if (win) return;
 954
 955         /* Build helper */
 956         helper = g_slice_new0 (HeaderActivatedHelper);
 957         helper->folder = tny_header_get_folder (header);
 958         helper->model = NULL;
 959
 960         /* Get headers tree model and selected iter to build message view */
 961         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
 962         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
 963         if (sel_list != NULL) {
 964                 gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) sel_list->data);
 965
 966                 /* Fill helpers */
 967                 helper->model = model;
 968                 helper->iter = iter;
 969
 970                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
 971                 g_list_free (sel_list);
 972         }
 973
 974         /* New mail operation */
 975         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(main_window));
 976         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
 977         modest_mail_operation_get_msg (mail_op, header, open_msg_func, helper);
 978
 979         /* Free */
 980         g_object_unref (mail_op);
 981 }
 982
 983 void
 984 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
 985                                                TnyFolderStore *folder_store,
 986                                                gboolean selected,
 987                                                ModestMainWindow *main_window)
 988 {
 989         ModestConf *conf;
 990         GtkWidget *header_view;
 991
 992         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 993
 994         header_view = modest_main_window_get_child_widget(main_window,
 995                                                           MODEST_WIDGET_TYPE_HEADER_VIEW);
 996         if (!header_view)
 997                 return;
 998
 999         conf = modest_runtime_get_conf ();
1000
1001         if (TNY_IS_FOLDER (folder_store)) {
1002
1003                 if (selected) {
1004                         modest_main_window_set_contents_style (main_window,
1005                                                                MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1006                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1007                                                        TNY_FOLDER (folder_store));
1008                         modest_widget_memory_restore (conf, G_OBJECT(header_view),
1009                                                       MODEST_CONF_HEADER_VIEW_KEY);
1010                 } else {
1011                         modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1012                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
1013                 }
1014         } else if (TNY_IS_ACCOUNT (folder_store)) {
1015
1016                 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1017         }
1018 }
1019
1020 void
1021 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1022                                      ModestWindow *win)
1023 {
1024         GtkWidget *dialog;
1025         gchar *txt, *item;
1026         gboolean online;
1027
1028         item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1029
1030         if (g_main_depth > 0)
1031                 gdk_threads_enter ();
1032         online = tny_device_is_online (modest_runtime_get_device());
1033
1034         if (online) {
1035                 /* already online -- the item is simply not there... */
1036                 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1037                                                  GTK_DIALOG_MODAL,
1038                                                  GTK_MESSAGE_WARNING,
1039                                                  GTK_BUTTONS_OK,
1040                                                  _("The %s you selected cannot be found"),
1041                                                  item);
1042                 gtk_dialog_run (GTK_DIALOG(dialog));
1043         } else {
1044                 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1045                                                       GTK_WINDOW (win),
1046                                                       GTK_DIALOG_MODAL,
1047                                                       GTK_STOCK_CANCEL,
1048                                                       GTK_RESPONSE_REJECT,
1049                                                       GTK_STOCK_OK,
1050                                                       GTK_RESPONSE_ACCEPT,
1051                                                       NULL);
1052                 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1053                                          "Do you want to get online?"), item);
1054                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1055                                     gtk_label_new (txt), FALSE, FALSE, 0);
1056                 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1057                 g_free (txt);
1058
1059                 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1060                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1061 //                      modest_platform_connect_and_wait ();;
1062                 }
1063         }
1064         gtk_widget_destroy (dialog);
1065         if (g_main_depth > 0)
1066                 gdk_threads_leave ();
1067 }
1068
1069 void
1070 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1071                                      ModestWindow *win)
1072 {
1073         /* g_message ("%s %s", __FUNCTION__, link); */
1074 }
1075
1076
1077 void
1078 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1079                                         ModestWindow *win)
1080 {
1081         modest_platform_activate_uri (link);
1082 }
1083
1084 void
1085 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1086                                           ModestWindow *win)
1087 {
1088         modest_platform_show_uri_popup (link);
1089 }
1090
1091 void
1092 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1093                                              ModestWindow *win)
1094 {
1095         /* g_message (__FUNCTION__); */
1096
1097 }
1098
1099 void
1100 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1101                                           const gchar *address,
1102                                           ModestWindow *win)
1103 {
1104         /* g_message ("%s %s", __FUNCTION__, address); */
1105 }
1106
1107 void
1108 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1109 {
1110         TnyTransportAccount *transport_account;
1111         ModestMailOperation *mail_operation;
1112         MsgData *data;
1113         gchar *account_name, *from;
1114         ModestAccountMgr *account_mgr;
1115
1116         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1117
1118         data = modest_msg_edit_window_get_msg_data (edit_window);
1119
1120         account_mgr = modest_runtime_get_account_mgr();
1121         account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1122         if (!account_name)
1123                 account_name = modest_account_mgr_get_default_account (account_mgr);
1124         if (!account_name) {
1125                 g_printerr ("modest: no account found\n");
1126                 modest_msg_edit_window_free_msg_data (edit_window, data);
1127                 return;
1128         }
1129         transport_account =
1130                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
1131                                       (modest_runtime_get_account_store(),
1132                                        account_name,
1133                                        TNY_ACCOUNT_TYPE_TRANSPORT));
1134         if (!transport_account) {
1135                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1136                 g_free (account_name);
1137                 modest_msg_edit_window_free_msg_data (edit_window, data);
1138                 return;
1139         }
1140         from = modest_account_mgr_get_from_string (account_mgr, account_name);
1141
1142         /* Create the mail operation */
1143         mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(edit_window));
1144         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1145
1146         modest_mail_operation_save_to_drafts (mail_operation,
1147                                               transport_account,
1148                                               from,
1149                                               data->to,
1150                                               data->cc,
1151                                               data->bcc,
1152                                               data->subject,
1153                                               data->plain_body,
1154                                               data->html_body,
1155                                               data->attachments,
1156                                               data->priority_flags);
1157         /* Frees */
1158         g_free (from);
1159         g_free (account_name);
1160         g_object_unref (G_OBJECT (transport_account));
1161         g_object_unref (G_OBJECT (mail_operation));
1162
1163         modest_msg_edit_window_free_msg_data (edit_window, data);
1164
1165         /* Save settings and close the window */
1166         gtk_widget_destroy (GTK_WIDGET (edit_window));
1167 }
1168 void
1169 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1170 {
1171         TnyTransportAccount *transport_account;
1172         ModestMailOperation *mail_operation;
1173         MsgData *data;
1174         gchar *account_name, *from;
1175         ModestAccountMgr *account_mgr;
1176
1177         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1178
1179         if (!modest_msg_edit_window_check_names (edit_window))
1180                 return;
1181
1182         data = modest_msg_edit_window_get_msg_data (edit_window);
1183
1184         /* FIXME: Code added just for testing. The final version will
1185            use the send queue provided by tinymail and some
1186            classifier */
1187         account_mgr = modest_runtime_get_account_mgr();
1188         account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1189         if (!account_name)
1190                 account_name = modest_account_mgr_get_default_account (account_mgr);
1191         if (!account_name) {
1192                 g_printerr ("modest: no account found\n");
1193                 modest_msg_edit_window_free_msg_data (edit_window, data);
1194                 return;
1195         }
1196         transport_account =
1197                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1198                                       (modest_runtime_get_account_store(),
1199                                        account_name));
1200         if (!transport_account) {
1201                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1202                 g_free (account_name);
1203                 modest_msg_edit_window_free_msg_data (edit_window, data);
1204                 return;
1205         }
1206         from = modest_account_mgr_get_from_string (account_mgr, account_name);
1207
1208         /* Create the mail operation */
1209         mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_SEND, G_OBJECT(edit_window));
1210         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1211
1212         modest_mail_operation_send_new_mail (mail_operation,
1213                                              transport_account,
1214                                              from,
1215                                              data->to,
1216                                              data->cc,
1217                                              data->bcc,
1218                                              data->subject,
1219                                              data->plain_body,
1220                                              data->html_body,
1221                                              data->attachments,
1222                                              data->priority_flags);
1223         /* Frees */
1224         g_free (from);
1225         g_free (account_name);
1226         g_object_unref (G_OBJECT (transport_account));
1227         g_object_unref (G_OBJECT (mail_operation));
1228
1229         modest_msg_edit_window_free_msg_data (edit_window, data);
1230
1231         /* Save settings and close the window */
1232         gtk_widget_destroy (GTK_WIDGET (edit_window));
1233 }
1234
1235 void
1236 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1237                                   ModestMsgEditWindow *window)
1238 {
1239         ModestMsgEditFormatState *format_state = NULL;
1240
1241         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1242         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1243
1244         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1245                 return;
1246
1247         format_state = modest_msg_edit_window_get_format_state (window);
1248         g_return_if_fail (format_state != NULL);
1249
1250         format_state->bold = gtk_toggle_action_get_active (action);
1251         modest_msg_edit_window_set_format_state (window, format_state);
1252         g_free (format_state);
1253
1254 }
1255
1256 void
1257 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1258                                      ModestMsgEditWindow *window)
1259 {
1260         ModestMsgEditFormatState *format_state = NULL;
1261
1262         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1263         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1264
1265         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1266                 return;
1267
1268         format_state = modest_msg_edit_window_get_format_state (window);
1269         g_return_if_fail (format_state != NULL);
1270
1271         format_state->italics = gtk_toggle_action_get_active (action);
1272         modest_msg_edit_window_set_format_state (window, format_state);
1273         g_free (format_state);
1274
1275 }
1276
1277 void
1278 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1279                                      ModestMsgEditWindow *window)
1280 {
1281         ModestMsgEditFormatState *format_state = NULL;
1282
1283         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1284         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1285
1286         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1287                 return;
1288
1289         format_state = modest_msg_edit_window_get_format_state (window);
1290         g_return_if_fail (format_state != NULL);
1291
1292         format_state->bullet = gtk_toggle_action_get_active (action);
1293         modest_msg_edit_window_set_format_state (window, format_state);
1294         g_free (format_state);
1295
1296 }
1297
1298 void
1299 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1300                                      GtkRadioAction *selected,
1301                                      ModestMsgEditWindow *window)
1302 {
1303         ModestMsgEditFormatState *format_state = NULL;
1304         GtkJustification value;
1305
1306         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1307
1308         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1309                 return;
1310
1311         value = gtk_radio_action_get_current_value (selected);
1312
1313         format_state = modest_msg_edit_window_get_format_state (window);
1314         g_return_if_fail (format_state != NULL);
1315
1316         format_state->justification = value;
1317         modest_msg_edit_window_set_format_state (window, format_state);
1318         g_free (format_state);
1319 }
1320
1321 void
1322 modest_ui_actions_on_select_editor_color (GtkAction *action,
1323                                           ModestMsgEditWindow *window)
1324 {
1325         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1326         g_return_if_fail (GTK_IS_ACTION (action));
1327
1328         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1329                 return;
1330
1331         modest_msg_edit_window_select_color (window);
1332 }
1333
1334 void
1335 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1336                                                      ModestMsgEditWindow *window)
1337 {
1338         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1339         g_return_if_fail (GTK_IS_ACTION (action));
1340
1341         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1342                 return;
1343
1344         modest_msg_edit_window_select_background_color (window);
1345 }
1346
1347 void
1348 modest_ui_actions_on_insert_image (GtkAction *action,
1349                                    ModestMsgEditWindow *window)
1350 {
1351         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1352         g_return_if_fail (GTK_IS_ACTION (action));
1353
1354         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1355                 return;
1356
1357         modest_msg_edit_window_insert_image (window);
1358 }
1359
1360 /*
1361  * Shows a dialog with an entry that asks for some text. The returned
1362  * value must be freed by the caller. The dialog window title will be
1363  * set to @title.
1364  */
1365 static gchar *
1366 ask_for_folder_name (GtkWindow *parent_window,
1367                      const gchar *title)
1368 {
1369         GtkWidget *dialog, *entry;
1370         gchar *folder_name = NULL;
1371
1372         /* Ask for folder name */
1373         dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1374                                               parent_window,
1375                                               GTK_DIALOG_MODAL,
1376                                               GTK_STOCK_CANCEL,
1377                                               GTK_RESPONSE_REJECT,
1378                                               GTK_STOCK_OK,
1379                                               GTK_RESPONSE_ACCEPT,
1380                                               NULL);
1381         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1382                             gtk_label_new(title),
1383                             FALSE, FALSE, 0);
1384
1385         entry = gtk_entry_new_with_max_length (40);
1386         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1387                             entry,
1388                             TRUE, FALSE, 0);
1389
1390         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1391
1392         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1393                 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1394
1395         gtk_widget_destroy (dialog);
1396
1397         return folder_name;
1398 }
1399
1400 void
1401 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1402 {
1403         TnyFolderStore *parent_folder;
1404         GtkWidget *folder_view;
1405
1406         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1407
1408         folder_view = modest_main_window_get_child_widget (main_window,
1409                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1410         if (!folder_view)
1411                 return;
1412
1413         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1414
1415         if (parent_folder) {
1416                 gboolean finished = FALSE;
1417                 gint result;
1418                 gchar *folder_name = NULL, *suggested_name = NULL;
1419
1420                 /* Run the new folder dialog */
1421                 while (!finished) {
1422                         result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1423                                                                         parent_folder,
1424                                                                         suggested_name,
1425                                                                         &folder_name);
1426
1427                         if (result == GTK_RESPONSE_REJECT) {
1428                                 finished = TRUE;
1429                         } else {
1430                                 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1431                                 TnyFolder *new_folder = NULL;
1432
1433                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1434                                                                  mail_op);
1435
1436                                 new_folder = modest_mail_operation_create_folder (mail_op,
1437                                                                                   parent_folder,
1438                                                                                   (const gchar *) folder_name);
1439                                 if (new_folder) {
1440                                         g_object_unref (new_folder);
1441                                         finished = TRUE;
1442                                 }
1443 /*                              else { */
1444 /*                                      /\* TODO: check error and follow proper actions *\/ */
1445 /* /\*                                  suggested_name = X; *\/ */
1446 /*                                      /\* Show error to the user *\/ */
1447 /*                                      modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1448 /*                                                                              MODEST_INFORMATION_CREATE_FOLDER); */
1449 /*                              } */
1450                                 g_object_unref (mail_op);
1451                         }
1452                         g_free (folder_name);
1453                         folder_name = NULL;
1454                 }
1455
1456                 g_object_unref (parent_folder);
1457         }
1458 }
1459
1460 void
1461 modest_ui_actions_on_rename_folder (GtkAction *action,
1462                                      ModestMainWindow *main_window)
1463 {
1464         TnyFolderStore *folder;
1465         GtkWidget *folder_view;
1466
1467         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1468
1469         folder_view = modest_main_window_get_child_widget (main_window,
1470                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1471         if (!folder_view)
1472                 return;
1473
1474         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1475
1476         if (folder && TNY_IS_FOLDER (folder)) {
1477                 gchar *folder_name;
1478                 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1479                                                    _("Please enter a new name for the folder"));
1480
1481                 if (folder_name != NULL && strlen (folder_name) > 0) {
1482                         ModestMailOperation *mail_op;
1483
1484                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1485                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1486                                                          mail_op);
1487
1488                         modest_mail_operation_rename_folder (mail_op,
1489                                                              TNY_FOLDER (folder),
1490                                                              (const gchar *) folder_name);
1491
1492                         g_object_unref (mail_op);
1493                         g_free (folder_name);
1494                 }
1495                 g_object_unref (folder);
1496         }
1497 }
1498
1499 static void
1500 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1501 {
1502         TnyFolderStore *folder;
1503         GtkWidget *folder_view;
1504         gint response;
1505         gchar *message;
1506
1507         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1508
1509         folder_view = modest_main_window_get_child_widget (main_window,
1510                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1511         if (!folder_view)
1512                 return;
1513
1514         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1515
1516         /* Ask the user */
1517         message =  g_strdup_printf (_("mcen_nc_delete_folder_text"),
1518                                     tny_folder_get_name (TNY_FOLDER (folder)));
1519         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1520                                                             (const gchar *) message);
1521         g_free (message);
1522
1523         if (response == GTK_RESPONSE_OK) {
1524                 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE, G_OBJECT(main_window));
1525
1526                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1527                                                  mail_op);
1528                 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1529
1530                 /* Show error if happened */
1531                 if (modest_mail_operation_get_error (mail_op))
1532                         modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1533                                                                 MODEST_INFORMATION_DELETE_FOLDER);
1534
1535                 g_object_unref (G_OBJECT (mail_op));
1536         }
1537
1538         g_object_unref (G_OBJECT (folder));
1539 }
1540
1541 void
1542 modest_ui_actions_on_delete_folder (GtkAction *action,
1543                                      ModestMainWindow *main_window)
1544 {
1545         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1546
1547         delete_folder (main_window, FALSE);
1548 }
1549
1550 void
1551 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1552 {
1553         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1554
1555         delete_folder (main_window, TRUE);
1556 }
1557
1558 void
1559 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1560                                          const gchar* server_account_name,
1561                                          gchar **username,
1562                                          gchar **password,
1563                                          gboolean *cancel,
1564                                          gboolean *remember,
1565                                          ModestMainWindow *main_window)
1566 {
1567         g_return_if_fail(server_account_name);
1568         /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1569
1570 #ifdef MODEST_PLATFORM_MAEMO
1571         /* Maemo uses a different (awkward) button order,
1572          * It should probably just use gtk_alternative_dialog_button_order ().
1573          */
1574         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1575                                               NULL,
1576                                               GTK_DIALOG_MODAL,
1577                                               GTK_STOCK_OK,
1578                                               GTK_RESPONSE_ACCEPT,
1579                                               GTK_STOCK_CANCEL,
1580                                               GTK_RESPONSE_REJECT,
1581                                               NULL);
1582 #else
1583         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1584                                               NULL,
1585                                               GTK_DIALOG_MODAL,
1586                                               GTK_STOCK_CANCEL,
1587                                               GTK_RESPONSE_REJECT,
1588                                               GTK_STOCK_OK,
1589                                               GTK_RESPONSE_ACCEPT,
1590                                               NULL);
1591 #endif /* MODEST_PLATFORM_MAEMO */
1592
1593         gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1594
1595         gchar *server_name = modest_server_account_get_hostname (
1596                 modest_runtime_get_account_mgr(), server_account_name);
1597
1598         /* This causes a warning because the logical ID has no %s in it,
1599          * though the translation does, but there is not much we can do about that: */
1600         gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
1601         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1602                             FALSE, FALSE, 0);
1603         g_free (txt);
1604         g_free (server_name);
1605         server_name = NULL;
1606
1607         /* username: */
1608         gchar *initial_username = modest_server_account_get_username (
1609                 modest_runtime_get_account_mgr(), server_account_name);
1610
1611         GtkWidget *entry_username = gtk_entry_new ();
1612         if (initial_username)
1613                 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
1614         /* Dim this if a connection has ever succeeded with this username,
1615          * as per the UI spec: */
1616         const gboolean username_known =
1617                 modest_server_account_get_username_has_succeeded(
1618                         modest_runtime_get_account_mgr(), server_account_name);
1619         gtk_widget_set_sensitive (entry_username, !username_known);
1620
1621 #ifdef MODEST_PLATFORM_MAEMO
1622         /* Auto-capitalization is the default, so let's turn it off: */
1623         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
1624
1625         /* Create a size group to be used by all captions.
1626          * Note that HildonCaption does not create a default size group if we do not specify one.
1627          * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
1628         GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1629
1630         GtkWidget *caption = hildon_caption_new (sizegroup,
1631                 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
1632         gtk_widget_show (entry_username);
1633         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1634                 FALSE, FALSE, MODEST_MARGIN_HALF);
1635         gtk_widget_show (caption);
1636 #else
1637         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
1638                             TRUE, FALSE, 0);
1639 #endif /* MODEST_PLATFORM_MAEMO */
1640
1641         /* password: */
1642         GtkWidget *entry_password = gtk_entry_new ();
1643         gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
1644         gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), 0x2022); /* bullet unichar */
1645
1646 #ifdef MODEST_PLATFORM_MAEMO
1647         /* Auto-capitalization is the default, so let's turn it off: */
1648         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password), HILDON_GTK_INPUT_MODE_FULL);
1649
1650         caption = hildon_caption_new (sizegroup,
1651                 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
1652         gtk_widget_show (entry_password);
1653         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1654                 FALSE, FALSE, MODEST_MARGIN_HALF);
1655         gtk_widget_show (caption);
1656 #else
1657         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
1658                             TRUE, FALSE, 0);
1659 #endif /* MODEST_PLATFORM_MAEMO */
1660
1661 /* This is not in the Maemo UI spec:
1662         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1663         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1664                             TRUE, FALSE, 0);
1665 */
1666
1667         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1668
1669         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1670                 if (username) {
1671                         *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
1672
1673                         modest_server_account_set_username (
1674                                  modest_runtime_get_account_mgr(), server_account_name,
1675                                  *username);
1676
1677                         const gboolean username_was_changed =
1678                                 (strcmp (*username, initial_username) != 0);
1679                         if (username_was_changed) {
1680                                 /* To actually use a changed username,
1681                                  * we must reset the connection, according to pvanhoof.
1682                                  * This _might_ be a sensible way to do that: */
1683                                  TnyDevice *device = modest_runtime_get_device();
1684                                  tny_device_force_offline (device);
1685                                  tny_device_force_online (device);
1686                         }
1687                 }
1688
1689                 if (password) {
1690                         *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
1691
1692                         /* We do not save the password in the configuration,
1693                          * because this function is only called for passwords that should
1694                          * not be remembered:
1695                         modest_server_account_set_password (
1696                                  modest_runtime_get_account_mgr(), server_account_name,
1697                                  *password);
1698                         */
1699                 }
1700
1701                 if (cancel)
1702                         *cancel   = FALSE;
1703
1704         } else {
1705                 if (username)
1706                         *username = NULL;
1707
1708                 if (password)
1709                         *password = NULL;
1710
1711                 if (cancel)
1712                         *cancel   = TRUE;
1713         }
1714
1715 /* This is not in the Maemo UI spec:
1716         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1717                 *remember = TRUE;
1718         else
1719                 *remember = FALSE;
1720 */
1721
1722         gtk_widget_destroy (dialog);
1723 }
1724
1725 void
1726 modest_ui_actions_on_cut (GtkAction *action,
1727                           ModestWindow *window)
1728 {
1729         GtkWidget *focused_widget;
1730
1731         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1732         if (GTK_IS_EDITABLE (focused_widget)) {
1733                 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1734         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1735                 GtkTextBuffer *buffer;
1736                 GtkClipboard *clipboard;
1737
1738                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1739                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1740                 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1741         }
1742 }
1743
1744 void
1745 modest_ui_actions_on_copy (GtkAction *action,
1746                            ModestWindow *window)
1747 {
1748         GtkClipboard *clipboard;
1749         GtkWidget *focused_widget;
1750
1751         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1752         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1753         if (GTK_IS_LABEL (focused_widget)) {
1754                 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1755         } else if (GTK_IS_EDITABLE (focused_widget)) {
1756                 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1757         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1758                 GtkTextBuffer *buffer;
1759
1760                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1761                 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1762         }
1763 }
1764
1765 void
1766 modest_ui_actions_on_undo (GtkAction *action,
1767                            ModestWindow *window)
1768 {
1769         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1770                 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1771         } else {
1772                 g_return_if_reached ();
1773         }
1774 }
1775
1776 void
1777 modest_ui_actions_on_paste (GtkAction *action,
1778                             ModestWindow *window)
1779 {
1780         GtkWidget *focused_widget;
1781
1782         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1783         if (GTK_IS_EDITABLE (focused_widget)) {
1784                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1785         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1786                 GtkTextBuffer *buffer;
1787                 GtkClipboard *clipboard;
1788
1789                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1790                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1791                 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1792         }
1793 }
1794
1795 void
1796 modest_ui_actions_on_select_all (GtkAction *action,
1797                                  ModestWindow *window)
1798 {
1799         GtkWidget *focused_widget;
1800
1801         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1802         if (GTK_IS_LABEL (focused_widget)) {
1803                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1804         } else if (GTK_IS_EDITABLE (focused_widget)) {
1805                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1806         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1807                 GtkTextBuffer *buffer;
1808                 GtkTextIter start, end;
1809
1810                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1811                 gtk_text_buffer_get_start_iter (buffer, &start);
1812                 gtk_text_buffer_get_end_iter (buffer, &end);
1813                 gtk_text_buffer_select_range (buffer, &start, &end);
1814         }
1815 }
1816
1817 void
1818 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
1819                                   GtkRadioAction *selected,
1820                                   ModestWindow *window)
1821 {
1822         gint value;
1823
1824         value = gtk_radio_action_get_current_value (selected);
1825         if (MODEST_IS_WINDOW (window)) {
1826                 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
1827         }
1828 }
1829
1830 void     modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
1831                                                         GtkRadioAction *selected,
1832                                                         ModestWindow *window)
1833 {
1834         TnyHeaderFlags flags;
1835         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1836
1837         flags = gtk_radio_action_get_current_value (selected);
1838         modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
1839 }
1840
1841 void     modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
1842                                                            GtkRadioAction *selected,
1843                                                            ModestWindow *window)
1844 {
1845         gint file_format;
1846
1847         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1848
1849         file_format = gtk_radio_action_get_current_value (selected);
1850         modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
1851 }
1852
1853
1854 void
1855 modest_ui_actions_on_zoom_plus (GtkAction *action,
1856                                 ModestWindow *window)
1857 {
1858         g_return_if_fail (MODEST_IS_WINDOW (window));
1859
1860         modest_window_zoom_plus (MODEST_WINDOW (window));
1861 }
1862
1863 void
1864 modest_ui_actions_on_zoom_minus (GtkAction *action,
1865                                  ModestWindow *window)
1866 {
1867         g_return_if_fail (MODEST_IS_WINDOW (window));
1868
1869         modest_window_zoom_minus (MODEST_WINDOW (window));
1870 }
1871
1872 void
1873 modest_ui_actions_on_toggle_fullscreen    (GtkToggleAction *toggle,
1874                                            ModestWindow *window)
1875 {
1876         ModestWindowMgr *mgr;
1877         gboolean fullscreen, active;
1878         g_return_if_fail (MODEST_IS_WINDOW (window));
1879
1880         mgr = modest_runtime_get_window_mgr ();
1881
1882         active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
1883         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1884
1885         if (active != fullscreen) {
1886                 modest_window_mgr_set_fullscreen_mode (mgr, active);
1887                 gtk_window_present (GTK_WINDOW (window));
1888         }
1889 }
1890
1891 void
1892 modest_ui_actions_on_change_fullscreen (GtkAction *action,
1893                                         ModestWindow *window)
1894 {
1895         ModestWindowMgr *mgr;
1896         gboolean fullscreen;
1897
1898         g_return_if_fail (MODEST_IS_WINDOW (window));
1899
1900         mgr = modest_runtime_get_window_mgr ();
1901         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1902         modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
1903
1904         gtk_window_present (GTK_WINDOW (window));
1905 }
1906
1907 /*
1908  * Used by modest_ui_actions_on_details to call do_headers_action
1909  */
1910 static void
1911 headers_action_show_details (TnyHeader *header,
1912                              ModestWindow *window,
1913                              gpointer user_data)
1914
1915 {
1916         GtkWidget *dialog;
1917
1918         /* Create dialog */
1919         dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
1920
1921         /* Run dialog */
1922         gtk_widget_show_all (dialog);
1923         gtk_dialog_run (GTK_DIALOG (dialog));
1924
1925         gtk_widget_destroy (dialog);
1926 }
1927
1928 /*
1929  * Show the folder details in a ModestDetailsDialog widget
1930  */
1931 static void
1932 show_folder_details (TnyFolder *folder,
1933                      GtkWindow *window)
1934 {
1935         GtkWidget *dialog;
1936
1937         /* Create dialog */
1938         dialog = modest_details_dialog_new_with_folder (window, folder);
1939
1940         /* Run dialog */
1941         gtk_widget_show_all (dialog);
1942         gtk_dialog_run (GTK_DIALOG (dialog));
1943
1944         gtk_widget_destroy (dialog);
1945 }
1946
1947 /*
1948  * Show the header details in a ModestDetailsDialog widget
1949  */
1950 void
1951 modest_ui_actions_on_details (GtkAction *action,
1952                               ModestWindow *win)
1953 {
1954         TnyList * headers_list;
1955         TnyIterator *iter;
1956         TnyHeader *header;
1957
1958         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1959                 TnyMsg *msg;
1960
1961                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1962                 if (!msg) {
1963                         return;
1964                 } else {
1965                         headers_list = get_selected_headers (win);
1966                         if (!headers_list)
1967                                 return;
1968
1969                         iter = tny_list_create_iterator (headers_list);
1970
1971                         header = TNY_HEADER (tny_iterator_get_current (iter));
1972                         headers_action_show_details (header, win, NULL);
1973                         g_object_unref (header);
1974
1975                         g_object_unref (iter);
1976                 }
1977         } else if (MODEST_IS_MAIN_WINDOW (win)) {
1978                 GtkWidget *folder_view, *header_view;
1979
1980                 /* Check which widget has the focus */
1981                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1982                                                                     MODEST_WIDGET_TYPE_FOLDER_VIEW);
1983                 if (gtk_widget_is_focus (folder_view)) {
1984                         TnyFolder *folder;
1985
1986                         folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1987
1988                         /* Show only when it's a folder */
1989                         if (!folder || !TNY_IS_FOLDER (folder))
1990                                 return;
1991
1992                         show_folder_details (folder, GTK_WINDOW (win));
1993
1994                 } else {
1995                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1996                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1997                         /* Show details of each header */
1998                         do_headers_action (win, headers_action_show_details, header_view);
1999                 }
2000         }
2001 }
2002
2003 void
2004 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2005                                      ModestMsgEditWindow *window)
2006 {
2007         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2008
2009         modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2010 }
2011
2012 void
2013 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2014                                       ModestMsgEditWindow *window)
2015 {
2016         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2017
2018         modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2019 }
2020
2021 void
2022 modest_ui_actions_toggle_folders_view (GtkAction *action,
2023                                        ModestMainWindow *main_window)
2024 {
2025         ModestConf *conf;
2026
2027         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2028
2029         conf = modest_runtime_get_conf ();
2030
2031         if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2032                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2033         else
2034                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2035 }
2036
2037 void
2038 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2039                                      ModestWindow *window)
2040 {
2041         gboolean active, fullscreen = FALSE;
2042         ModestWindowMgr *mgr;
2043
2044         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2045
2046         /* Check if we want to toggle the toolbar vuew in fullscreen
2047            or normal mode */
2048         if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2049                      "ViewShowToolbarFullScreen")) {
2050                 fullscreen = TRUE;
2051         }
2052
2053         /* Toggle toolbar */
2054         mgr = modest_runtime_get_window_mgr ();
2055         modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2056 }
2057
2058 void
2059 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2060                                            ModestMsgEditWindow *window)
2061 {
2062         modest_msg_edit_window_select_font (window);
2063 }
2064
2065 void
2066 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2067                                                   const gchar *display_name,
2068                                                   GtkWindow *window)
2069 {
2070         /* Do not change the application name if the widget has not
2071            the focus. This callback could be called even if the folder
2072            view has not the focus, because the handled signal could be
2073            emitted when the folder view is redrawn */
2074         if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2075                 if (display_name)
2076                         gtk_window_set_title (window, display_name);
2077                 else
2078                         gtk_window_set_title (window, " ");
2079         }
2080 }
2081
2082 void
2083 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2084 {
2085         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2086         modest_msg_edit_window_select_contacts (window);
2087 }
2088
2089 void
2090 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2091 {
2092         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2093         modest_msg_edit_window_check_names (window);
2094 }
2095
2096
2097 static GtkWidget*
2098 create_move_to_dialog (ModestWindow *win,
2099                        GtkWidget *folder_view,
2100                        GtkWidget **tree_view)
2101 {
2102         GtkWidget *dialog, *scroll;
2103
2104         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2105                                               GTK_WINDOW (win),
2106                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2107                                               GTK_STOCK_OK,
2108                                               GTK_RESPONSE_ACCEPT,
2109                                               GTK_STOCK_CANCEL,
2110                                               GTK_RESPONSE_REJECT,
2111                                               NULL);
2112
2113         /* Create scrolled window */
2114         scroll = gtk_scrolled_window_new (NULL, NULL);
2115         gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scroll),
2116                                          GTK_POLICY_AUTOMATIC,
2117                                          GTK_POLICY_AUTOMATIC);
2118
2119         /* Create folder view */
2120         *tree_view = modest_folder_view_new (NULL);
2121         gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2122                                  gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2123         gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2124
2125         /* Add scroll to dialog */
2126         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2127                             scroll, FALSE, FALSE, 0);
2128
2129         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2130
2131         return dialog;
2132 }
2133
2134 /*
2135  * Returns TRUE if at least one of the headers of the list belongs to
2136  * a message that has been fully retrieved.
2137  */
2138 static gboolean
2139 has_retrieved_msgs (TnyList *list)
2140 {
2141         TnyIterator *iter;
2142         gboolean found = FALSE;
2143
2144         iter = tny_list_create_iterator (list);
2145         while (tny_iterator_is_done (iter) && !found) {
2146                 TnyHeader *header;
2147                 TnyHeaderFlags flags;
2148
2149                 header = TNY_HEADER (tny_iterator_get_current (iter));
2150                 flags = tny_header_get_flags (header);
2151                 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2152                         found = TRUE;
2153
2154                 if (!found)
2155                         tny_iterator_next (iter);
2156         }
2157         g_object_unref (iter);
2158
2159         return found;
2160 }
2161
2162 /*
2163  * Shows a confirmation dialog to the user when we're moving messages
2164  * from a remote server to the local storage. Returns the dialog
2165  * response. If it's other kind of movement the it always returns
2166  * GTK_RESPONSE_OK
2167  */
2168 static gint
2169 msgs_move_to_confirmation (GtkWindow *win,
2170                            TnyFolder *dest_folder,
2171                            TnyList *headers)
2172 {
2173         gint response = GTK_RESPONSE_OK;
2174
2175         /* If the destination is a local folder */
2176         if (modest_tny_folder_is_local_folder (dest_folder)) {
2177                 TnyFolder *src_folder;
2178                 TnyIterator *iter;
2179                 TnyHeader *header;
2180
2181                 /* Get source folder */
2182                 iter = tny_list_create_iterator (headers);
2183                 header = TNY_HEADER (tny_iterator_get_current (iter));
2184                 src_folder = tny_header_get_folder (header);
2185                 g_object_unref (header);
2186                 g_object_unref (iter);
2187
2188                 /* If the source is a remote folder */
2189                 if (!modest_tny_folder_is_local_folder (src_folder)) {
2190                         const gchar *message;
2191
2192                         if (tny_list_get_length (headers) == 1)
2193                                 if (has_retrieved_msgs (headers))
2194                                         message = _("mcen_nc_move_retrieve");
2195                                 else
2196                                         message = _("mcen_nc_move_header");
2197                         else
2198                                 if (has_retrieved_msgs (headers))
2199                                         message = _("mcen_nc_move_retrieves");
2200                                 else
2201                                         message = _("mcen_nc_move_headers");
2202
2203                         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2204                                                                             (const gchar *) message);
2205                 }
2206         }
2207         return response;
2208 }
2209
2210 /*
2211  * UI handler for the "Move to" action when invoked from the
2212  * ModestMainWindow
2213  */
2214 static void
2215 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2216                                           ModestMainWindow *win)
2217 {
2218         GtkWidget *dialog, *folder_view, *tree_view = NULL;
2219         gint result;
2220         TnyFolderStore *folder_store;
2221         ModestMailOperation *mail_op = NULL;
2222
2223         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2224
2225         /* Get the folder view */
2226         folder_view = modest_main_window_get_child_widget (win,
2227                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2228
2229         /* Create and run the dialog */
2230         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2231         result = gtk_dialog_run (GTK_DIALOG(dialog));
2232
2233         /* We do this to save an indentation level ;-) */
2234         if (result != GTK_RESPONSE_ACCEPT)
2235                 goto end;
2236
2237         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2238
2239         if (TNY_IS_ACCOUNT (folder_store))
2240                 goto end;
2241
2242         /* Get folder or messages to transfer */
2243         if (gtk_widget_is_focus (folder_view)) {
2244                 TnyFolderStore *src_folder;
2245                 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2246
2247                 if (TNY_IS_FOLDER (src_folder)) {
2248                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2249                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2250                                                          mail_op);
2251
2252                         modest_mail_operation_xfer_folder (mail_op,
2253                                                            TNY_FOLDER (src_folder),
2254                                                            folder_store,
2255                                                            TRUE);
2256                         g_object_unref (G_OBJECT (mail_op));
2257                 }
2258
2259                 /* Frees */
2260                 g_object_unref (G_OBJECT (src_folder));
2261         } else {
2262                 GtkWidget *header_view;
2263                 header_view = modest_main_window_get_child_widget (win,
2264                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
2265                 if (gtk_widget_is_focus (header_view)) {
2266                         TnyList *headers;
2267                         gint response;
2268
2269                         headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2270
2271                         /* Ask for user confirmation */
2272                         response = msgs_move_to_confirmation (GTK_WINDOW (win),
2273                                                               TNY_FOLDER (folder_store),
2274                                                               headers);
2275
2276                         /* Transfer messages */
2277                         if (response == GTK_RESPONSE_OK) {
2278                                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2279                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2280                                                                  mail_op);
2281
2282                                 modest_mail_operation_xfer_msgs (mail_op,
2283                                                                  headers,
2284                                                                  TNY_FOLDER (folder_store),
2285                                                                  TRUE);
2286                                 g_object_unref (G_OBJECT (mail_op));
2287                         }
2288                 }
2289         }
2290         g_object_unref (folder_store);
2291
2292  end:
2293         gtk_widget_destroy (dialog);
2294 }
2295
2296
2297 /*
2298  * UI handler for the "Move to" action when invoked from the
2299  * ModestMsgViewWindow
2300  */
2301 static void
2302 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2303                                               ModestMsgViewWindow *win)
2304 {
2305         GtkWidget *dialog, *folder_view, *tree_view = NULL;
2306         gint result;
2307         ModestMainWindow *main_window;
2308         TnyMsg *msg;
2309         TnyHeader *header;
2310         TnyList *headers;
2311
2312         /* Get the folder view */
2313         main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2314         folder_view = modest_main_window_get_child_widget (main_window,
2315                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2316
2317         /* Create and run the dialog */
2318         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2319         result = gtk_dialog_run (GTK_DIALOG(dialog));
2320
2321         if (result == GTK_RESPONSE_ACCEPT) {
2322                 TnyFolderStore *folder_store;
2323                 gint response;
2324
2325                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2326
2327                 /* Create header list */
2328                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2329                 header = tny_msg_get_header (msg);
2330                 headers = tny_simple_list_new ();
2331                 tny_list_prepend (headers, G_OBJECT (header));
2332                 g_object_unref (header);
2333                 g_object_unref (msg);
2334
2335                 /* Ask user for confirmation. MSG-NOT404 */
2336                 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2337                                                       TNY_FOLDER (folder_store),
2338                                                       headers);
2339
2340                 /* Transfer current msg */
2341                 if (response == GTK_RESPONSE_OK) {
2342                         ModestMailOperation *mail_op;
2343
2344                         /* Create mail op */
2345                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2346                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2347                                                          mail_op);
2348
2349                         /* Transfer messages */
2350                         modest_mail_operation_xfer_msgs (mail_op,
2351                                                          headers,
2352                                                          TNY_FOLDER (folder_store),
2353                                                          TRUE);
2354                         g_object_unref (G_OBJECT (mail_op));
2355                 } else {
2356                         g_object_unref (headers);
2357                 }
2358                 g_object_unref (folder_store);
2359         }
2360         gtk_widget_destroy (dialog);
2361 }
2362
2363 void
2364 modest_ui_actions_on_move_to (GtkAction *action,
2365                               ModestWindow *win)
2366 {
2367         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2368                           MODEST_IS_MSG_VIEW_WINDOW (win));
2369
2370         if (MODEST_IS_MAIN_WINDOW (win))
2371                 modest_ui_actions_on_main_window_move_to (action,
2372                                                           MODEST_MAIN_WINDOW (win));
2373         else
2374                 modest_ui_actions_on_msg_view_window_move_to (action,
2375                                                               MODEST_MSG_VIEW_WINDOW (win));
2376 }
2377
2378 /*
2379  * Calls #HeadersFunc for each header already selected in the main
2380  * window or the message currently being shown in the msg view window
2381  */
2382 static void
2383 do_headers_action (ModestWindow *win,
2384                    HeadersFunc func,
2385                    gpointer user_data)
2386 {
2387         TnyList *headers_list;
2388         TnyIterator *iter;
2389
2390         /* Get headers */
2391         headers_list = get_selected_headers (win);
2392         if (!headers_list)
2393                 return;
2394
2395         /* Call the function for each header */
2396         iter = tny_list_create_iterator (headers_list);
2397         while (!tny_iterator_is_done (iter)) {
2398                 TnyHeader *header;
2399
2400                 header = TNY_HEADER (tny_iterator_get_current (iter));
2401                 func (header, win, user_data);
2402                 g_object_unref (header);
2403                 tny_iterator_next (iter);
2404         }
2405         g_object_unref (iter);
2406 }