1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
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.
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.
32 #endif /*HAVE_CONFIG_H*/
34 #include <glib/gi18n.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>
42 #include "modest-ui-actions.h"
44 #include "modest-tny-platform-factory.h"
45 #include "modest-platform.h"
47 #include <widgets/modest-main-window.h>
48 #include <widgets/modest-msg-view-window.h>
49 #include <widgets/modest-account-view-window.h>
50 #include <widgets/modest-details-dialog.h>
52 #include "modest-account-mgr-helpers.h"
53 #include "modest-mail-operation.h"
54 #include "modest-text-utils.h"
56 #ifdef MODEST_HAVE_EASYSETUP
57 #include "easysetup/modest-easysetup-wizard.h"
58 #endif /*MODEST_HAVE_EASYSETUP*/
60 #include <modest-widget-memory.h>
61 #include <tny-error.h>
62 #include <tny-simple-list.h>
63 #include <tny-msg-view.h>
64 #include <tny-device.h>
66 typedef struct _GetMsgAsyncHelper {
68 ModestMailOperation *mail_op;
75 typedef enum _ReplyForwardAction {
81 typedef struct _ReplyForwardHelper {
82 guint reply_forward_type;
83 ReplyForwardAction action;
88 static void reply_forward_func (gpointer data, gpointer user_data);
89 static void read_msg_func (gpointer data, gpointer user_data);
90 static void get_msg_cb (TnyFolder *folder, TnyMsg *msg, GError **err,
92 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
94 static gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
98 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
101 const gchar *authors[] = {
102 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
105 about = gtk_about_dialog_new ();
106 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
107 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
108 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
109 _("Copyright (c) 2006, Nokia Corporation\n"
110 "All rights reserved."));
111 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
112 _("a modest e-mail client\n\n"
113 "design and implementation: Dirk-Jan C. Binnema\n"
114 "contributions from the fine people at KC and Ig\n"
115 "uses the tinymail email framework written by Philip van Hoof"));
116 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
117 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
119 gtk_dialog_run (GTK_DIALOG (about));
120 gtk_widget_destroy(about);
125 get_selected_headers (ModestWindow *win)
127 if (MODEST_IS_MAIN_WINDOW(win)) {
128 GtkWidget *header_view;
130 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
131 MODEST_WIDGET_TYPE_HEADER_VIEW);
132 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
134 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
135 /* for MsgViewWindows, we simply return a list with one element */
138 TnyList *list = NULL;
140 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
142 header = tny_msg_get_header (msg);
143 list = tny_simple_list_new ();
144 tny_list_prepend (list, G_OBJECT(header));
145 g_object_unref (G_OBJECT(header));
154 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
156 TnyList *header_list;
159 g_return_if_fail (MODEST_IS_WINDOW(win));
161 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
163 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
167 header_list = get_selected_headers (win);
170 iter = tny_list_create_iterator (header_list);
173 ModestMailOperation *mail_op;
175 header = TNY_HEADER (tny_iterator_get_current (iter));
176 /* TODO: thick grain mail operation involving
177 a list of objects. Composite pattern ??? */
178 /* TODO: add confirmation dialog */
179 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE);
180 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
183 /* Always delete. TODO: Move to trash still not supported */
184 modest_mail_operation_remove_msg (mail_op, header, FALSE);
187 g_object_unref (G_OBJECT (mail_op));
188 g_object_unref (G_OBJECT (header));
190 tny_iterator_next (iter);
192 } while (!tny_iterator_is_done (iter));
195 g_object_unref (G_OBJECT (iter));
198 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
199 gtk_widget_destroy (GTK_WIDGET(win));
205 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
211 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
213 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
214 gtk_widget_destroy (GTK_WIDGET (win));
215 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
217 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
218 } else if (MODEST_IS_WINDOW (win)) {
219 gtk_widget_destroy (GTK_WIDGET (win));
221 g_return_if_reached ();
226 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
228 GtkClipboard *clipboard = NULL;
229 gchar *selection = NULL;
231 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
232 selection = gtk_clipboard_wait_for_text (clipboard);
234 modest_address_book_add_address (selection);
239 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
242 /* This is currently only implemented for Maemo,
243 * because it requires a providers preset file which is not publically available.
245 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
246 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
247 TRUE /* enabled accounts only */);
248 gboolean accounts_exist = account_names != NULL;
249 g_slist_free (account_names);
251 if (!accounts_exist) {
252 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
253 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
254 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
255 gtk_dialog_run (GTK_DIALOG (wizard));
256 gtk_widget_destroy (GTK_WIDGET (wizard));
258 /* Show the list of accounts: */
259 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
260 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
261 gtk_dialog_run (account_win);
262 gtk_widget_destroy (GTK_WIDGET(account_win));
265 GtkWidget *dialog, *label;
267 /* Create the widgets */
269 dialog = gtk_dialog_new_with_buttons ("Message",
271 GTK_DIALOG_DESTROY_WITH_PARENT,
275 label = gtk_label_new ("Hello World!");
277 /* Ensure that the dialog box is destroyed when the user responds. */
279 g_signal_connect_swapped (dialog, "response",
280 G_CALLBACK (gtk_widget_destroy),
283 /* Add the label, and show everything we've added to the dialog. */
285 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
287 gtk_widget_show_all (dialog);
288 #endif /* MODEST_PLATFORM_MAEMO */
292 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
294 ModestWindow *msg_win;
296 TnyFolder *folder = NULL;
297 gchar *account_name = NULL;
298 gchar *from_str = NULL;
299 /* GError *err = NULL; */
300 TnyAccount *account = NULL;
301 ModestWindowMgr *mgr;
302 gchar *signature = NULL;
304 account_name = g_strdup(modest_window_get_active_account (win));
306 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
308 g_printerr ("modest: no account found\n");
312 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
314 TNY_ACCOUNT_TYPE_STORE);
316 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
320 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
322 g_printerr ("modest: failed get from string for '%s'\n", account_name);
326 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
327 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
328 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
329 MODEST_ACCOUNT_SIGNATURE, FALSE);
331 signature = g_strdup ("");
334 msg = modest_tny_msg_new ("", from_str, "", "", "", signature, NULL);
336 g_printerr ("modest: failed to create new msg\n");
340 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
342 g_printerr ("modest: failed to find Drafts folder\n");
346 /* tny_folder_add_msg (folder, msg, &err); */
348 /* g_printerr ("modest: error adding msg to Drafts folder: %s", */
350 /* g_error_free (err); */
354 /* Create and register edit window */
355 msg_win = modest_msg_edit_window_new (msg, account_name);
356 mgr = modest_runtime_get_window_mgr ();
357 modest_window_mgr_register_window (mgr, msg_win);
360 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
362 gtk_widget_show_all (GTK_WIDGET (msg_win));
365 g_free (account_name);
369 g_object_unref (G_OBJECT(account));
371 g_object_unref (G_OBJECT(msg));
373 g_object_unref (G_OBJECT(folder));
378 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
380 modest_runtime_not_implemented (GTK_WINDOW(win)); /* FIXME */
386 reply_forward_func (gpointer data, gpointer user_data)
388 TnyMsg *msg, *new_msg;
389 GetMsgAsyncHelper *helper;
390 ReplyForwardHelper *rf_helper;
391 ModestWindow *msg_win;
392 ModestEditType edit_type;
395 TnyFolder *folder = NULL;
396 TnyAccount *account = NULL;
397 ModestWindowMgr *mgr;
398 gchar *signature = NULL;
400 msg = TNY_MSG (data);
401 helper = (GetMsgAsyncHelper *) user_data;
402 rf_helper = (ReplyForwardHelper *) helper->user_data;
404 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
405 rf_helper->account_name);
406 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
407 rf_helper->account_name,
408 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
409 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
410 rf_helper->account_name,
411 MODEST_ACCOUNT_SIGNATURE, FALSE);
413 /* Create reply mail */
414 switch (rf_helper->action) {
417 modest_tny_msg_create_reply_msg (msg, from, signature,
418 rf_helper->reply_forward_type,
419 MODEST_TNY_MSG_REPLY_MODE_SENDER);
421 case ACTION_REPLY_TO_ALL:
423 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
424 MODEST_TNY_MSG_REPLY_MODE_ALL);
425 edit_type = MODEST_EDIT_TYPE_REPLY;
429 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
430 edit_type = MODEST_EDIT_TYPE_FORWARD;
433 g_return_if_reached ();
440 g_printerr ("modest: failed to create message\n");
444 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
445 rf_helper->account_name,
446 TNY_ACCOUNT_TYPE_STORE);
448 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
452 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
454 g_printerr ("modest: failed to find Drafts folder\n");
458 tny_folder_add_msg (folder, msg, &err);
460 g_printerr ("modest: error adding msg to Drafts folder: %s",
466 /* Create and register the windows */
467 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
468 mgr = modest_runtime_get_window_mgr ();
469 modest_window_mgr_register_window (mgr, msg_win);
471 /* Show edit window */
472 gtk_widget_show_all (GTK_WIDGET (msg_win));
476 g_object_unref (G_OBJECT (new_msg));
478 g_object_unref (G_OBJECT (folder));
480 g_object_unref (G_OBJECT (account));
482 /* g_free (rf_helper->account_name); */
483 /* g_slice_free (ReplyForwardHelper, rf_helper); */
486 * Common code for the reply and forward actions
489 reply_forward (ReplyForwardAction action, ModestWindow *win)
491 TnyList *header_list;
492 guint reply_forward_type;
494 /* TnyFolder *folder; */
495 GetMsgAsyncHelper *helper;
496 ReplyForwardHelper *rf_helper;
498 g_return_if_fail (MODEST_IS_WINDOW(win));
500 header_list = get_selected_headers (win);
504 reply_forward_type = modest_conf_get_int (modest_runtime_get_conf (),
505 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
507 /* We assume that we can only select messages of the
508 same folder and that we reply all of them from the
509 same account. In fact the interface currently only
510 allows single selection */
513 rf_helper = g_slice_new0 (ReplyForwardHelper);
514 rf_helper->reply_forward_type = reply_forward_type;
515 rf_helper->action = action;
517 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
518 if (!rf_helper->account_name)
519 rf_helper->account_name =
520 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
522 helper = g_slice_new0 (GetMsgAsyncHelper);
523 helper->window = win;
524 helper->func = reply_forward_func;
525 helper->iter = tny_list_create_iterator (header_list);
526 helper->user_data = rf_helper;
527 helper->num_ops = tny_list_get_length (header_list);
529 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
531 msg = modest_msg_view_window_get_message(MODEST_MSG_VIEW_WINDOW(win));
533 g_printerr ("modest: no message found\n");
536 reply_forward_func (msg, helper);
538 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
540 /* folder = tny_header_get_folder (header); */
542 /* /\* The callback will call it per each header *\/ */
543 /* tny_folder_get_msg_async (folder, header, get_msg_cb, NULL, helper); */
544 /* g_object_unref (G_OBJECT (folder)); */
546 /* g_printerr ("modest: no folder for header\n"); */
548 helper->mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
549 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), helper->mail_op);
550 modest_mail_operation_process_msg (helper->mail_op, header, helper->num_ops, get_msg_cb, helper);
553 g_object_unref (G_OBJECT (header));
559 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
561 g_return_if_fail (MODEST_IS_WINDOW(win));
563 reply_forward (ACTION_REPLY, win);
567 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
569 g_return_if_fail (MODEST_IS_WINDOW(win));
571 reply_forward (ACTION_FORWARD, win);
575 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
577 g_return_if_fail (MODEST_IS_WINDOW(win));
579 reply_forward (ACTION_REPLY_TO_ALL, win);
583 modest_ui_actions_on_next (GtkAction *action,
584 ModestWindow *window)
586 if (MODEST_IS_MAIN_WINDOW (window)) {
587 GtkWidget *header_view;
589 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
590 MODEST_WIDGET_TYPE_HEADER_VIEW);
594 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
595 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
596 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
598 g_return_if_reached ();
603 modest_ui_actions_on_prev (GtkAction *action,
604 ModestWindow *window)
606 g_return_if_fail (MODEST_IS_WINDOW(window));
608 if (MODEST_IS_MAIN_WINDOW (window)) {
609 GtkWidget *header_view;
610 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
611 MODEST_WIDGET_TYPE_HEADER_VIEW);
615 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
616 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
617 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
619 g_return_if_reached ();
624 modest_ui_actions_on_sort (GtkAction *action,
625 ModestWindow *window)
627 g_return_if_fail (MODEST_IS_WINDOW(window));
629 if (MODEST_IS_MAIN_WINDOW (window)) {
630 GtkWidget *header_view;
631 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
632 MODEST_WIDGET_TYPE_HEADER_VIEW);
636 /* Show sorting dialog */
637 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
643 action_send (const gchar* account_name)
645 TnyAccount *tny_account;
646 ModestTnySendQueue *send_queue;
648 g_return_val_if_fail (account_name, FALSE);
650 /* Get the transport account according to the open connection,
651 * because the account might specify connection-specific SMTP servers.
654 modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
657 g_printerr ("modest: cannot get tny transport account for %s\n", account_name);
661 send_queue = modest_tny_send_queue_new (TNY_CAMEL_TRANSPORT_ACCOUNT(tny_account));
663 g_object_unref (G_OBJECT(tny_account));
664 g_printerr ("modest: cannot get send queue for %s\n", account_name);
668 //modest_tny_send_queue_flush (send_queue);
670 g_object_unref (G_OBJECT(send_queue));
671 g_object_unref (G_OBJECT(tny_account));
678 action_receive (const gchar* account_name)
680 TnyAccount *tny_account;
681 ModestMailOperation *mail_op;
683 g_return_val_if_fail (account_name, FALSE);
686 modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
688 TNY_ACCOUNT_TYPE_STORE);
690 g_printerr ("modest: cannot get tny store account for %s\n", account_name);
694 /* Create the mail operation */
695 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
696 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
697 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
698 modest_mail_operation_update_account (mail_op, TNY_STORE_ACCOUNT(tny_account));
700 g_object_unref (G_OBJECT(tny_account));
701 g_object_unref (G_OBJECT (mail_op));
706 /** Check that an appropriate connection is open.
708 gboolean check_for_connection (const gchar *account_name)
710 TnyDevice *device = modest_runtime_get_device ();
713 g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
715 TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);
718 if (tny_device_is_online (device))
721 modest_platform_connect_and_wait (NULL);
723 /* TODO: Wait until a result. */
729 do_send_receive_current_or_default (ModestWindow *win)
733 g_message ("%s: online? %s", __FUNCTION__,
734 tny_device_is_online(modest_runtime_get_device()) ? "yes":"no");
736 /* As per the UI spec, only the active account should be affected,
737 * else the default folder if there is no active account: */
739 g_strdup(modest_window_get_active_account(MODEST_WINDOW(win)));
741 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
743 g_printerr ("modest: cannot get default account\n");
747 /* Do not continue if no suitable connection is open: */
748 if (check_for_connection (account_name)) {
749 /* As per the UI spec,
750 * for POP accounts, we should receive,
751 * for IMAP we should synchronize everything, including receiving,
752 * for SMTP we should send,
753 * first receiving, then sending:
755 if (!action_receive(account_name))
756 g_printerr ("modest: failed to receive\n");
757 if (!action_send(account_name))
758 g_printerr ("modest: failed to send\n");
760 g_free (account_name);
766 do_send_receive_auto (ModestWindow *win)
768 g_message ("%s: online? %s", __FUNCTION__,
769 tny_device_is_online(modest_runtime_get_device()) ? "yes":"no");
771 /* TODO: Delete the item->data strings as well as the list? */
772 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
773 TRUE /* enabled accounts only */);
774 GSList *iter = account_names;
776 const gchar * account_name = (const char*) iter->data;
778 /* Do not continue if no suitable connection is open: */
779 if (account_name && check_for_connection (account_name)) {
780 /* As per the UI spec,
781 * for POP accounts, we should receive,
782 * for IMAP we should synchronize everything, including receiving,
783 * for SMTP we should send,
784 * first receiving, then sending:
786 if (!action_receive(account_name))
787 g_printerr ("modest: failed to receive for account %s\n", account_name);
788 if (!action_send(account_name))
789 g_printerr ("modest: failed to send for account %s\n", account_name);
794 g_slist_free (account_names);
798 do_send_receive (ModestWindow *win)
800 const gboolean auto_update = TRUE; /* TODO: Get gconf setting. */
802 do_send_receive_current_or_default (win);
804 do_send_receive_auto (win);
808 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
810 /* Check that at least one account exists: */
811 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
812 TRUE /* enabled accounts only */);
813 gboolean accounts_exist = account_names != NULL;
814 g_slist_free (account_names);
816 /* If not, allow the user to create an account before trying to send/receive. */
817 if (!accounts_exist) {
818 modest_ui_actions_on_accounts (NULL, win);
821 do_send_receive (win);
828 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
831 GtkWidget *header_view;
833 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
835 header_view = modest_main_window_get_child_widget (main_window,
836 MODEST_WIDGET_TYPE_HEADER_VIEW);
840 conf = modest_runtime_get_conf ();
842 /* what is saved/restored is depending on the style; thus; we save with
843 * old style, then update the style, and restore for this new style
845 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
847 if (modest_header_view_get_style
848 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
849 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
850 MODEST_HEADER_VIEW_STYLE_TWOLINES);
852 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
853 MODEST_HEADER_VIEW_STYLE_DETAILS);
855 modest_widget_memory_restore (conf, G_OBJECT(header_view),
856 MODEST_CONF_HEADER_VIEW_KEY);
862 * Marks a message as read and passes it to the msg preview widget
865 read_msg_func (gpointer data, gpointer user_data)
869 GetMsgAsyncHelper *helper;
870 TnyHeaderFlags header_flags;
871 GtkWidget *msg_preview;
873 msg = TNY_MSG (data);
874 helper = (GetMsgAsyncHelper *) user_data;
876 msg_preview = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (helper->window),
877 MODEST_WIDGET_TYPE_MSG_PREVIEW);
881 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
882 header_flags = tny_header_get_flags (header);
883 tny_header_set_flags (header, header_flags | TNY_HEADER_FLAG_SEEN);
884 g_object_unref (G_OBJECT (header));
886 /* Set message on msg view */
887 modest_msg_view_set_message (MODEST_MSG_VIEW(msg_preview), msg);
891 * This function is a generic handler for the tny_folder_get_msg_async
892 * call. It expects as user_data a #GetMsgAsyncHelper. This helper
893 * contains a user provided function that is called inside this
894 * method. This will allow us to use this callback in many different
895 * places. This callback performs the common actions for the
896 * get_msg_async call, more specific actions will be done by the user
900 get_msg_cb (TnyFolder *folder, TnyMsg *msg, GError **err, gpointer user_data)
902 GetMsgAsyncHelper *helper;
904 helper = (GetMsgAsyncHelper *) user_data;
907 if ((*err && ((*err)->code == TNY_FOLDER_ERROR_GET_MSG)) || !msg) {
908 modest_ui_actions_on_item_not_found (NULL,
909 MODEST_ITEM_TYPE_MESSAGE,
914 /* Call user function */
916 helper->func (msg, user_data);
918 /* Process next element (if exists) */
919 tny_iterator_next (helper->iter);
920 if (tny_iterator_is_done (helper->iter)) {
921 /* Notify the queue */
922 if (helper->mail_op != NULL)
923 modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), helper->mail_op);
927 ReplyForwardHelper *rf_helper = (ReplyForwardHelper *) helper->user_data;
928 headers = tny_iterator_get_list (helper->iter);
929 g_object_unref (G_OBJECT (headers));
930 g_object_unref (G_OBJECT (helper->iter));
931 if (rf_helper != NULL) {
932 g_free (rf_helper->account_name);
933 g_slice_free (ReplyForwardHelper, rf_helper);
935 g_slice_free (GetMsgAsyncHelper, helper);
938 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
939 /* tny_folder_get_msg_async (folder, header, */
940 /* get_msg_cb, NULL, helper); */
941 modest_mail_operation_process_msg (helper->mail_op, header, helper->num_ops, get_msg_cb, helper);
943 g_object_unref (G_OBJECT(header));
948 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
950 ModestMainWindow *main_window)
952 /* TnyFolder *folder; */
953 GetMsgAsyncHelper *helper;
956 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
958 /* when there's no header, clear the msgview */
960 GtkWidget *msg_preview;
962 /* Clear msg preview if exists */
963 msg_preview = modest_main_window_get_child_widget(main_window,
964 MODEST_WIDGET_TYPE_MSG_PREVIEW);
967 modest_msg_view_set_message (MODEST_MSG_VIEW(msg_preview), NULL);
971 /* Update Main window title */
972 if (GTK_WIDGET_HAS_FOCUS (header_view)) {
973 const gchar *subject = tny_header_get_subject (header);
974 if (subject && strcmp (subject, ""))
975 gtk_window_set_title (GTK_WINDOW (main_window), subject);
977 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
981 list = tny_simple_list_new ();
982 tny_list_prepend (list, G_OBJECT (header));
984 /* Fill helper data */
985 helper = g_slice_new0 (GetMsgAsyncHelper);
986 helper->window = MODEST_WINDOW (main_window);
987 helper->iter = tny_list_create_iterator (list);
988 helper->func = read_msg_func;
989 helper->num_ops = tny_list_get_length (list);
991 /* folder = tny_header_get_folder (TNY_HEADER(header)); */
993 /* tny_folder_get_msg_async (TNY_FOLDER(folder), */
994 /* header, get_msg_cb, */
997 helper->mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
998 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), helper->mail_op);
999 modest_mail_operation_process_msg (helper->mail_op, header, helper->num_ops, get_msg_cb, helper);
1002 /* g_object_unref (G_OBJECT (folder)); */
1008 modest_ui_actions_on_header_activated (ModestHeaderView *folder_view, TnyHeader *header,
1009 ModestMainWindow *main_window)
1011 ModestWindow *win = NULL;
1012 TnyFolder *folder = NULL;
1014 ModestWindowMgr *mgr;
1015 GtkTreeModel *model;
1017 GtkTreeSelection *sel = NULL;
1018 GList *sel_list = NULL;
1020 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1025 folder = tny_header_get_folder (header);
1027 g_printerr ("modest: cannot get folder for header\n");
1031 /* FIXME: make async?; check error */
1032 msg = tny_folder_get_msg (folder, header, NULL);
1034 g_printerr ("modest: cannot get msg for header\n");
1038 /* Look if we already have a message view for that header */
1039 mgr = modest_runtime_get_window_mgr ();
1040 win = modest_window_mgr_find_window_by_msguid (mgr, tny_header_get_uid (header));
1042 /* If not, create a new window */
1046 account = g_strdup(modest_window_get_active_account(MODEST_WINDOW(main_window)));
1048 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1050 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
1051 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
1052 if (sel_list != NULL) {
1053 gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) sel_list->data);
1055 win = modest_msg_view_window_new_with_header_model (msg, account, model, iter);
1056 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
1057 g_list_free (sel_list);
1059 win = modest_msg_view_window_new (msg, account);
1061 modest_window_mgr_register_window (mgr, win);
1063 gtk_window_set_transient_for (GTK_WINDOW (win),
1064 GTK_WINDOW (main_window));
1067 gtk_widget_show_all (GTK_WIDGET(win));
1069 g_object_unref (G_OBJECT (msg));
1072 g_object_unref (G_OBJECT (folder));
1076 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1077 TnyFolderStore *folder_store,
1079 ModestMainWindow *main_window)
1082 GtkWidget *header_view;
1084 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1086 header_view = modest_main_window_get_child_widget(main_window,
1087 MODEST_WIDGET_TYPE_HEADER_VIEW);
1091 conf = modest_runtime_get_conf ();
1093 if (TNY_IS_FOLDER (folder_store)) {
1095 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1098 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1099 TNY_FOLDER (folder_store));
1100 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1101 MODEST_CONF_HEADER_VIEW_KEY);
1103 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1104 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
1106 } else if (TNY_IS_ACCOUNT (folder_store)) {
1108 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1113 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1120 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1122 if (g_main_depth > 0)
1123 gdk_threads_enter ();
1124 online = tny_device_is_online (modest_runtime_get_device());
1127 /* already online -- the item is simply not there... */
1128 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1130 GTK_MESSAGE_WARNING,
1132 _("The %s you selected cannot be found"),
1134 gtk_dialog_run (GTK_DIALOG(dialog));
1136 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1140 GTK_RESPONSE_REJECT,
1142 GTK_RESPONSE_ACCEPT,
1144 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1145 "Do you want to get online?"), item);
1146 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1147 gtk_label_new (txt), FALSE, FALSE, 0);
1148 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1151 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1152 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1153 // modest_platform_connect_and_wait ();;
1156 gtk_widget_destroy (dialog);
1157 if (g_main_depth > 0)
1158 gdk_threads_leave ();
1162 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1165 g_message ("%s %s", __FUNCTION__, link);
1170 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1173 modest_platform_activate_uri (link);
1177 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1180 modest_platform_show_uri_popup (link);
1184 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1187 g_message (__FUNCTION__);
1192 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1193 const gchar *address,
1196 g_message ("%s %s", __FUNCTION__, address);
1200 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1202 TnyTransportAccount *transport_account;
1203 ModestMailOperation *mail_operation;
1205 gchar *account_name, *from;
1206 ModestAccountMgr *account_mgr;
1208 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1210 data = modest_msg_edit_window_get_msg_data (edit_window);
1212 account_mgr = modest_runtime_get_account_mgr();
1213 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1215 account_name = modest_account_mgr_get_default_account (account_mgr);
1216 if (!account_name) {
1217 g_printerr ("modest: no account found\n");
1218 modest_msg_edit_window_free_msg_data (edit_window, data);
1222 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
1223 (modest_runtime_get_account_store(),
1225 TNY_ACCOUNT_TYPE_TRANSPORT));
1226 if (!transport_account) {
1227 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1228 g_free (account_name);
1229 modest_msg_edit_window_free_msg_data (edit_window, data);
1232 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1234 /* Create the mail operation */
1235 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO);
1236 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1238 modest_mail_operation_save_to_drafts (mail_operation,
1248 data->priority_flags);
1251 g_free (account_name);
1252 g_object_unref (G_OBJECT (transport_account));
1253 g_object_unref (G_OBJECT (mail_operation));
1255 modest_msg_edit_window_free_msg_data (edit_window, data);
1257 /* Save settings and close the window */
1258 gtk_widget_destroy (GTK_WIDGET (edit_window));
1261 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1263 TnyTransportAccount *transport_account;
1264 ModestMailOperation *mail_operation;
1266 gchar *account_name, *from;
1267 ModestAccountMgr *account_mgr;
1269 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1271 if (!modest_msg_edit_window_check_names (edit_window))
1274 data = modest_msg_edit_window_get_msg_data (edit_window);
1276 /* FIXME: Code added just for testing. The final version will
1277 use the send queue provided by tinymail and some
1279 account_mgr = modest_runtime_get_account_mgr();
1280 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1282 account_name = modest_account_mgr_get_default_account (account_mgr);
1283 if (!account_name) {
1284 g_printerr ("modest: no account found\n");
1285 modest_msg_edit_window_free_msg_data (edit_window, data);
1289 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1290 (modest_runtime_get_account_store(),
1292 if (!transport_account) {
1293 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1294 g_free (account_name);
1295 modest_msg_edit_window_free_msg_data (edit_window, data);
1298 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1300 /* Create the mail operation */
1301 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_SEND);
1302 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1304 modest_mail_operation_send_new_mail (mail_operation,
1314 data->priority_flags);
1317 g_free (account_name);
1318 g_object_unref (G_OBJECT (transport_account));
1319 g_object_unref (G_OBJECT (mail_operation));
1321 modest_msg_edit_window_free_msg_data (edit_window, data);
1323 /* Save settings and close the window */
1324 gtk_widget_destroy (GTK_WIDGET (edit_window));
1328 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1329 ModestMsgEditWindow *window)
1331 ModestMsgEditFormatState *format_state = NULL;
1333 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1334 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1336 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1339 format_state = modest_msg_edit_window_get_format_state (window);
1340 g_return_if_fail (format_state != NULL);
1342 format_state->bold = gtk_toggle_action_get_active (action);
1343 modest_msg_edit_window_set_format_state (window, format_state);
1344 g_free (format_state);
1349 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1350 ModestMsgEditWindow *window)
1352 ModestMsgEditFormatState *format_state = NULL;
1354 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1355 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1357 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1360 format_state = modest_msg_edit_window_get_format_state (window);
1361 g_return_if_fail (format_state != NULL);
1363 format_state->italics = gtk_toggle_action_get_active (action);
1364 modest_msg_edit_window_set_format_state (window, format_state);
1365 g_free (format_state);
1370 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1371 ModestMsgEditWindow *window)
1373 ModestMsgEditFormatState *format_state = NULL;
1375 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1376 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1378 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1381 format_state = modest_msg_edit_window_get_format_state (window);
1382 g_return_if_fail (format_state != NULL);
1384 format_state->bullet = gtk_toggle_action_get_active (action);
1385 modest_msg_edit_window_set_format_state (window, format_state);
1386 g_free (format_state);
1391 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1392 GtkRadioAction *selected,
1393 ModestMsgEditWindow *window)
1395 ModestMsgEditFormatState *format_state = NULL;
1396 GtkJustification value;
1398 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1400 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1403 value = gtk_radio_action_get_current_value (selected);
1405 format_state = modest_msg_edit_window_get_format_state (window);
1406 g_return_if_fail (format_state != NULL);
1408 format_state->justification = value;
1409 modest_msg_edit_window_set_format_state (window, format_state);
1410 g_free (format_state);
1414 modest_ui_actions_on_select_editor_color (GtkAction *action,
1415 ModestMsgEditWindow *window)
1417 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1418 g_return_if_fail (GTK_IS_ACTION (action));
1420 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1423 modest_msg_edit_window_select_color (window);
1427 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1428 ModestMsgEditWindow *window)
1430 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1431 g_return_if_fail (GTK_IS_ACTION (action));
1433 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1436 modest_msg_edit_window_select_background_color (window);
1440 modest_ui_actions_on_insert_image (GtkAction *action,
1441 ModestMsgEditWindow *window)
1443 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1444 g_return_if_fail (GTK_IS_ACTION (action));
1446 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1449 modest_msg_edit_window_insert_image (window);
1453 * Shows a dialog with an entry that asks for some text. The returned
1454 * value must be freed by the caller. The dialog window title will be
1458 ask_for_folder_name (GtkWindow *parent_window,
1461 GtkWidget *dialog, *entry;
1462 gchar *folder_name = NULL;
1464 /* Ask for folder name */
1465 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1469 GTK_RESPONSE_REJECT,
1471 GTK_RESPONSE_ACCEPT,
1473 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1474 gtk_label_new(title),
1477 entry = gtk_entry_new_with_max_length (40);
1478 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1482 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1484 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1485 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1487 gtk_widget_destroy (dialog);
1493 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1495 TnyFolderStore *parent_folder;
1496 GtkWidget *folder_view;
1498 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1500 folder_view = modest_main_window_get_child_widget (main_window,
1501 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1505 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1507 if (parent_folder) {
1508 gboolean finished = FALSE;
1510 gchar *folder_name = NULL, *suggested_name = NULL;
1512 /* Run the new folder dialog */
1514 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1519 if (result == GTK_RESPONSE_REJECT) {
1522 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO);
1523 TnyFolder *new_folder = NULL;
1525 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1528 new_folder = modest_mail_operation_create_folder (mail_op,
1530 (const gchar *) folder_name);
1532 g_object_unref (new_folder);
1536 /* /\* TODO: check error and follow proper actions *\/ */
1537 /* /\* suggested_name = X; *\/ */
1538 /* /\* Show error to the user *\/ */
1539 /* modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1540 /* MODEST_INFORMATION_CREATE_FOLDER); */
1542 g_object_unref (mail_op);
1544 g_free (folder_name);
1548 g_object_unref (parent_folder);
1553 modest_ui_actions_on_rename_folder (GtkAction *action,
1554 ModestMainWindow *main_window)
1556 TnyFolderStore *folder;
1557 GtkWidget *folder_view;
1559 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1561 folder_view = modest_main_window_get_child_widget (main_window,
1562 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1566 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1568 if (folder && TNY_IS_FOLDER (folder)) {
1570 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1571 _("Please enter a new name for the folder"));
1573 if (folder_name != NULL && strlen (folder_name) > 0) {
1574 ModestMailOperation *mail_op;
1576 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO);
1577 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1580 modest_mail_operation_rename_folder (mail_op,
1581 TNY_FOLDER (folder),
1582 (const gchar *) folder_name);
1584 g_object_unref (mail_op);
1585 g_free (folder_name);
1587 g_object_unref (folder);
1592 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1594 TnyFolderStore *folder;
1595 GtkWidget *folder_view;
1599 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1601 folder_view = modest_main_window_get_child_widget (main_window,
1602 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1606 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1609 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1610 tny_folder_get_name (TNY_FOLDER (folder)));
1611 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1612 (const gchar *) message);
1615 if (response == GTK_RESPONSE_OK) {
1616 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE);
1618 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1620 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1622 /* Show error if happened */
1623 if (modest_mail_operation_get_error (mail_op))
1624 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1625 MODEST_INFORMATION_DELETE_FOLDER);
1627 g_object_unref (G_OBJECT (mail_op));
1630 g_object_unref (G_OBJECT (folder));
1634 modest_ui_actions_on_delete_folder (GtkAction *action,
1635 ModestMainWindow *main_window)
1637 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1639 delete_folder (main_window, FALSE);
1643 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1645 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1647 delete_folder (main_window, TRUE);
1651 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1652 const gchar* account_name,
1656 ModestMainWindow *main_window)
1659 GtkWidget *dialog, *entry, *remember_pass_check;
1661 dialog = gtk_dialog_new_with_buttons (_("Password requested"),
1665 GTK_RESPONSE_REJECT,
1667 GTK_RESPONSE_ACCEPT,
1669 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1671 txt = g_strdup_printf (_("Please enter your password for %s"), account_name);
1672 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1676 entry = gtk_entry_new_with_max_length (40);
1677 gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
1678 gtk_entry_set_invisible_char (GTK_ENTRY(entry), 0x2022); /* bullet unichar */
1680 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry,
1683 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1684 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1687 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1689 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1690 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry)));
1697 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1702 gtk_widget_destroy (dialog);
1706 modest_ui_actions_on_cut (GtkAction *action,
1707 ModestWindow *window)
1709 GtkWidget *focused_widget;
1711 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1712 if (GTK_IS_EDITABLE (focused_widget)) {
1713 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1714 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1715 GtkTextBuffer *buffer;
1716 GtkClipboard *clipboard;
1718 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1719 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1720 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1725 modest_ui_actions_on_copy (GtkAction *action,
1726 ModestWindow *window)
1728 GtkClipboard *clipboard;
1729 GtkWidget *focused_widget;
1731 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1732 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1733 if (GTK_IS_LABEL (focused_widget)) {
1734 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1735 } else if (GTK_IS_EDITABLE (focused_widget)) {
1736 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1737 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1738 GtkTextBuffer *buffer;
1740 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1741 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1746 modest_ui_actions_on_undo (GtkAction *action,
1747 ModestWindow *window)
1749 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1750 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1752 g_return_if_reached ();
1757 modest_ui_actions_on_paste (GtkAction *action,
1758 ModestWindow *window)
1760 GtkWidget *focused_widget;
1762 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1763 if (GTK_IS_EDITABLE (focused_widget)) {
1764 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1765 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1766 GtkTextBuffer *buffer;
1767 GtkClipboard *clipboard;
1769 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1770 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1771 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1776 modest_ui_actions_on_select_all (GtkAction *action,
1777 ModestWindow *window)
1779 GtkWidget *focused_widget;
1781 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1782 if (GTK_IS_LABEL (focused_widget)) {
1783 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1784 } else if (GTK_IS_EDITABLE (focused_widget)) {
1785 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1786 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1787 GtkTextBuffer *buffer;
1788 GtkTextIter start, end;
1790 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1791 gtk_text_buffer_get_start_iter (buffer, &start);
1792 gtk_text_buffer_get_end_iter (buffer, &end);
1793 gtk_text_buffer_select_range (buffer, &start, &end);
1798 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
1799 GtkRadioAction *selected,
1800 ModestWindow *window)
1804 value = gtk_radio_action_get_current_value (selected);
1805 if (MODEST_IS_WINDOW (window)) {
1806 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
1810 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
1811 GtkRadioAction *selected,
1812 ModestWindow *window)
1814 TnyHeaderFlags flags;
1815 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1817 flags = gtk_radio_action_get_current_value (selected);
1818 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
1821 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
1822 GtkRadioAction *selected,
1823 ModestWindow *window)
1827 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1829 file_format = gtk_radio_action_get_current_value (selected);
1830 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
1835 modest_ui_actions_on_zoom_plus (GtkAction *action,
1836 ModestWindow *window)
1838 g_return_if_fail (MODEST_IS_WINDOW (window));
1840 modest_window_zoom_plus (MODEST_WINDOW (window));
1844 modest_ui_actions_on_zoom_minus (GtkAction *action,
1845 ModestWindow *window)
1847 g_return_if_fail (MODEST_IS_WINDOW (window));
1849 modest_window_zoom_minus (MODEST_WINDOW (window));
1853 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
1854 ModestWindow *window)
1856 ModestWindowMgr *mgr;
1857 gboolean fullscreen, active;
1858 g_return_if_fail (MODEST_IS_WINDOW (window));
1860 mgr = modest_runtime_get_window_mgr ();
1862 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
1863 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1865 if (active != fullscreen) {
1866 modest_window_mgr_set_fullscreen_mode (mgr, active);
1867 gtk_window_present (GTK_WINDOW (window));
1872 modest_ui_actions_on_change_fullscreen (GtkAction *action,
1873 ModestWindow *window)
1875 ModestWindowMgr *mgr;
1876 gboolean fullscreen;
1878 g_return_if_fail (MODEST_IS_WINDOW (window));
1880 mgr = modest_runtime_get_window_mgr ();
1881 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1882 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
1884 gtk_window_present (GTK_WINDOW (window));
1888 * Show the header details in a ModestDetailsDialog widget
1891 show_header_details (TnyHeader *header,
1897 dialog = modest_details_dialog_new_with_header (window, header);
1900 gtk_widget_show_all (dialog);
1901 gtk_dialog_run (GTK_DIALOG (dialog));
1903 gtk_widget_destroy (dialog);
1907 * Show the folder details in a ModestDetailsDialog widget
1910 show_folder_details (TnyFolder *folder,
1916 dialog = modest_details_dialog_new_with_folder (window, folder);
1919 gtk_widget_show_all (dialog);
1920 gtk_dialog_run (GTK_DIALOG (dialog));
1922 gtk_widget_destroy (dialog);
1927 modest_ui_actions_on_details (GtkAction *action,
1930 TnyList * headers_list;
1934 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1937 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1941 headers_list = get_selected_headers (win);
1945 iter = tny_list_create_iterator (headers_list);
1947 header = TNY_HEADER (tny_iterator_get_current (iter));
1948 show_header_details (header, GTK_WINDOW (win));
1949 g_object_unref (header);
1951 g_object_unref (iter);
1953 } else if (MODEST_IS_MAIN_WINDOW (win)) {
1954 GtkWidget *folder_view, *header_view;
1956 /* Check which widget has the focus */
1957 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1958 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1959 if (gtk_widget_is_focus (folder_view)) {
1962 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1964 /* Show only when it's a folder */
1965 if (!folder || !TNY_IS_FOLDER (folder))
1968 show_folder_details (folder, GTK_WINDOW (win));
1971 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1972 MODEST_WIDGET_TYPE_HEADER_VIEW);
1973 if (!gtk_widget_is_focus (header_view))
1976 headers_list = get_selected_headers (win);
1980 iter = tny_list_create_iterator (headers_list);
1981 while (!tny_iterator_is_done (iter)) {
1983 header = TNY_HEADER (tny_iterator_get_current (iter));
1984 show_header_details (header, GTK_WINDOW (win));
1985 g_object_unref (header);
1987 tny_iterator_next (iter);
1989 g_object_unref (iter);
1995 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
1996 ModestMsgEditWindow *window)
1998 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2000 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2004 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2005 ModestMsgEditWindow *window)
2007 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2009 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2013 modest_ui_actions_toggle_folders_view (GtkAction *action,
2014 ModestMainWindow *main_window)
2018 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2020 conf = modest_runtime_get_conf ();
2022 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2023 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2025 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2029 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2030 ModestWindow *window)
2032 gboolean active, fullscreen = FALSE;
2033 ModestWindowMgr *mgr;
2035 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2037 /* Check if we want to toggle the toolbar vuew in fullscreen
2039 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2040 "ViewShowToolbarFullScreen")) {
2044 /* Toggle toolbar */
2045 mgr = modest_runtime_get_window_mgr ();
2046 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2050 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2051 ModestMsgEditWindow *window)
2053 modest_msg_edit_window_select_font (window);
2057 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2058 const gchar *display_name,
2061 /* Do not change the application name if the widget has not
2062 the focus. This callback could be called even if the folder
2063 view has not the focus, because the handled signal could be
2064 emitted when the folder view is redrawn */
2065 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2067 gtk_window_set_title (window, display_name);
2069 gtk_window_set_title (window, " ");
2074 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2076 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2077 modest_msg_edit_window_select_contacts (window);
2081 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2083 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2084 modest_msg_edit_window_check_names (window);
2089 create_move_to_dialog (ModestWindow *win,
2090 GtkWidget *folder_view,
2091 GtkWidget **tree_view)
2093 GtkWidget *dialog, *scroll;
2095 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2097 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2099 GTK_RESPONSE_ACCEPT,
2101 GTK_RESPONSE_REJECT,
2104 /* Create scrolled window */
2105 scroll = gtk_scrolled_window_new (NULL, NULL);
2106 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2107 GTK_POLICY_AUTOMATIC,
2108 GTK_POLICY_AUTOMATIC);
2110 /* Create folder view */
2111 *tree_view = modest_folder_view_new (NULL);
2112 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2113 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2114 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2116 /* Add scroll to dialog */
2117 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2118 scroll, FALSE, FALSE, 0);
2120 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2126 * Returns TRUE if at least one of the headers of the list belongs to
2127 * a message that has been fully retrieved.
2130 has_retrieved_msgs (TnyList *list)
2133 gboolean found = FALSE;
2135 iter = tny_list_create_iterator (list);
2136 while (tny_iterator_is_done (iter) && !found) {
2138 TnyHeaderFlags flags;
2140 header = TNY_HEADER (tny_iterator_get_current (iter));
2141 flags = tny_header_get_flags (header);
2142 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2146 tny_iterator_next (iter);
2148 g_object_unref (iter);
2154 * Shows a confirmation dialog to the user when we're moving messages
2155 * from a remote server to the local storage. Returns the dialog
2156 * response. If it's other kind of movement the it always returns
2160 msgs_move_to_confirmation (GtkWindow *win,
2161 TnyFolder *dest_folder,
2164 gint response = GTK_RESPONSE_OK;
2166 /* If the destination is a local folder */
2167 if (modest_tny_folder_is_local_folder (dest_folder)) {
2168 TnyFolder *src_folder;
2172 /* Get source folder */
2173 iter = tny_list_create_iterator (headers);
2174 header = TNY_HEADER (tny_iterator_get_current (iter));
2175 src_folder = tny_header_get_folder (header);
2176 g_object_unref (header);
2177 g_object_unref (iter);
2179 /* If the source is a remote folder */
2180 if (!modest_tny_folder_is_local_folder (src_folder)) {
2181 const gchar *message;
2183 if (tny_list_get_length (headers) == 1)
2184 if (has_retrieved_msgs (headers))
2185 message = _("mcen_nc_move_retrieve");
2187 message = _("mcen_nc_move_header");
2189 if (has_retrieved_msgs (headers))
2190 message = _("mcen_nc_move_retrieves");
2192 message = _("mcen_nc_move_headers");
2194 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2195 (const gchar *) message);
2202 * UI handler for the "Move to" action when invoked from the
2206 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2207 ModestMainWindow *win)
2209 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2211 TnyFolderStore *folder_store;
2212 ModestMailOperation *mail_op = NULL;
2214 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2216 /* Get the folder view */
2217 folder_view = modest_main_window_get_child_widget (win,
2218 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2220 /* Create and run the dialog */
2221 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2222 result = gtk_dialog_run (GTK_DIALOG(dialog));
2224 /* We do this to save an indentation level ;-) */
2225 if (result != GTK_RESPONSE_ACCEPT)
2228 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2230 if (TNY_IS_ACCOUNT (folder_store))
2233 /* Get folder or messages to transfer */
2234 if (gtk_widget_is_focus (folder_view)) {
2235 TnyFolderStore *src_folder;
2236 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2238 if (TNY_IS_FOLDER (src_folder)) {
2239 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
2240 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2243 modest_mail_operation_xfer_folder (mail_op,
2244 TNY_FOLDER (src_folder),
2247 g_object_unref (G_OBJECT (mail_op));
2251 g_object_unref (G_OBJECT (src_folder));
2253 GtkWidget *header_view;
2254 header_view = modest_main_window_get_child_widget (win,
2255 MODEST_WIDGET_TYPE_HEADER_VIEW);
2256 if (gtk_widget_is_focus (header_view)) {
2260 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2262 /* Ask for user confirmation */
2263 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2264 TNY_FOLDER (folder_store),
2267 /* Transfer messages */
2268 if (response == GTK_RESPONSE_OK) {
2269 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
2270 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2273 modest_mail_operation_xfer_msgs (mail_op,
2275 TNY_FOLDER (folder_store),
2277 g_object_unref (G_OBJECT (mail_op));
2281 g_object_unref (folder_store);
2284 gtk_widget_destroy (dialog);
2289 * UI handler for the "Move to" action when invoked from the
2290 * ModestMsgViewWindow
2293 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2294 ModestMsgViewWindow *win)
2296 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2298 ModestMainWindow *main_window;
2303 /* Get the folder view */
2304 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2305 folder_view = modest_main_window_get_child_widget (main_window,
2306 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2308 /* Create and run the dialog */
2309 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2310 result = gtk_dialog_run (GTK_DIALOG(dialog));
2312 if (result == GTK_RESPONSE_ACCEPT) {
2313 TnyFolderStore *folder_store;
2316 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2318 /* Create header list */
2319 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2320 header = tny_msg_get_header (msg);
2321 headers = tny_simple_list_new ();
2322 tny_list_prepend (headers, G_OBJECT (header));
2323 g_object_unref (header);
2324 g_object_unref (msg);
2326 /* Ask user for confirmation. MSG-NOT404 */
2327 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2328 TNY_FOLDER (folder_store),
2331 /* Transfer current msg */
2332 if (response == GTK_RESPONSE_OK) {
2333 ModestMailOperation *mail_op;
2335 /* Create mail op */
2336 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
2337 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2340 /* Transfer messages */
2341 modest_mail_operation_xfer_msgs (mail_op,
2343 TNY_FOLDER (folder_store),
2345 g_object_unref (G_OBJECT (mail_op));
2347 g_object_unref (headers);
2349 g_object_unref (folder_store);
2351 gtk_widget_destroy (dialog);
2355 modest_ui_actions_on_move_to (GtkAction *action,
2358 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2359 MODEST_IS_MSG_VIEW_WINDOW (win));
2361 if (MODEST_IS_MAIN_WINDOW (win))
2362 modest_ui_actions_on_main_window_move_to (action,
2363 MODEST_MAIN_WINDOW (win));
2365 modest_ui_actions_on_msg_view_window_move_to (action,
2366 MODEST_MSG_VIEW_WINDOW (win));