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-msg.h>
  38 #include <modest-tny-account.h>
  39 #include <modest-address-book.h>
  40
  41 #include "modest-ui-actions.h"
  42
  43 #include "modest-tny-platform-factory.h"
  44
  45 #include <widgets/modest-main-window.h>
  46 #include <widgets/modest-msg-view-window.h>
  47 #include <widgets/modest-account-view-window.h>
  48
  49 #include "modest-account-mgr-helpers.h"
  50 #include "modest-mail-operation.h"
  51
  52 #ifdef MODEST_HAVE_EASYSETUP
  53 #include "easysetup/modest-easysetup-wizard.h"
  54 #endif /*MODEST_HAVE_EASYSETUP*/
  55
  56 #include <modest-widget-memory.h>
  57 #include <tny-error.h>
  58 #include <tny-simple-list.h>
  59 #include <tny-msg-view.h>
  60 #include <tny-device.h>
  61
  62
  63 typedef struct _GetMsgAsyncHelper {
  64         ModestWindow *window;
  65         TnyIterator *iter;
  66         GFunc func;
  67         gpointer user_data;
  68 } GetMsgAsyncHelper;
  69
  70 typedef enum _ReplyForwardAction {
  71         ACTION_REPLY,
  72         ACTION_REPLY_TO_ALL,
  73         ACTION_FORWARD
  74 } ReplyForwardAction;
  75
  76 typedef struct _ReplyForwardHelper {
  77 guint reply_forward_type;
  78         ReplyForwardAction action;
  79         gchar *account_name;
  80 } ReplyForwardHelper;
  81
  82
  83 static void     reply_forward_func     (gpointer data, gpointer user_data);
  84 static void     read_msg_func          (gpointer data, gpointer user_data);
  85 static void     get_msg_cb             (TnyFolder *folder, TnyMsg *msg, GError **err,
  86                                         gpointer user_data);
  87 static void     reply_forward          (ReplyForwardAction action, ModestWindow *win);
  88 static gchar*   ask_for_folder_name    (GtkWindow *parent_window, const gchar *title);
  89
  90
  91 void
  92 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
  93 {
  94         GtkWidget *about;
  95         const gchar *authors[] = {
  96                 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
  97                 NULL
  98         };
  99         about = gtk_about_dialog_new ();
 100         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
 101         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
 102         gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
 103                                         _("Copyright (c) 2006, Nokia Corporation\n"
 104                                           "All rights reserved."));
 105         gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
 106                                        _("a modest e-mail client\n\n"
 107                                          "design and implementation: Dirk-Jan C. Binnema\n"
 108                                          "contributions from the fine people at KernelConcepts and Igalia\n"
 109                                          "uses the tinymail email framework written by Philip van Hoof"));
 110         gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
 111         gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
 112
 113         gtk_dialog_run (GTK_DIALOG (about));
 114         gtk_widget_destroy(about);
 115 }
 116
 117
 118 static TnyList *
 119 get_selected_headers (ModestWindow *win)
 120 {
 121         if (MODEST_IS_MAIN_WINDOW(win)) {
 122                 GtkWidget *header_view;
 123
 124                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 125                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 126                 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 127
 128         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 129                 /* for MsgViewWindows, we simply return a list with one element */
 130                 TnyMsg *msg;
 131                 TnyHeader *header;
 132                 TnyList *list = NULL;
 133
 134                 msg  = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
 135                 if (msg) {
 136                         header = tny_msg_get_header (msg);
 137                         list = tny_simple_list_new ();
 138                         tny_list_prepend (list, G_OBJECT(header));
 139                         g_object_unref (G_OBJECT(header));
 140                 }
 141                 return list;
 142
 143         } else
 144                 return NULL;
 145 }
 146
 147 void
 148 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
 149 {
 150         TnyList *header_list;
 151         TnyIterator *iter;
 152
 153         g_return_if_fail (MODEST_IS_WINDOW(win));
 154
 155         header_list = get_selected_headers (win);
 156
 157         if (header_list) {
 158                 iter = tny_list_create_iterator (header_list);
 159                 do {
 160                         TnyHeader *header;
 161                         ModestMailOperation *mail_op;
 162
 163                         header = TNY_HEADER (tny_iterator_get_current (iter));
 164                         /* TODO: thick grain mail operation involving
 165                            a list of objects. Composite pattern ??? */
 166                         /* TODO: add confirmation dialog */
 167                         mail_op = modest_mail_operation_new ();
 168                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 169                                                          mail_op);
 170
 171                         /* Always delete. TODO: Move to trash still not supported */
 172                         modest_mail_operation_remove_msg (mail_op, header, FALSE);
 173
 174                         /* Frees */
 175                         g_object_unref (G_OBJECT (mail_op));
 176                         g_object_unref (G_OBJECT (header));
 177
 178                         tny_iterator_next (iter);
 179
 180                 } while (!tny_iterator_is_done (iter));
 181
 182                 /* Free iter */
 183                 g_object_unref (G_OBJECT (iter));
 184         }
 185 }
 186
 187
 188 void
 189 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
 190 {
 191         /* FIXME: save size of main window */
 192 /*      save_sizes (main_window); */
 193         gtk_widget_destroy (GTK_WIDGET (win));
 194 }
 195
 196 void
 197 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
 198 {
 199         GtkClipboard *clipboard = NULL;
 200         gchar *selection = NULL;
 201
 202         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 203         selection = gtk_clipboard_wait_for_text (clipboard);
 204
 205         modest_address_book_add_address (selection);
 206         g_free (selection);
 207 }
 208
 209 void
 210 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
 211 {
 212         GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr());
 213
 214         gboolean accounts_exist = account_names != NULL;
 215         g_slist_free (account_names);
 216
 217         /* This is currently only implemented for Maemo,
 218          * because it requires a providers preset file which is not publically available.
 219          */
 220 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
 221         /* To test, while modest_account_mgr_account_names() is broken: accounts_exist = TRUE; */
 222         if (!accounts_exist) {
 223                 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
 224                 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
 225                 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
 226                 gtk_dialog_run (GTK_DIALOG (wizard));
 227                 gtk_widget_destroy (GTK_WIDGET (wizard));
 228         }
 229         else
 230         {
 231                 /* Show the list of accounts: */
 232                 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
 233                 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
 234                 gtk_dialog_run (account_win);
 235                 gtk_widget_destroy (GTK_WIDGET(account_win));
 236         }
 237 #else
 238    GtkWidget *dialog, *label;
 239
 240    /* Create the widgets */
 241
 242    dialog = gtk_dialog_new_with_buttons ("Message",
 243                                          GTK_WINDOW(win),
 244                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 245                                          GTK_STOCK_OK,
 246                                          GTK_RESPONSE_NONE,
 247                                          NULL);
 248    label = gtk_label_new ("Hello World!");
 249
 250    /* Ensure that the dialog box is destroyed when the user responds. */
 251
 252    g_signal_connect_swapped (dialog, "response",
 253                              G_CALLBACK (gtk_widget_destroy),
 254                              dialog);
 255
 256    /* Add the label, and show everything we've added to the dialog. */
 257
 258    gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
 259                       label);
 260    gtk_widget_show_all (dialog);
 261 #endif /* MODEST_PLATFORM_MAEMO */
 262 }
 263
 264 void
 265 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
 266 {
 267         ModestWindow *msg_win;
 268         TnyMsg *msg = NULL;
 269         TnyFolder *folder = NULL;
 270         gchar *account_name = NULL;
 271         gchar *from_str = NULL;
 272         GError *err = NULL;
 273         TnyAccount *account;
 274
 275         account_name = g_strdup(modest_window_get_active_account (win));
 276         if (!account_name)
 277                 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 278
 279         account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
 280                                                                        account_name,
 281                                                                        TNY_ACCOUNT_TYPE_STORE);
 282         if (!account) {
 283                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
 284                 goto cleanup;
 285         }
 286
 287         from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
 288
 289         msg    = modest_tny_msg_new ("", from_str, "", "", "", "", NULL);
 290         if (!msg) {
 291                 g_printerr ("modest: failed to create new msg\n");
 292                 goto cleanup;
 293         }
 294
 295         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 296         if (!folder) {
 297                 g_printerr ("modest: failed to find Drafts folder\n");
 298                 goto cleanup;
 299         }
 300
 301         tny_folder_add_msg (folder, msg, &err);
 302         if (err) {
 303                 g_printerr ("modest: error adding msg to Drafts folder: %s",
 304                             err->message);
 305                 g_error_free (err);
 306                 goto cleanup;
 307         }
 308
 309         msg_win = modest_msg_edit_window_new (msg, account_name);
 310         if (win)
 311                 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
 312                                               GTK_WINDOW (win));
 313         gtk_widget_show_all (GTK_WIDGET (msg_win));
 314
 315 cleanup:
 316         g_free (account_name);
 317         g_free (from_str);
 318         if (account)
 319                 g_object_unref (G_OBJECT(account));
 320         if (msg)
 321                 g_object_unref (G_OBJECT(msg));
 322         if (folder)
 323                 g_object_unref (G_OBJECT(folder));
 324 }
 325
 326
 327 void
 328 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
 329 {
 330         modest_runtime_not_implemented (GTK_WINDOW(win)); /* FIXME */
 331 }
 332
 333
 334
 335 static void
 336 reply_forward_func (gpointer data, gpointer user_data)
 337 {
 338         TnyMsg *msg, *new_msg;
 339         GetMsgAsyncHelper *helper;
 340         ReplyForwardHelper *rf_helper;
 341         ModestWindow *msg_win;
 342         ModestEditType edit_type;
 343         gchar *from;
 344         GError *err = NULL;
 345         TnyFolder *folder = NULL;
 346         TnyAccount *account = NULL;
 347
 348         msg = TNY_MSG (data);
 349         helper = (GetMsgAsyncHelper *) user_data;
 350         rf_helper = (ReplyForwardHelper *) helper->user_data;
 351
 352         from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
 353                                                    rf_helper->account_name);
 354         /* Create reply mail */
 355         switch (rf_helper->action) {
 356         case ACTION_REPLY:
 357                 new_msg =
 358                         modest_tny_msg_create_reply_msg (msg,  from,
 359                                                          rf_helper->reply_forward_type,
 360                                                          MODEST_TNY_MSG_REPLY_MODE_SENDER);
 361                 break;
 362         case ACTION_REPLY_TO_ALL:
 363                 new_msg =
 364                         modest_tny_msg_create_reply_msg (msg, from, rf_helper->reply_forward_type,
 365                                                          MODEST_TNY_MSG_REPLY_MODE_ALL);
 366                 edit_type = MODEST_EDIT_TYPE_REPLY;
 367                 break;
 368         case ACTION_FORWARD:
 369                 new_msg =
 370                         modest_tny_msg_create_forward_msg (msg, from, rf_helper->reply_forward_type);
 371                 edit_type = MODEST_EDIT_TYPE_FORWARD;
 372                 break;
 373         default:
 374                 g_return_if_reached ();
 375                 return;
 376         }
 377
 378         if (!new_msg) {
 379                 g_printerr ("modest: failed to create message\n");
 380                 goto cleanup;
 381         }
 382
 383         account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
 384                                                                        rf_helper->account_name,
 385                                                                        TNY_ACCOUNT_TYPE_STORE);
 386         if (!account) {
 387                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
 388                 goto cleanup;
 389         }
 390
 391         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
 392         if (!folder) {
 393                 g_printerr ("modest: failed to find Drafts folder\n");
 394                 goto cleanup;
 395         }
 396
 397         tny_folder_add_msg (folder, msg, &err);
 398         if (err) {
 399                 g_printerr ("modest: error adding msg to Drafts folder: %s",
 400                             err->message);
 401                 g_error_free (err);
 402                 goto cleanup;
 403         }
 404
 405         /* Show edit window */
 406         msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
 407         gtk_widget_show_all (GTK_WIDGET (msg_win));
 408
 409 cleanup:
 410         if (new_msg)
 411                 g_object_unref (G_OBJECT (new_msg));
 412         if (folder)
 413                 g_object_unref (G_OBJECT (folder));
 414         if (account)
 415                 g_object_unref (G_OBJECT (account));
 416
 417         g_free (rf_helper->account_name);
 418         g_slice_free (ReplyForwardHelper, rf_helper);
 419 }
 420 /*
 421  * Common code for the reply and forward actions
 422  */
 423 static void
 424 reply_forward (ReplyForwardAction action, ModestWindow *win)
 425 {
 426         TnyList *header_list;
 427         guint reply_forward_type;
 428         TnyHeader *header;
 429         TnyFolder *folder;
 430         GetMsgAsyncHelper *helper;
 431         ReplyForwardHelper *rf_helper;
 432
 433         g_return_if_fail (MODEST_IS_WINDOW(win));
 434
 435         header_list = get_selected_headers (win);
 436         if (!header_list)
 437                 return;
 438
 439         reply_forward_type = modest_conf_get_int (modest_runtime_get_conf (),
 440                                                   (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
 441                                                   NULL);
 442         /* We assume that we can only select messages of the
 443            same folder and that we reply all of them from the
 444            same account. In fact the interface currently only
 445            allows single selection */
 446
 447         /* Fill helpers */
 448         rf_helper = g_slice_new0 (ReplyForwardHelper);
 449         rf_helper->reply_forward_type = reply_forward_type;
 450         rf_helper->action = action;
 451
 452         rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
 453         if (!rf_helper->account_name)
 454                 rf_helper->account_name =
 455                         modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 456
 457         helper = g_slice_new0 (GetMsgAsyncHelper);
 458         helper->window = win;
 459         helper->func = reply_forward_func;
 460         helper->iter = tny_list_create_iterator (header_list);
 461         helper->user_data = rf_helper;
 462
 463         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 464                 TnyMsg *msg;
 465                 msg = modest_msg_view_window_get_message(MODEST_MSG_VIEW_WINDOW(win));
 466                 if (!msg) {
 467                         g_printerr ("modest: no message found\n");
 468                         return;
 469                 } else
 470                         reply_forward_func (msg, helper);
 471         } else {
 472                 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
 473                 folder = tny_header_get_folder (header);
 474                 if (folder) {
 475                         /* The callback will call it per each header */
 476                         tny_folder_get_msg_async (folder, header, get_msg_cb, helper);
 477                         g_object_unref (G_OBJECT (folder));
 478                 } else
 479                         g_printerr ("modest: no folder for header\n");
 480
 481                 /* Clean */
 482                 g_object_unref (G_OBJECT (header));
 483         }
 484 }
 485
 486
 487 void
 488 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
 489 {
 490         g_return_if_fail (MODEST_IS_WINDOW(win));
 491
 492         reply_forward (ACTION_REPLY, win);
 493 }
 494
 495 void
 496 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
 497 {
 498         g_return_if_fail (MODEST_IS_WINDOW(win));
 499
 500         reply_forward (ACTION_FORWARD, win);
 501 }
 502
 503 void
 504 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
 505 {
 506         g_return_if_fail (MODEST_IS_WINDOW(win));
 507
 508         reply_forward (ACTION_REPLY_TO_ALL, win);
 509 }
 510
 511 void
 512 modest_ui_actions_on_next (GtkAction *action,
 513                            ModestMainWindow *main_window)
 514 {
 515         GtkWidget *header_view;
 516         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 517
 518         header_view = modest_main_window_get_child_widget (main_window,
 519                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 520         if (!header_view)
 521                 return;
 522
 523         modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
 524 }
 525
 526 void
 527 modest_ui_actions_on_prev (GtkAction *action,
 528                            ModestMainWindow *main_window)
 529 {
 530         GtkWidget *header_view;
 531         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 532
 533         header_view = modest_main_window_get_child_widget (main_window,
 534                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 535         if (!header_view)
 536                 return;
 537
 538         modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
 539 }
 540
 541
 542 void
 543 modest_ui_actions_on_send_receive (GtkAction *action,  ModestWindow *win)
 544 {
 545         gchar *account_name;
 546         TnyAccount *tny_account;
 547         ModestTnySendQueue *send_queue;
 548         ModestMailOperation *mail_op;
 549
 550         account_name =
 551                 g_strdup(modest_window_get_active_account(MODEST_WINDOW(win)));
 552         if (!account_name)
 553                 account_name  = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 554         if (!account_name) {
 555                 g_printerr ("modest: cannot get account\n");
 556                 return;
 557         }
 558
 559         tny_account =
 560                 modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
 561                                                                      account_name,
 562                                                                      TNY_ACCOUNT_TYPE_TRANSPORT);
 563         if (!tny_account) {
 564                 g_printerr ("modest: cannot get tny transport account for %s\n", account_name);
 565                 return;
 566         }
 567         send_queue = modest_tny_send_queue_new (TNY_CAMEL_TRANSPORT_ACCOUNT(tny_account));
 568         if (!send_queue) {
 569                 g_object_unref (G_OBJECT(tny_account));
 570                 g_printerr ("modest: cannot get send queue for %s\n", account_name);
 571                 return;
 572         }
 573         //modest_tny_send_queue_flush (send_queue);
 574
 575         g_object_unref (G_OBJECT(send_queue));
 576         g_object_unref (G_OBJECT(tny_account));
 577
 578         tny_account =
 579                 modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
 580                                                                      account_name,
 581                                                                      TNY_ACCOUNT_TYPE_STORE);
 582         if (!tny_account) {
 583                 g_printerr ("modest: cannot get tny store account for %s\n", account_name);
 584                 return;
 585         }
 586
 587         /* Create the mail operation */
 588         mail_op = modest_mail_operation_new ();
 589         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
 590         modest_mail_operation_update_account (mail_op, TNY_STORE_ACCOUNT(tny_account));
 591
 592         /* Frees */
 593         g_object_unref (G_OBJECT (tny_account));
 594         g_object_unref (G_OBJECT (mail_op));
 595 }
 596
 597
 598
 599 void
 600 modest_ui_actions_toggle_view (GtkAction *action, ModestMainWindow *main_window)
 601 {
 602         ModestConf *conf;
 603         GtkWidget *header_view;
 604
 605         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 606
 607         header_view = modest_main_window_get_child_widget (main_window,
 608                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 609         if (!header_view)
 610                 return;
 611
 612         conf = modest_runtime_get_conf ();
 613
 614         /* what is saved/restored is depending on the style; thus; we save with
 615          * old style, then update the style, and restore for this new style
 616          */
 617         modest_widget_memory_save (conf, G_OBJECT(header_view), "header-view");
 618
 619         if (modest_header_view_get_style
 620             (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
 621                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
 622                                               MODEST_HEADER_VIEW_STYLE_TWOLINES);
 623         else
 624                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
 625                                               MODEST_HEADER_VIEW_STYLE_DETAILS);
 626
 627         modest_widget_memory_restore (conf, G_OBJECT(header_view),
 628                                       "header-view");
 629 }
 630
 631
 632
 633 /*
 634  * Marks a message as read and passes it to the msg preview widget
 635  */
 636 static void
 637 read_msg_func (gpointer data, gpointer user_data)
 638 {
 639         TnyMsg *msg;
 640         TnyHeader *header;
 641         GetMsgAsyncHelper *helper;
 642         TnyHeaderFlags header_flags;
 643         GtkWidget *msg_preview;
 644
 645         msg = TNY_MSG (data);
 646         helper = (GetMsgAsyncHelper *) user_data;
 647
 648         msg_preview = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (helper->window),
 649                                                            MODEST_WIDGET_TYPE_MSG_PREVIEW);
 650         if (!msg_preview)
 651                 return;
 652
 653         header = TNY_HEADER (tny_iterator_get_current (helper->iter));
 654         header_flags = tny_header_get_flags (header);
 655         tny_header_set_flags (header, header_flags | TNY_HEADER_FLAG_SEEN);
 656         g_object_unref (G_OBJECT (header));
 657
 658         /* Set message on msg view */
 659         modest_msg_view_set_message (MODEST_MSG_VIEW(msg_preview), msg);
 660 }
 661
 662 /*
 663  * This function is a generic handler for the tny_folder_get_msg_async
 664  * call. It expects as user_data a #GetMsgAsyncHelper. This helper
 665  * contains a user provided function that is called inside this
 666  * method. This will allow us to use this callback in many different
 667  * places. This callback performs the common actions for the
 668  * get_msg_async call, more specific actions will be done by the user
 669  * function
 670  */
 671 static void
 672 get_msg_cb (TnyFolder *folder, TnyMsg *msg, GError **err, gpointer user_data)
 673 {
 674         GetMsgAsyncHelper *helper;
 675
 676         helper = (GetMsgAsyncHelper *) user_data;
 677
 678         if ((*err && ((*err)->code == TNY_FOLDER_ERROR_GET_MSG)) || !msg) {
 679                 modest_ui_actions_on_item_not_found (NULL,
 680                                                      MODEST_ITEM_TYPE_MESSAGE,
 681                                                      helper->window);
 682                 return;
 683         }
 684
 685         /* Call user function */
 686         helper->func (msg, user_data);
 687
 688         /* Process next element (if exists) */
 689         tny_iterator_next (helper->iter);
 690         if (tny_iterator_is_done (helper->iter)) {
 691                 TnyList *headers;
 692                 headers = tny_iterator_get_list (helper->iter);
 693                 /* Free resources */
 694                 g_object_unref (G_OBJECT (headers));
 695                 g_object_unref (G_OBJECT (helper->iter));
 696                 g_slice_free (GetMsgAsyncHelper, helper);
 697         } else {
 698                 TnyHeader *header;
 699                 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
 700                 tny_folder_get_msg_async (folder, header,
 701                                           get_msg_cb, helper);
 702                 g_object_unref (G_OBJECT(header));
 703         }
 704 }
 705
 706 void
 707 modest_ui_actions_on_header_selected (ModestHeaderView *folder_view,
 708                                       TnyHeader *header,
 709                                       ModestMainWindow *main_window)
 710 {
 711         GtkWidget *msg_preview;
 712         TnyFolder *folder;
 713         GetMsgAsyncHelper *helper;
 714         TnyList *list;
 715
 716         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 717
 718         msg_preview = modest_main_window_get_child_widget(main_window,
 719                                                           MODEST_WIDGET_TYPE_MSG_PREVIEW);
 720         if (!msg_preview)
 721                 return;
 722
 723         /* when there's no header, clear the msgview */
 724         if (!header) {
 725                 modest_msg_view_set_message (MODEST_MSG_VIEW(msg_preview), NULL);
 726                 return;
 727         }
 728
 729         folder = tny_header_get_folder (TNY_HEADER(header));
 730
 731         /* Create list */
 732         list = tny_simple_list_new ();
 733         tny_list_prepend (list, G_OBJECT (header));
 734
 735         /* Fill helper data */
 736         helper = g_slice_new0 (GetMsgAsyncHelper);
 737         helper->window = MODEST_WINDOW (main_window);
 738         helper->iter = tny_list_create_iterator (list);
 739         helper->func = read_msg_func;
 740
 741         tny_folder_get_msg_async (TNY_FOLDER(folder),
 742                                   header, get_msg_cb,
 743                                   helper);
 744
 745         /* Frees */
 746         g_object_unref (G_OBJECT (folder));
 747 }
 748
 749
 750
 751 void
 752 modest_ui_actions_on_header_activated (ModestHeaderView *folder_view, TnyHeader *header,
 753                                        ModestMainWindow *main_window)
 754 {
 755         ModestWindow *win;
 756         TnyFolder *folder = NULL;
 757         TnyMsg    *msg    = NULL;
 758         gchar *account    = NULL;
 759
 760         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 761
 762         if (!header)
 763                 return;
 764
 765         folder = tny_header_get_folder (header);
 766         if (!folder) {
 767                 g_printerr ("modest: cannot get folder for header\n");
 768                 goto cleanup;
 769         }
 770
 771         /* FIXME: make async?; check error  */
 772         msg = tny_folder_get_msg (folder, header, NULL);
 773         if (!msg) {
 774                 g_printerr ("modest: cannot get msg for header\n");
 775                 goto cleanup;
 776         }
 777
 778         account =  g_strdup(modest_window_get_active_account(MODEST_WINDOW(main_window)));
 779         if (!account)
 780                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
 781
 782         win = modest_msg_view_window_new (msg, account);
 783         gtk_window_set_transient_for (GTK_WINDOW (win),
 784                                       GTK_WINDOW (main_window));
 785
 786         gtk_widget_show_all (GTK_WIDGET(win));
 787
 788 cleanup:
 789         g_free (account);
 790
 791         if (folder)
 792                 g_object_unref (G_OBJECT (folder));
 793         if (msg)
 794                 g_object_unref (G_OBJECT (msg));
 795 }
 796
 797 void
 798 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
 799                                                TnyFolder *folder,
 800                                                gboolean selected,
 801                                                ModestMainWindow *main_window)
 802 {
 803         gchar *txt;
 804         ModestConf *conf;
 805         GtkWidget *header_view;
 806
 807         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
 808
 809         header_view = modest_main_window_get_child_widget(main_window,
 810                                                           MODEST_WIDGET_TYPE_HEADER_VIEW);
 811         if (!header_view)
 812                 return;
 813
 814         conf = modest_runtime_get_conf ();
 815
 816         if (!selected) { /* the folder was unselected; save it's settings  */
 817                 modest_widget_memory_save (conf, G_OBJECT (header_view), "header-view");
 818                 gtk_window_set_title (GTK_WINDOW(main_window), "Modest");
 819                 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
 820         } else {  /* the folder was selected */
 821                 if (folder) { /* folder may be NULL */
 822                         guint num, unread;
 823                         gchar *title;
 824
 825                         num    = tny_folder_get_all_count    (folder);
 826                         unread = tny_folder_get_unread_count (folder);
 827
 828                         title = g_strdup_printf ("Modest: %s",
 829                                                  tny_folder_get_name (folder));
 830
 831                         gtk_window_set_title (GTK_WINDOW(main_window), title);
 832                         g_free (title);
 833
 834                         txt = g_strdup_printf (_("%d %s, %d unread"),
 835                                                num, num==1 ? _("item") : _("items"), unread);
 836                         //gtk_label_set_label (GTK_LABEL(folder_info_label), txt);
 837                         g_free (txt);
 838                 }
 839                 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), folder);
 840                 modest_widget_memory_restore (conf, G_OBJECT(header_view),
 841                                               "header-view");
 842         }
 843 }
 844
 845 void
 846 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
 847                                      ModestWindow *win)
 848 {
 849         GtkWidget *dialog;
 850         gchar *txt, *item;
 851         gboolean online;
 852
 853         item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
 854
 855         if (g_main_depth > 0)
 856                 gdk_threads_enter ();
 857         online = tny_device_is_online (modest_runtime_get_device());
 858
 859         if (online) {
 860                 /* already online -- the item is simply not there... */
 861                 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
 862                                                  GTK_DIALOG_MODAL,
 863                                                  GTK_MESSAGE_WARNING,
 864                                                  GTK_BUTTONS_OK,
 865                                                  _("The %s you selected cannot be found"),
 866                                                  item);
 867                 gtk_dialog_run (GTK_DIALOG(dialog));
 868         } else {
 869                 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
 870                                                       GTK_WINDOW (win),
 871                                                       GTK_DIALOG_MODAL,
 872                                                       GTK_STOCK_CANCEL,
 873                                                       GTK_RESPONSE_REJECT,
 874                                                       GTK_STOCK_OK,
 875                                                       GTK_RESPONSE_ACCEPT,
 876                                                       NULL);
 877                 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
 878                                          "Do you want to get online?"), item);
 879                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
 880                                     gtk_label_new (txt), FALSE, FALSE, 0);
 881                 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
 882                 g_free (txt);
 883
 884                 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
 885                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 886 //                      tny_device_force_online (modest_runtime_get_device());
 887                 }
 888         }
 889         gtk_widget_destroy (dialog);
 890         if (g_main_depth > 0)
 891                 gdk_threads_leave ();
 892 }
 893
 894 void
 895 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
 896                                      ModestWindow *win)
 897 {
 898         g_message (__FUNCTION__);
 899 }
 900
 901
 902 void
 903 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
 904                                         ModestWindow *win)
 905 {
 906         g_message (__FUNCTION__);
 907 }
 908
 909 void
 910 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
 911                                              ModestWindow *win)
 912 {
 913         g_message (__FUNCTION__);
 914
 915 }
 916
 917 void
 918 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
 919                                           const gchar *address,
 920                                           ModestWindow *win)
 921 {
 922         g_message ("%s %s", __FUNCTION__, address);
 923 }
 924
 925 void
 926 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
 927 {
 928         TnyTransportAccount *transport_account;
 929         ModestMailOperation *mail_operation;
 930         MsgData *data;
 931         gchar *account_name, *from;
 932         ModestAccountMgr *account_mgr;
 933
 934         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
 935
 936         data = modest_msg_edit_window_get_msg_data (edit_window);
 937
 938         /* FIXME: Code added just for testing. The final version will
 939            use the send queue provided by tinymail and some
 940            classifier */
 941         account_mgr = modest_runtime_get_account_mgr();
 942         account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
 943         if (!account_name)
 944                 account_name = modest_account_mgr_get_default_account (account_mgr);
 945         if (!account_name) {
 946                 g_printerr ("modest: no account found\n");
 947                 modest_msg_edit_window_free_msg_data (edit_window, data);
 948                 return;
 949         }
 950         transport_account =
 951                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
 952                                       (modest_runtime_get_account_store(),
 953                                        account_name,
 954                                        TNY_ACCOUNT_TYPE_TRANSPORT));
 955         if (!transport_account) {
 956                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
 957                 g_free (account_name);
 958                 modest_msg_edit_window_free_msg_data (edit_window, data);
 959                 return;
 960         }
 961         from = modest_account_mgr_get_from_string (account_mgr, account_name);
 962
 963         /* Create the mail operation */
 964         mail_operation = modest_mail_operation_new ();
 965         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
 966
 967         modest_mail_operation_send_new_mail (mail_operation,
 968                                              transport_account,
 969                                              from,
 970                                              data->to,
 971                                              data->cc,
 972                                              data->bcc,
 973                                              data->subject,
 974                                              data->plain_body,
 975                                              data->html_body,
 976                                              data->attachments);
 977         /* Frees */
 978         g_free (from);
 979         g_free (account_name);
 980         g_object_unref (G_OBJECT (transport_account));
 981         g_object_unref (G_OBJECT (mail_operation));
 982
 983         modest_msg_edit_window_free_msg_data (edit_window, data);
 984
 985         /* Save settings and close the window */
 986         gtk_widget_destroy (GTK_WIDGET (edit_window));
 987 }
 988
 989 void
 990 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
 991                                   ModestMsgEditWindow *window)
 992 {
 993         ModestMsgEditFormatState *format_state = NULL;
 994
 995         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 996         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
 997
 998         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
 999                 return;
1000
1001         format_state = modest_msg_edit_window_get_format_state (window);
1002         g_return_if_fail (format_state != NULL);
1003
1004         format_state->bold = gtk_toggle_action_get_active (action);
1005         modest_msg_edit_window_set_format_state (window, format_state);
1006         g_free (format_state);
1007
1008 }
1009
1010 void
1011 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1012                                      ModestMsgEditWindow *window)
1013 {
1014         ModestMsgEditFormatState *format_state = NULL;
1015
1016         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1017         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1018
1019         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1020                 return;
1021
1022         format_state = modest_msg_edit_window_get_format_state (window);
1023         g_return_if_fail (format_state != NULL);
1024
1025         format_state->italics = gtk_toggle_action_get_active (action);
1026         modest_msg_edit_window_set_format_state (window, format_state);
1027         g_free (format_state);
1028
1029 }
1030
1031 void
1032 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1033                                      ModestMsgEditWindow *window)
1034 {
1035         ModestMsgEditFormatState *format_state = NULL;
1036
1037         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1038         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1039
1040         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1041                 return;
1042
1043         format_state = modest_msg_edit_window_get_format_state (window);
1044         g_return_if_fail (format_state != NULL);
1045
1046         format_state->bullet = gtk_toggle_action_get_active (action);
1047         modest_msg_edit_window_set_format_state (window, format_state);
1048         g_free (format_state);
1049
1050 }
1051
1052 void
1053 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1054                                      GtkRadioAction *selected,
1055                                      ModestMsgEditWindow *window)
1056 {
1057         ModestMsgEditFormatState *format_state = NULL;
1058         GtkJustification value;
1059
1060         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1061
1062         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1063                 return;
1064
1065         value = gtk_radio_action_get_current_value (selected);
1066
1067         format_state = modest_msg_edit_window_get_format_state (window);
1068         g_return_if_fail (format_state != NULL);
1069
1070         format_state->justification = value;
1071         modest_msg_edit_window_set_format_state (window, format_state);
1072         g_free (format_state);
1073 }
1074
1075 void
1076 modest_ui_actions_on_select_editor_color (GtkAction *action,
1077                                           ModestMsgEditWindow *window)
1078 {
1079         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1080         g_return_if_fail (GTK_IS_ACTION (action));
1081
1082         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1083                 return;
1084
1085         modest_msg_edit_window_select_color (window);
1086 }
1087
1088 void
1089 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1090                                                      ModestMsgEditWindow *window)
1091 {
1092         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1093         g_return_if_fail (GTK_IS_ACTION (action));
1094
1095         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1096                 return;
1097
1098         modest_msg_edit_window_select_background_color (window);
1099 }
1100
1101 void
1102 modest_ui_actions_on_insert_image (GtkAction *action,
1103                                    ModestMsgEditWindow *window)
1104 {
1105         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1106         g_return_if_fail (GTK_IS_ACTION (action));
1107
1108         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1109                 return;
1110
1111         modest_msg_edit_window_insert_image (window);
1112 }
1113
1114 /*
1115  * Shows a dialog with an entry that asks for some text. The returned
1116  * value must be freed by the caller. The dialog window title will be
1117  * set to @title.
1118  */
1119 static gchar *
1120 ask_for_folder_name (GtkWindow *parent_window,
1121                      const gchar *title)
1122 {
1123         GtkWidget *dialog, *entry;
1124         gchar *folder_name = NULL;
1125
1126         /* Ask for folder name */
1127         dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1128                                               parent_window,
1129                                               GTK_DIALOG_MODAL,
1130                                               GTK_STOCK_CANCEL,
1131                                               GTK_RESPONSE_REJECT,
1132                                               GTK_STOCK_OK,
1133                                               GTK_RESPONSE_ACCEPT,
1134                                               NULL);
1135         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1136                             gtk_label_new(title),
1137                             FALSE, FALSE, 0);
1138
1139         entry = gtk_entry_new_with_max_length (40);
1140         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1141                             entry,
1142                             TRUE, FALSE, 0);
1143
1144         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1145
1146         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1147                 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1148
1149         gtk_widget_destroy (dialog);
1150
1151         return folder_name;
1152 }
1153
1154 void
1155 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1156 {
1157         TnyFolder *parent_folder;
1158         GtkWidget *folder_view;
1159
1160         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1161
1162         folder_view = modest_main_window_get_child_widget (main_window,
1163                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1164         if (!folder_view)
1165                 return;
1166
1167         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1168
1169         if (parent_folder) {
1170                 gchar *folder_name;
1171
1172                 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1173                                                    _("Please enter a name for the new folder"));
1174
1175                 if (folder_name != NULL && strlen (folder_name) > 0) {
1176                         TnyFolder *new_folder;
1177                         ModestMailOperation *mail_op;
1178
1179                         mail_op = modest_mail_operation_new ();
1180                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1181                                                          mail_op);
1182
1183                         new_folder = modest_mail_operation_create_folder (mail_op,
1184                                                                           TNY_FOLDER_STORE (parent_folder),
1185                                                                           (const gchar *) folder_name);
1186                         if (new_folder)
1187                                 g_object_unref (new_folder);
1188                         g_object_unref (mail_op);
1189                         g_free (folder_name);
1190                 }
1191                 g_object_unref (parent_folder);
1192         }
1193 }
1194
1195 void
1196 modest_ui_actions_on_rename_folder (GtkAction *action,
1197                                      ModestMainWindow *main_window)
1198 {
1199         TnyFolder *folder;
1200         GtkWidget *folder_view;
1201
1202         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1203
1204         folder_view = modest_main_window_get_child_widget (main_window,
1205                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1206         if (!folder_view)
1207                 return;
1208
1209         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1210
1211         if (folder) {
1212                 gchar *folder_name;
1213                 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1214                                                    _("Please enter a new name for the folder"));
1215
1216                 if (folder_name != NULL && strlen (folder_name) > 0) {
1217                         ModestMailOperation *mail_op;
1218
1219                         mail_op = modest_mail_operation_new ();
1220                         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1221                                                          mail_op);
1222
1223                         modest_mail_operation_rename_folder (mail_op,
1224                                                              folder,
1225                                                              (const gchar *) folder_name);
1226
1227                         g_object_unref (mail_op);
1228                         g_free (folder_name);
1229                 }
1230                 g_object_unref (folder);
1231         }
1232 }
1233
1234 static void
1235 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1236 {
1237         TnyFolder *folder;
1238         ModestMailOperation *mail_op;
1239         GtkWidget *folder_view;
1240
1241         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1242
1243         folder_view = modest_main_window_get_child_widget (main_window,
1244                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1245         if (!folder_view)
1246                 return;
1247
1248         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1249
1250         mail_op = modest_mail_operation_new ();
1251         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1252                                          mail_op);
1253         modest_mail_operation_remove_folder (mail_op, folder, move_to_trash);
1254
1255         g_object_unref (G_OBJECT (mail_op));
1256         g_object_unref (G_OBJECT (folder));
1257 }
1258
1259 void
1260 modest_ui_actions_on_delete_folder (GtkAction *action,
1261                                      ModestMainWindow *main_window)
1262 {
1263         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1264
1265         delete_folder (main_window, FALSE);
1266 }
1267
1268 void
1269 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1270 {
1271         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1272
1273         delete_folder (main_window, TRUE);
1274 }
1275
1276 void
1277 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1278                                          const gchar* account_name,
1279                                          gchar **password,
1280                                          gboolean *cancel,
1281                                          gboolean *remember,
1282                                          ModestMainWindow *main_window)
1283 {
1284         gchar *txt;
1285         GtkWidget *dialog, *entry, *remember_pass_check;
1286
1287         dialog = gtk_dialog_new_with_buttons (_("Password requested"),
1288                                               NULL,
1289                                               GTK_DIALOG_MODAL,
1290                                               GTK_STOCK_CANCEL,
1291                                               GTK_RESPONSE_REJECT,
1292                                               GTK_STOCK_OK,
1293                                               GTK_RESPONSE_ACCEPT,
1294                                               NULL);
1295         gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1296
1297         txt = g_strdup_printf (_("Please enter your password for %s"), account_name);
1298         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1299                             FALSE, FALSE, 0);
1300         g_free (txt);
1301
1302         entry = gtk_entry_new_with_max_length (40);
1303         gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
1304         gtk_entry_set_invisible_char (GTK_ENTRY(entry), 0x2022); /* bullet unichar */
1305
1306         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry,
1307                             TRUE, FALSE, 0);
1308
1309         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1310         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1311                             TRUE, FALSE, 0);
1312
1313         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1314
1315         if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1316                 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry)));
1317                 *cancel   = FALSE;
1318         } else {
1319                 *password = NULL;
1320                 *cancel   = TRUE;
1321         }
1322
1323         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1324                 *remember = TRUE;
1325         else
1326                 *remember = FALSE;
1327
1328         gtk_widget_destroy (dialog);
1329 }
1330
1331 void
1332 modest_ui_actions_on_cut (GtkAction *action,
1333                           ModestWindow *window)
1334 {
1335         GtkWidget *focused_widget;
1336
1337         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1338         if (GTK_IS_EDITABLE (focused_widget)) {
1339                 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1340         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1341                 GtkTextBuffer *buffer;
1342                 GtkClipboard *clipboard;
1343
1344                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1345                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1346                 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1347         }
1348 }
1349
1350 void
1351 modest_ui_actions_on_copy (GtkAction *action,
1352                            ModestWindow *window)
1353 {
1354         GtkClipboard *clipboard;
1355         GtkWidget *focused_widget;
1356
1357         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1358         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1359         if (GTK_IS_LABEL (focused_widget)) {
1360                 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1361         } else if (GTK_IS_EDITABLE (focused_widget)) {
1362                 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1363         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1364                 GtkTextBuffer *buffer;
1365
1366                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1367                 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1368         }
1369 }
1370
1371 void
1372 modest_ui_actions_on_paste (GtkAction *action,
1373                             ModestWindow *window)
1374 {
1375         GtkWidget *focused_widget;
1376
1377         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1378         if (GTK_IS_EDITABLE (focused_widget)) {
1379                 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1380         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1381                 GtkTextBuffer *buffer;
1382                 GtkClipboard *clipboard;
1383
1384                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1385                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1386                 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1387         }
1388 }
1389
1390 void
1391 modest_ui_actions_on_select_all (GtkAction *action,
1392                                  ModestWindow *window)
1393 {
1394         GtkWidget *focused_widget;
1395
1396         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1397         if (GTK_IS_LABEL (focused_widget)) {
1398                 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1399         } else if (GTK_IS_EDITABLE (focused_widget)) {
1400                 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1401         } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1402                 GtkTextBuffer *buffer;
1403                 GtkTextIter start, end;
1404
1405                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1406                 gtk_text_buffer_get_start_iter (buffer, &start);
1407                 gtk_text_buffer_get_end_iter (buffer, &end);
1408                 gtk_text_buffer_select_range (buffer, &start, &end);
1409         }
1410 }