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 #endif /* MODEST_PLATFORM_MAEMO */
  50
  51 #include "widgets/modest-ui-constants.h"
  52 #include <widgets/modest-main-window.h>
  53 #include <widgets/modest-msg-view-window.h>
  54 #include <widgets/modest-account-view-window.h>
  55 #include <widgets/modest-details-dialog.h>
  56 #include <widgets/modest-attachments-view.h>
  57 #include "widgets/modest-global-settings-dialog.h"
  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         modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1096 }
1097
1098 void
1099 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1100                                           const gchar *address,
1101                                           ModestWindow *win)
1102 {
1103         /* g_message ("%s %s", __FUNCTION__, address); */
1104 }
1105
1106 void
1107 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1108 {
1109         TnyTransportAccount *transport_account;
1110         ModestMailOperation *mail_operation;
1111         MsgData *data;
1112         gchar *account_name, *from;
1113         ModestAccountMgr *account_mgr;
1114
1115         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1116
1117         data = modest_msg_edit_window_get_msg_data (edit_window);
1118
1119         account_mgr = modest_runtime_get_account_mgr();
1120         account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1121         if (!account_name)
1122                 account_name = modest_account_mgr_get_default_account (account_mgr);
1123         if (!account_name) {
1124                 g_printerr ("modest: no account found\n");
1125                 modest_msg_edit_window_free_msg_data (edit_window, data);
1126                 return;
1127         }
1128         transport_account =
1129                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
1130                                       (modest_runtime_get_account_store(),
1131                                        account_name,
1132                                        TNY_ACCOUNT_TYPE_TRANSPORT));
1133         if (!transport_account) {
1134                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1135                 g_free (account_name);
1136                 modest_msg_edit_window_free_msg_data (edit_window, data);
1137                 return;
1138         }
1139         from = modest_account_mgr_get_from_string (account_mgr, account_name);
1140
1141         /* Create the mail operation */
1142         mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(edit_window));
1143         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1144
1145         modest_mail_operation_save_to_drafts (mail_operation,
1146                                               transport_account,
1147                                               from,
1148                                               data->to,
1149                                               data->cc,
1150                                               data->bcc,
1151                                               data->subject,
1152                                               data->plain_body,
1153                                               data->html_body,
1154                                               data->attachments,
1155                                               data->priority_flags);
1156         /* Frees */
1157         g_free (from);
1158         g_free (account_name);
1159         g_object_unref (G_OBJECT (transport_account));
1160         g_object_unref (G_OBJECT (mail_operation));
1161
1162         modest_msg_edit_window_free_msg_data (edit_window, data);
1163
1164         /* Save settings and close the window */
1165         gtk_widget_destroy (GTK_WIDGET (edit_window));
1166 }
1167 void
1168 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1169 {
1170         TnyTransportAccount *transport_account;
1171         ModestMailOperation *mail_operation;
1172         MsgData *data;
1173         gchar *account_name, *from;
1174         ModestAccountMgr *account_mgr;
1175
1176         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1177
1178         if (!modest_msg_edit_window_check_names (edit_window))
1179                 return;
1180
1181         data = modest_msg_edit_window_get_msg_data (edit_window);
1182
1183         /* FIXME: Code added just for testing. The final version will
1184            use the send queue provided by tinymail and some
1185            classifier */
1186         account_mgr = modest_runtime_get_account_mgr();
1187         account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1188         if (!account_name)
1189                 account_name = modest_account_mgr_get_default_account (account_mgr);
1190         if (!account_name) {
1191                 g_printerr ("modest: no account found\n");
1192                 modest_msg_edit_window_free_msg_data (edit_window, data);
1193                 return;
1194         }
1195         transport_account =
1196                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1197                                       (modest_runtime_get_account_store(),
1198                                        account_name));
1199         if (!transport_account) {
1200                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1201                 g_free (account_name);
1202                 modest_msg_edit_window_free_msg_data (edit_window, data);
1203                 return;
1204         }
1205         from = modest_account_mgr_get_from_string (account_mgr, account_name);
1206
1207         /* Create the mail operation */
1208         mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_SEND, G_OBJECT(edit_window));
1209         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1210
1211         modest_mail_operation_send_new_mail (mail_operation,
1212                                              transport_account,
1213                                              from,
1214                                              data->to,
1215                                              data->cc,
1216                                              data->bcc,
1217                                              data->subject,
1218                                              data->plain_body,
1219                                              data->html_body,
1220                                              data->attachments,
1221                                              data->priority_flags);
1222         /* Frees */
1223         g_free (from);
1224         g_free (account_name);
1225         g_object_unref (G_OBJECT (transport_account));
1226         g_object_unref (G_OBJECT (mail_operation));
1227
1228         modest_msg_edit_window_free_msg_data (edit_window, data);
1229
1230         /* Save settings and close the window */
1231         gtk_widget_destroy (GTK_WIDGET (edit_window));
1232 }
1233
1234 void
1235 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1236                                   ModestMsgEditWindow *window)
1237 {
1238         ModestMsgEditFormatState *format_state = NULL;
1239
1240         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1241         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1242
1243         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1244                 return;
1245
1246         format_state = modest_msg_edit_window_get_format_state (window);
1247         g_return_if_fail (format_state != NULL);
1248
1249         format_state->bold = gtk_toggle_action_get_active (action);
1250         modest_msg_edit_window_set_format_state (window, format_state);
1251         g_free (format_state);
1252
1253 }
1254
1255 void
1256 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1257                                      ModestMsgEditWindow *window)
1258 {
1259         ModestMsgEditFormatState *format_state = NULL;
1260
1261         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1262         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1263
1264         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1265                 return;
1266
1267         format_state = modest_msg_edit_window_get_format_state (window);
1268         g_return_if_fail (format_state != NULL);
1269
1270         format_state->italics = gtk_toggle_action_get_active (action);
1271         modest_msg_edit_window_set_format_state (window, format_state);
1272         g_free (format_state);
1273
1274 }
1275
1276 void
1277 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1278                                      ModestMsgEditWindow *window)
1279 {
1280         ModestMsgEditFormatState *format_state = NULL;
1281
1282         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1283         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1284
1285         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1286                 return;
1287
1288         format_state = modest_msg_edit_window_get_format_state (window);
1289         g_return_if_fail (format_state != NULL);
1290
1291         format_state->bullet = gtk_toggle_action_get_active (action);
1292         modest_msg_edit_window_set_format_state (window, format_state);
1293         g_free (format_state);
1294
1295 }
1296
1297 void
1298 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1299                                      GtkRadioAction *selected,
1300                                      ModestMsgEditWindow *window)
1301 {
1302         ModestMsgEditFormatState *format_state = NULL;
1303         GtkJustification value;
1304
1305         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1306
1307         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1308                 return;
1309
1310         value = gtk_radio_action_get_current_value (selected);
1311
1312         format_state = modest_msg_edit_window_get_format_state (window);
1313         g_return_if_fail (format_state != NULL);
1314
1315         format_state->justification = value;
1316         modest_msg_edit_window_set_format_state (window, format_state);
1317         g_free (format_state);
1318 }
1319
1320 void
1321 modest_ui_actions_on_select_editor_color (GtkAction *action,
1322                                           ModestMsgEditWindow *window)
1323 {
1324         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1325         g_return_if_fail (GTK_IS_ACTION (action));
1326
1327         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1328                 return;
1329
1330         modest_msg_edit_window_select_color (window);
1331 }
1332
1333 void
1334 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1335                                                      ModestMsgEditWindow *window)
1336 {
1337         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1338         g_return_if_fail (GTK_IS_ACTION (action));
1339
1340         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1341                 return;
1342
1343         modest_msg_edit_window_select_background_color (window);
1344 }
1345
1346 void
1347 modest_ui_actions_on_insert_image (GtkAction *action,
1348                                    ModestMsgEditWindow *window)
1349 {
1350         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1351         g_return_if_fail (GTK_IS_ACTION (action));
1352
1353         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1354                 return;
1355
1356         modest_msg_edit_window_insert_image (window);
1357 }
1358
1359 void
1360 modest_ui_actions_on_attach_file (GtkAction *action,
1361                                   ModestMsgEditWindow *window)
1362 {
1363         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1364         g_return_if_fail (GTK_IS_ACTION (action));
1365
1366         modest_msg_edit_window_attach_file (window);
1367 }
1368
1369 void
1370 modest_ui_actions_on_remove_attachments (GtkAction *action,
1371                                          ModestMsgEditWindow *window)
1372 {
1373         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1374         g_return_if_fail (GTK_IS_ACTION (action));
1375
1376         modest_msg_edit_window_remove_attachments (window, NULL);
1377 }
1378
1379 /*
1380  * Shows a dialog with an entry that asks for some text. The returned
1381  * value must be freed by the caller. The dialog window title will be
1382  * set to @title.
1383  */
1384 static gchar *
1385 ask_for_folder_name (GtkWindow *parent_window,
1386                      const gchar *title)
1387 {
1388         GtkWidget *dialog, *entry;
1389         gchar *folder_name = NULL;
1390
1391         /* Ask for folder name */
1392         dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1393                                               parent_window,
1394                                               GTK_DIALOG_MODAL,
1395                                               GTK_STOCK_CANCEL,
1396                                               GTK_RESPONSE_REJECT,
1397                                               GTK_STOCK_OK,
1398                                               GTK_RESPONSE_ACCEPT,
1399                                               NULL);
1400         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1401                             gtk_label_new(title),
1402                             FALSE, FALSE, 0);
1403
1404         entry = gtk_entry_new_with_max_length (40);
1405         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1406                             entry,
1407                             TRUE, FALSE, 0);
1408
1409         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1410
1411         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1412                 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1413
1414         gtk_widget_destroy (dialog);
1415
1416         return folder_name;
1417 }
1418
1419 void
1420 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1421 {
1422         TnyFolderStore *parent_folder;
1423         GtkWidget *folder_view;
1424
1425         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1426
1427         folder_view = modest_main_window_get_child_widget (main_window,
1428                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1429         if (!folder_view)
1430                 return;
1431
1432         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1433
1434         if (parent_folder) {
1435                 gboolean finished = FALSE;
1436                 gint result;
1437                 gchar *folder_name = NULL, *suggested_name = NULL;
1438
1439                 /* Run the new folder dialog */
1440                 while (!finished) {
1441                         result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1442                                                                         parent_folder,
1443                                                                         suggested_name,
1444                                                                         &folder_name);
1445
1446                         if (result == GTK_RESPONSE_REJECT) {
1447                                 finished = TRUE;
1448                         } else {
1449                                 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1450                                 TnyFolder *new_folder = NULL;
1451
1452                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1453                                                                  mail_op);
1454
1455                                 new_folder = modest_mail_operation_create_folder (mail_op,
1456                                                                                   parent_folder,
1457                                                                                   (const gchar *) folder_name);
1458                                 if (new_folder) {
1459                                         g_object_unref (new_folder);
1460                                         finished = TRUE;
1461                                 }
1462 /*                              else { */
1463 /*                                      /\* TODO: check error and follow proper actions *\/ */
1464 /* /\*                                  suggested_name = X; *\/ */
1465 /*                                      /\* Show error to the user *\/ */
1466 /*                                      modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1467 /*                                                                              MODEST_INFORMATION_CREATE_FOLDER); */
1468 /*                              } */
1469                                 g_object_unref (mail_op);
1470                         }
1471                         g_free (folder_name);
1472                         folder_name = NULL;
1473                 }
1474
1475                 g_object_unref (parent_folder);
1476         }
1477 }
1478
1479 void
1480 modest_ui_actions_on_rename_folder (GtkAction *action,
1481                                      ModestMainWindow *main_window)
1482 {
1483         TnyFolderStore *folder;
1484         GtkWidget *folder_view;
1485
1486         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1487
1488         folder_view = modest_main_window_get_child_widget (main_window,
1489                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1490         if (!folder_view)
1491                 return;
1492
1493         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1494
1495         if (folder && TNY_IS_FOLDER (folder)) {
1496                 gchar *folder_name;
1497                 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1498                                                    _("Please enter a new name for the folder"));
1499
1500                 if (folder_name != NULL && strlen (folder_name) > 0) {
1501                         ModestMailOperation *mail_op;
1502
1503                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1504                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1505                                                          mail_op);
1506
1507                         modest_mail_operation_rename_folder (mail_op,
1508                                                              TNY_FOLDER (folder),
1509                                                              (const gchar *) folder_name);
1510
1511                         g_object_unref (mail_op);
1512                         g_free (folder_name);
1513                 }
1514                 g_object_unref (folder);
1515         }
1516 }
1517
1518 static void
1519 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1520 {
1521         TnyFolderStore *folder;
1522         GtkWidget *folder_view;
1523         gint response;
1524         gchar *message;
1525
1526         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1527
1528         folder_view = modest_main_window_get_child_widget (main_window,
1529                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1530         if (!folder_view)
1531                 return;
1532
1533         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1534
1535         /* Ask the user */
1536         message =  g_strdup_printf (_("mcen_nc_delete_folder_text"),
1537                                     tny_folder_get_name (TNY_FOLDER (folder)));
1538         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1539                                                             (const gchar *) message);
1540         g_free (message);
1541
1542         if (response == GTK_RESPONSE_OK) {
1543                 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE, G_OBJECT(main_window));
1544
1545                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1546                                                  mail_op);
1547                 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1548
1549                 /* Show error if happened */
1550                 if (modest_mail_operation_get_error (mail_op))
1551                         modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1552                                                                 MODEST_INFORMATION_DELETE_FOLDER);
1553
1554                 g_object_unref (G_OBJECT (mail_op));
1555         }
1556
1557         g_object_unref (G_OBJECT (folder));
1558 }
1559
1560 void
1561 modest_ui_actions_on_delete_folder (GtkAction *action,
1562                                      ModestMainWindow *main_window)
1563 {
1564         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1565
1566         delete_folder (main_window, FALSE);
1567 }
1568
1569 void
1570 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1571 {
1572         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1573
1574         delete_folder (main_window, TRUE);
1575 }
1576
1577 void
1578 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1579                                          const gchar* server_account_name,
1580                                          gchar **username,
1581                                          gchar **password,
1582                                          gboolean *cancel,
1583                                          gboolean *remember,
1584                                          ModestMainWindow *main_window)
1585 {
1586         g_return_if_fail(server_account_name);
1587         /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1588
1589 #ifdef MODEST_PLATFORM_MAEMO
1590         /* Maemo uses a different (awkward) button order,
1591          * It should probably just use gtk_alternative_dialog_button_order ().
1592          */
1593         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1594                                               NULL,
1595                                               GTK_DIALOG_MODAL,
1596                                               GTK_STOCK_OK,
1597                                               GTK_RESPONSE_ACCEPT,
1598                                               GTK_STOCK_CANCEL,
1599                                               GTK_RESPONSE_REJECT,
1600                                               NULL);
1601 #else
1602         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1603                                               NULL,
1604                                               GTK_DIALOG_MODAL,
1605                                               GTK_STOCK_CANCEL,
1606                                               GTK_RESPONSE_REJECT,
1607                                               GTK_STOCK_OK,
1608                                               GTK_RESPONSE_ACCEPT,
1609                                               NULL);
1610 #endif /* MODEST_PLATFORM_MAEMO */
1611
1612         gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1613
1614         gchar *server_name = modest_server_account_get_hostname (
1615                 modest_runtime_get_account_mgr(), server_account_name);
1616
1617         /* This causes a warning because the logical ID has no %s in it,
1618          * though the translation does, but there is not much we can do about that: */
1619         gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
1620         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1621                             FALSE, FALSE, 0);
1622         g_free (txt);
1623         g_free (server_name);
1624         server_name = NULL;
1625
1626         /* username: */
1627         gchar *initial_username = modest_server_account_get_username (
1628                 modest_runtime_get_account_mgr(), server_account_name);
1629
1630         GtkWidget *entry_username = gtk_entry_new ();
1631         if (initial_username)
1632                 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
1633         /* Dim this if a connection has ever succeeded with this username,
1634          * as per the UI spec: */
1635         const gboolean username_known =
1636                 modest_server_account_get_username_has_succeeded(
1637                         modest_runtime_get_account_mgr(), server_account_name);
1638         gtk_widget_set_sensitive (entry_username, !username_known);
1639
1640 #ifdef MODEST_PLATFORM_MAEMO
1641         /* Auto-capitalization is the default, so let's turn it off: */
1642         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
1643
1644         /* Create a size group to be used by all captions.
1645          * Note that HildonCaption does not create a default size group if we do not specify one.
1646          * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
1647         GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1648
1649         GtkWidget *caption = hildon_caption_new (sizegroup,
1650                 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
1651         gtk_widget_show (entry_username);
1652         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1653                 FALSE, FALSE, MODEST_MARGIN_HALF);
1654         gtk_widget_show (caption);
1655 #else
1656         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
1657                             TRUE, FALSE, 0);
1658 #endif /* MODEST_PLATFORM_MAEMO */
1659
1660         /* password: */
1661         GtkWidget *entry_password = gtk_entry_new ();
1662         gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
1663         gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), 0x2022); /* bullet unichar */
1664
1665 #ifdef MODEST_PLATFORM_MAEMO
1666         /* Auto-capitalization is the default, so let's turn it off: */
1667         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password), HILDON_GTK_INPUT_MODE_FULL);
1668
1669         caption = hildon_caption_new (sizegroup,
1670                 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
1671         gtk_widget_show (entry_password);
1672         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1673                 FALSE, FALSE, MODEST_MARGIN_HALF);
1674         gtk_widget_show (caption);
1675         g_object_unref (sizegroup);
1676 #else
1677         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
1678                             TRUE, FALSE, 0);
1679 #endif /* MODEST_PLATFORM_MAEMO */
1680
1681 /* This is not in the Maemo UI spec:
1682         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1683         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1684                             TRUE, FALSE, 0);
1685 */
1686
1687         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1688
1689         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1690                 if (username) {
1691                         *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
1692
1693                         modest_server_account_set_username (
1694                                  modest_runtime_get_account_mgr(), server_account_name,
1695                                  *username);
1696
1697                         const gboolean username_was_changed =
1698                                 (strcmp (*username, initial_username) != 0);
1699                         if (username_was_changed) {
1700                                 /* To actually use a changed username,
1701                                  * we must reset the connection, according to pvanhoof.
1702                                  * This _might_ be a sensible way to do that: */
1703                                  TnyDevice *device = modest_runtime_get_device();
1704                                  tny_device_force_offline (device);
1705                                  tny_device_force_online (device);
1706                         }
1707                 }
1708
1709                 if (password) {
1710                         *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
1711
1712                         /* We do not save the password in the configuration,
1713                          * because this function is only called for passwords that should
1714                          * not be remembered:
1715                         modest_server_account_set_password (
1716                                  modest_runtime_get_account_mgr(), server_account_name,
1717                                  *password);
1718                         */
1719                 }
1720
1721                 if (cancel)
1722                         *cancel   = FALSE;
1723
1724         } else {
1725                 if (username)
1726                         *username = NULL;
1727
1728                 if (password)
1729                         *password = NULL;
1730
1731                 if (cancel)
1732                         *cancel   = TRUE;
1733         }
1734
1735 /* This is not in the Maemo UI spec:
1736         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1737                 *remember = TRUE;
1738         else
1739                 *remember = FALSE;
1740 */
1741
1742         gtk_widget_destroy (dialog);
1743 }
1744
1745 void
1746 modest_ui_actions_on_cut (GtkAction *action,
1747                           ModestWindow *window)
1748 {
1749         GtkWidget *focused_widget;
1750
1751         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1752         if (GTK_IS_EDITABLE (focused_widget)) {
1753                 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1754         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1755                 GtkTextBuffer *buffer;
1756                 GtkClipboard *clipboard;
1757
1758                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1759                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1760                 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1761         }
1762 }
1763
1764 void
1765 modest_ui_actions_on_copy (GtkAction *action,
1766                            ModestWindow *window)
1767 {
1768         GtkClipboard *clipboard;
1769         GtkWidget *focused_widget;
1770
1771         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1772         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1773         if (GTK_IS_LABEL (focused_widget)) {
1774                 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1775         } else if (GTK_IS_EDITABLE (focused_widget)) {
1776                 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1777         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1778                 GtkTextBuffer *buffer;
1779
1780                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1781                 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1782         }
1783 }
1784
1785 void
1786 modest_ui_actions_on_undo (GtkAction *action,
1787                            ModestWindow *window)
1788 {
1789         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1790                 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1791         } else {
1792                 g_return_if_reached ();
1793         }
1794 }
1795
1796 void
1797 modest_ui_actions_on_paste (GtkAction *action,
1798                             ModestWindow *window)
1799 {
1800         GtkWidget *focused_widget;
1801
1802         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1803         if (GTK_IS_EDITABLE (focused_widget)) {
1804                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1805         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1806                 GtkTextBuffer *buffer;
1807                 GtkClipboard *clipboard;
1808
1809                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1810                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1811                 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1812         }
1813 }
1814
1815 void
1816 modest_ui_actions_on_select_all (GtkAction *action,
1817                                  ModestWindow *window)
1818 {
1819         GtkWidget *focused_widget;
1820
1821         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1822         if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
1823                 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
1824         } else if (GTK_IS_LABEL (focused_widget)) {
1825                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1826         } else if (GTK_IS_EDITABLE (focused_widget)) {
1827                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1828         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1829                 GtkTextBuffer *buffer;
1830                 GtkTextIter start, end;
1831
1832                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1833                 gtk_text_buffer_get_start_iter (buffer, &start);
1834                 gtk_text_buffer_get_end_iter (buffer, &end);
1835                 gtk_text_buffer_select_range (buffer, &start, &end);
1836         }
1837 }
1838
1839 void
1840 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
1841                                   GtkRadioAction *selected,
1842                                   ModestWindow *window)
1843 {
1844         gint value;
1845
1846         value = gtk_radio_action_get_current_value (selected);
1847         if (MODEST_IS_WINDOW (window)) {
1848                 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
1849         }
1850 }
1851
1852 void     modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
1853                                                         GtkRadioAction *selected,
1854                                                         ModestWindow *window)
1855 {
1856         TnyHeaderFlags flags;
1857         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1858
1859         flags = gtk_radio_action_get_current_value (selected);
1860         modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
1861 }
1862
1863 void     modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
1864                                                            GtkRadioAction *selected,
1865                                                            ModestWindow *window)
1866 {
1867         gint file_format;
1868
1869         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1870
1871         file_format = gtk_radio_action_get_current_value (selected);
1872         modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
1873 }
1874
1875
1876 void
1877 modest_ui_actions_on_zoom_plus (GtkAction *action,
1878                                 ModestWindow *window)
1879 {
1880         g_return_if_fail (MODEST_IS_WINDOW (window));
1881
1882         modest_window_zoom_plus (MODEST_WINDOW (window));
1883 }
1884
1885 void
1886 modest_ui_actions_on_zoom_minus (GtkAction *action,
1887                                  ModestWindow *window)
1888 {
1889         g_return_if_fail (MODEST_IS_WINDOW (window));
1890
1891         modest_window_zoom_minus (MODEST_WINDOW (window));
1892 }
1893
1894 void
1895 modest_ui_actions_on_toggle_fullscreen    (GtkToggleAction *toggle,
1896                                            ModestWindow *window)
1897 {
1898         ModestWindowMgr *mgr;
1899         gboolean fullscreen, active;
1900         g_return_if_fail (MODEST_IS_WINDOW (window));
1901
1902         mgr = modest_runtime_get_window_mgr ();
1903
1904         active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
1905         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1906
1907         if (active != fullscreen) {
1908                 modest_window_mgr_set_fullscreen_mode (mgr, active);
1909                 gtk_window_present (GTK_WINDOW (window));
1910         }
1911 }
1912
1913 void
1914 modest_ui_actions_on_change_fullscreen (GtkAction *action,
1915                                         ModestWindow *window)
1916 {
1917         ModestWindowMgr *mgr;
1918         gboolean fullscreen;
1919
1920         g_return_if_fail (MODEST_IS_WINDOW (window));
1921
1922         mgr = modest_runtime_get_window_mgr ();
1923         fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1924         modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
1925
1926         gtk_window_present (GTK_WINDOW (window));
1927 }
1928
1929 /*
1930  * Used by modest_ui_actions_on_details to call do_headers_action
1931  */
1932 static void
1933 headers_action_show_details (TnyHeader *header,
1934                              ModestWindow *window,
1935                              gpointer user_data)
1936
1937 {
1938         GtkWidget *dialog;
1939
1940         /* Create dialog */
1941         dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
1942
1943         /* Run dialog */
1944         gtk_widget_show_all (dialog);
1945         gtk_dialog_run (GTK_DIALOG (dialog));
1946
1947         gtk_widget_destroy (dialog);
1948 }
1949
1950 /*
1951  * Show the folder details in a ModestDetailsDialog widget
1952  */
1953 static void
1954 show_folder_details (TnyFolder *folder,
1955                      GtkWindow *window)
1956 {
1957         GtkWidget *dialog;
1958
1959         /* Create dialog */
1960         dialog = modest_details_dialog_new_with_folder (window, folder);
1961
1962         /* Run dialog */
1963         gtk_widget_show_all (dialog);
1964         gtk_dialog_run (GTK_DIALOG (dialog));
1965
1966         gtk_widget_destroy (dialog);
1967 }
1968
1969 /*
1970  * Show the header details in a ModestDetailsDialog widget
1971  */
1972 void
1973 modest_ui_actions_on_details (GtkAction *action,
1974                               ModestWindow *win)
1975 {
1976         TnyList * headers_list;
1977         TnyIterator *iter;
1978         TnyHeader *header;
1979
1980         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1981                 TnyMsg *msg;
1982
1983                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1984                 if (!msg) {
1985                         return;
1986                 } else {
1987                         headers_list = get_selected_headers (win);
1988                         if (!headers_list)
1989                                 return;
1990
1991                         iter = tny_list_create_iterator (headers_list);
1992
1993                         header = TNY_HEADER (tny_iterator_get_current (iter));
1994                         headers_action_show_details (header, win, NULL);
1995                         g_object_unref (header);
1996
1997                         g_object_unref (iter);
1998                 }
1999         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2000                 GtkWidget *folder_view, *header_view;
2001
2002                 /* Check which widget has the focus */
2003                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2004                                                                     MODEST_WIDGET_TYPE_FOLDER_VIEW);
2005                 if (gtk_widget_is_focus (folder_view)) {
2006                         TnyFolder *folder;
2007
2008                         folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2009
2010                         /* Show only when it's a folder */
2011                         if (!folder || !TNY_IS_FOLDER (folder))
2012                                 return;
2013
2014                         show_folder_details (folder, GTK_WINDOW (win));
2015
2016                 } else {
2017                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2018                                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
2019                         /* Show details of each header */
2020                         do_headers_action (win, headers_action_show_details, header_view);
2021                 }
2022         }
2023 }
2024
2025 void
2026 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2027                                      ModestMsgEditWindow *window)
2028 {
2029         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2030
2031         modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2032 }
2033
2034 void
2035 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2036                                       ModestMsgEditWindow *window)
2037 {
2038         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2039
2040         modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2041 }
2042
2043 void
2044 modest_ui_actions_toggle_folders_view (GtkAction *action,
2045                                        ModestMainWindow *main_window)
2046 {
2047         ModestConf *conf;
2048
2049         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2050
2051         conf = modest_runtime_get_conf ();
2052
2053         if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2054                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2055         else
2056                 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2057 }
2058
2059 void
2060 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2061                                      ModestWindow *window)
2062 {
2063         gboolean active, fullscreen = FALSE;
2064         ModestWindowMgr *mgr;
2065
2066         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2067
2068         /* Check if we want to toggle the toolbar vuew in fullscreen
2069            or normal mode */
2070         if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2071                      "ViewShowToolbarFullScreen")) {
2072                 fullscreen = TRUE;
2073         }
2074
2075         /* Toggle toolbar */
2076         mgr = modest_runtime_get_window_mgr ();
2077         modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2078 }
2079
2080 void
2081 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2082                                            ModestMsgEditWindow *window)
2083 {
2084         modest_msg_edit_window_select_font (window);
2085 }
2086
2087 void
2088 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2089                                                   const gchar *display_name,
2090                                                   GtkWindow *window)
2091 {
2092         /* Do not change the application name if the widget has not
2093            the focus. This callback could be called even if the folder
2094            view has not the focus, because the handled signal could be
2095            emitted when the folder view is redrawn */
2096         if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2097                 if (display_name)
2098                         gtk_window_set_title (window, display_name);
2099                 else
2100                         gtk_window_set_title (window, " ");
2101         }
2102 }
2103
2104 void
2105 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2106 {
2107         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2108         modest_msg_edit_window_select_contacts (window);
2109 }
2110
2111 void
2112 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2113 {
2114         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2115         modest_msg_edit_window_check_names (window);
2116 }
2117
2118
2119 static GtkWidget*
2120 create_move_to_dialog (ModestWindow *win,
2121                        GtkWidget *folder_view,
2122                        GtkWidget **tree_view)
2123 {
2124         GtkWidget *dialog, *scroll;
2125
2126         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2127                                               GTK_WINDOW (win),
2128                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2129                                               GTK_STOCK_OK,
2130                                               GTK_RESPONSE_ACCEPT,
2131                                               GTK_STOCK_CANCEL,
2132                                               GTK_RESPONSE_REJECT,
2133                                               NULL);
2134
2135         /* Create scrolled window */
2136         scroll = gtk_scrolled_window_new (NULL, NULL);
2137         gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scroll),
2138                                          GTK_POLICY_AUTOMATIC,
2139                                          GTK_POLICY_AUTOMATIC);
2140
2141         /* Create folder view */
2142         *tree_view = modest_folder_view_new (NULL);
2143         gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2144                                  gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2145         gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2146
2147         /* Add scroll to dialog */
2148         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2149                             scroll, FALSE, FALSE, 0);
2150
2151         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2152
2153         return dialog;
2154 }
2155
2156 /*
2157  * Returns TRUE if at least one of the headers of the list belongs to
2158  * a message that has been fully retrieved.
2159  */
2160 static gboolean
2161 has_retrieved_msgs (TnyList *list)
2162 {
2163         TnyIterator *iter;
2164         gboolean found = FALSE;
2165
2166         iter = tny_list_create_iterator (list);
2167         while (tny_iterator_is_done (iter) && !found) {
2168                 TnyHeader *header;
2169                 TnyHeaderFlags flags;
2170
2171                 header = TNY_HEADER (tny_iterator_get_current (iter));
2172                 flags = tny_header_get_flags (header);
2173                 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2174                         found = TRUE;
2175
2176                 if (!found)
2177                         tny_iterator_next (iter);
2178         }
2179         g_object_unref (iter);
2180
2181         return found;
2182 }
2183
2184 /*
2185  * Shows a confirmation dialog to the user when we're moving messages
2186  * from a remote server to the local storage. Returns the dialog
2187  * response. If it's other kind of movement the it always returns
2188  * GTK_RESPONSE_OK
2189  */
2190 static gint
2191 msgs_move_to_confirmation (GtkWindow *win,
2192                            TnyFolder *dest_folder,
2193                            TnyList *headers)
2194 {
2195         gint response = GTK_RESPONSE_OK;
2196
2197         /* If the destination is a local folder */
2198         if (modest_tny_folder_is_local_folder (dest_folder)) {
2199                 TnyFolder *src_folder;
2200                 TnyIterator *iter;
2201                 TnyHeader *header;
2202
2203                 /* Get source folder */
2204                 iter = tny_list_create_iterator (headers);
2205                 header = TNY_HEADER (tny_iterator_get_current (iter));
2206                 src_folder = tny_header_get_folder (header);
2207                 g_object_unref (header);
2208                 g_object_unref (iter);
2209
2210                 /* If the source is a remote folder */
2211                 if (!modest_tny_folder_is_local_folder (src_folder)) {
2212                         const gchar *message;
2213
2214                         if (tny_list_get_length (headers) == 1)
2215                                 if (has_retrieved_msgs (headers))
2216                                         message = _("mcen_nc_move_retrieve");
2217                                 else
2218                                         message = _("mcen_nc_move_header");
2219                         else
2220                                 if (has_retrieved_msgs (headers))
2221                                         message = _("mcen_nc_move_retrieves");
2222                                 else
2223                                         message = _("mcen_nc_move_headers");
2224
2225                         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2226                                                                             (const gchar *) message);
2227                 }
2228         }
2229         return response;
2230 }
2231
2232 /*
2233  * UI handler for the "Move to" action when invoked from the
2234  * ModestMainWindow
2235  */
2236 static void
2237 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2238                                           ModestMainWindow *win)
2239 {
2240         GtkWidget *dialog, *folder_view, *tree_view = NULL;
2241         gint result;
2242         TnyFolderStore *folder_store;
2243         ModestMailOperation *mail_op = NULL;
2244
2245         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2246
2247         /* Get the folder view */
2248         folder_view = modest_main_window_get_child_widget (win,
2249                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2250
2251         /* Create and run the dialog */
2252         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2253         result = gtk_dialog_run (GTK_DIALOG(dialog));
2254
2255         /* We do this to save an indentation level ;-) */
2256         if (result != GTK_RESPONSE_ACCEPT)
2257                 goto end;
2258
2259         folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2260
2261         if (TNY_IS_ACCOUNT (folder_store))
2262                 goto end;
2263
2264         /* Get folder or messages to transfer */
2265         if (gtk_widget_is_focus (folder_view)) {
2266                 TnyFolderStore *src_folder;
2267                 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2268
2269                 if (TNY_IS_FOLDER (src_folder)) {
2270                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2271                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2272                                                          mail_op);
2273
2274                         modest_mail_operation_xfer_folder (mail_op,
2275                                                            TNY_FOLDER (src_folder),
2276                                                            folder_store,
2277                                                            TRUE);
2278                         g_object_unref (G_OBJECT (mail_op));
2279                 }
2280
2281                 /* Frees */
2282                 g_object_unref (G_OBJECT (src_folder));
2283         } else {
2284                 GtkWidget *header_view;
2285                 header_view = modest_main_window_get_child_widget (win,
2286                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
2287                 if (gtk_widget_is_focus (header_view)) {
2288                         TnyList *headers;
2289                         gint response;
2290
2291                         headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2292
2293                         /* Ask for user confirmation */
2294                         response = msgs_move_to_confirmation (GTK_WINDOW (win),
2295                                                               TNY_FOLDER (folder_store),
2296                                                               headers);
2297
2298                         /* Transfer messages */
2299                         if (response == GTK_RESPONSE_OK) {
2300                                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2301                                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2302                                                                  mail_op);
2303
2304                                 modest_mail_operation_xfer_msgs (mail_op,
2305                                                                  headers,
2306                                                                  TNY_FOLDER (folder_store),
2307                                                                  TRUE);
2308                                 g_object_unref (G_OBJECT (mail_op));
2309                         }
2310                 }
2311         }
2312         g_object_unref (folder_store);
2313
2314  end:
2315         gtk_widget_destroy (dialog);
2316 }
2317
2318
2319 /*
2320  * UI handler for the "Move to" action when invoked from the
2321  * ModestMsgViewWindow
2322  */
2323 static void
2324 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2325                                               ModestMsgViewWindow *win)
2326 {
2327         GtkWidget *dialog, *folder_view, *tree_view = NULL;
2328         gint result;
2329         ModestMainWindow *main_window;
2330         TnyMsg *msg;
2331         TnyHeader *header;
2332         TnyList *headers;
2333
2334         /* Get the folder view */
2335         main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2336         folder_view = modest_main_window_get_child_widget (main_window,
2337                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2338
2339         /* Create and run the dialog */
2340         dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2341         result = gtk_dialog_run (GTK_DIALOG(dialog));
2342
2343         if (result == GTK_RESPONSE_ACCEPT) {
2344                 TnyFolderStore *folder_store;
2345                 gint response;
2346
2347                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2348
2349                 /* Create header list */
2350                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2351                 header = tny_msg_get_header (msg);
2352                 headers = tny_simple_list_new ();
2353                 tny_list_prepend (headers, G_OBJECT (header));
2354                 g_object_unref (header);
2355                 g_object_unref (msg);
2356
2357                 /* Ask user for confirmation. MSG-NOT404 */
2358                 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2359                                                       TNY_FOLDER (folder_store),
2360                                                       headers);
2361
2362                 /* Transfer current msg */
2363                 if (response == GTK_RESPONSE_OK) {
2364                         ModestMailOperation *mail_op;
2365
2366                         /* Create mail op */
2367                         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2368                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2369                                                          mail_op);
2370
2371                         /* Transfer messages */
2372                         modest_mail_operation_xfer_msgs (mail_op,
2373                                                          headers,
2374                                                          TNY_FOLDER (folder_store),
2375                                                          TRUE);
2376                         g_object_unref (G_OBJECT (mail_op));
2377                 } else {
2378                         g_object_unref (headers);
2379                 }
2380                 g_object_unref (folder_store);
2381         }
2382         gtk_widget_destroy (dialog);
2383 }
2384
2385 void
2386 modest_ui_actions_on_move_to (GtkAction *action,
2387                               ModestWindow *win)
2388 {
2389         g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2390                           MODEST_IS_MSG_VIEW_WINDOW (win));
2391
2392         if (MODEST_IS_MAIN_WINDOW (win))
2393                 modest_ui_actions_on_main_window_move_to (action,
2394                                                           MODEST_MAIN_WINDOW (win));
2395         else
2396                 modest_ui_actions_on_msg_view_window_move_to (action,
2397                                                               MODEST_MSG_VIEW_WINDOW (win));
2398 }
2399
2400 /*
2401  * Calls #HeadersFunc for each header already selected in the main
2402  * window or the message currently being shown in the msg view window
2403  */
2404 static void
2405 do_headers_action (ModestWindow *win,
2406                    HeadersFunc func,
2407                    gpointer user_data)
2408 {
2409         TnyList *headers_list;
2410         TnyIterator *iter;
2411
2412         /* Get headers */
2413         headers_list = get_selected_headers (win);
2414         if (!headers_list)
2415                 return;
2416
2417         /* Call the function for each header */
2418         iter = tny_list_create_iterator (headers_list);
2419         while (!tny_iterator_is_done (iter)) {
2420                 TnyHeader *header;
2421
2422                 header = TNY_HEADER (tny_iterator_get_current (iter));
2423                 func (header, win, user_data);
2424                 g_object_unref (header);
2425                 tny_iterator_next (iter);
2426         }
2427         g_object_unref (iter);
2428 }
2429
2430 void
2431 modest_ui_actions_view_attachment (GtkAction *action,
2432                                    ModestWindow *window)
2433 {
2434         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2435                 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
2436         } else {
2437                 /* not supported window for this action */
2438                 g_return_if_reached ();
2439         }
2440 }
2441
2442 void
2443 modest_ui_actions_save_attachments (GtkAction *action,
2444                                     ModestWindow *window)
2445 {
2446         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2447                 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2448         } else {
2449                 /* not supported window for this action */
2450                 g_return_if_reached ();
2451         }
2452 }
2453
2454 void
2455 modest_ui_actions_remove_attachments (GtkAction *action,
2456                                       ModestWindow *window)
2457 {
2458         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2459                 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2460         } else {
2461                 /* not supported window for this action */
2462                 g_return_if_reached ();
2463         }
2464 }
2465
2466 void
2467 modest_ui_actions_on_settings (GtkAction *action,
2468                                ModestWindow *win)
2469 {
2470         GtkWidget *dialog;
2471         gint response;
2472
2473         dialog = modest_platform_get_global_settings_dialog ();
2474         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
2475         gtk_widget_show (dialog);
2476
2477         response = gtk_dialog_run (GTK_DIALOG (dialog));
2478
2479         if (response == GTK_RESPONSE_ACCEPT) {
2480                 g_message ("YES");
2481         }
2482
2483         gtk_widget_destroy (dialog);
2484 }