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 #ifdef MODEST_PLATFORM_MAEMO
48 #include "maemo/modest-osso-state-saving.h"
49 #endif /* MODEST_PLATFORM_MAEMO */
52 #include <widgets/modest-main-window.h>
53 #include <widgets/modest-msg-view-window.h>
54 #include <widgets/modest-account-view-window.h>
55 #include <widgets/modest-details-dialog.h>
57 #include "modest-account-mgr-helpers.h"
58 #include "modest-mail-operation.h"
59 #include "modest-text-utils.h"
61 #ifdef MODEST_HAVE_EASYSETUP
62 #include "easysetup/modest-easysetup-wizard.h"
63 #endif /* MODEST_HAVE_EASYSETUP */
65 #include <modest-widget-memory.h>
66 #include <tny-error.h>
67 #include <tny-simple-list.h>
68 #include <tny-msg-view.h>
69 #include <tny-device.h>
71 typedef struct _GetMsgAsyncHelper {
73 ModestMailOperation *mail_op;
80 typedef enum _ReplyForwardAction {
86 typedef struct _ReplyForwardHelper {
87 guint reply_forward_type;
88 ReplyForwardAction action;
93 typedef struct _HeaderActivatedHelper {
97 } HeaderActivatedHelper;
100 * The do_headers_action uses this kind of functions to perform some
101 * action to each member of a list of headers
103 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
106 do_headers_action (ModestWindow *win,
111 static void open_msg_func (const GObject *obj, const TnyMsg *msg, gpointer user_data);
113 static void reply_forward_func (const GObject *obj, const TnyMsg *msg, gpointer user_data);
115 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
117 static gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
120 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
123 const gchar *authors[] = {
124 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
127 about = gtk_about_dialog_new ();
128 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
129 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
130 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
131 _("Copyright (c) 2006, Nokia Corporation\n"
132 "All rights reserved."));
133 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
134 _("a modest e-mail client\n\n"
135 "design and implementation: Dirk-Jan C. Binnema\n"
136 "contributions from the fine people at KC and Ig\n"
137 "uses the tinymail email framework written by Philip van Hoof"));
138 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
139 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
141 gtk_dialog_run (GTK_DIALOG (about));
142 gtk_widget_destroy(about);
147 get_selected_headers (ModestWindow *win)
149 if (MODEST_IS_MAIN_WINDOW(win)) {
150 GtkWidget *header_view;
152 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
153 MODEST_WIDGET_TYPE_HEADER_VIEW);
154 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
156 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
157 /* for MsgViewWindows, we simply return a list with one element */
160 TnyList *list = NULL;
162 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
164 header = tny_msg_get_header (msg);
165 list = tny_simple_list_new ();
166 tny_list_prepend (list, G_OBJECT(header));
167 g_object_unref (G_OBJECT(header));
176 headers_action_delete (TnyHeader *header,
180 ModestMailOperation *mail_op;
182 /* TODO: add confirmation dialog */
183 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE, G_OBJECT(win));
184 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
187 /* Always delete. TODO: Move to trash still not supported */
188 modest_mail_operation_remove_msg (mail_op, header, FALSE);
189 g_object_unref (G_OBJECT (mail_op));
193 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
195 g_return_if_fail (MODEST_IS_WINDOW(win));
197 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
199 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
203 /* Remove each header */
204 do_headers_action (win, headers_action_delete, NULL);
206 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
207 gtk_widget_destroy (GTK_WIDGET(win));
213 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
215 #ifdef MODEST_PLATFORM_MAEMO
216 modest_osso_save_state();
217 #endif /* MODEST_PLATFORM_MAEMO */
223 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
225 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
226 gtk_widget_destroy (GTK_WIDGET (win));
227 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
229 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
230 } else if (MODEST_IS_WINDOW (win)) {
231 gtk_widget_destroy (GTK_WIDGET (win));
233 g_return_if_reached ();
238 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
240 GtkClipboard *clipboard = NULL;
241 gchar *selection = NULL;
243 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
244 selection = gtk_clipboard_wait_for_text (clipboard);
246 modest_address_book_add_address (selection);
251 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
254 /* This is currently only implemented for Maemo,
255 * because it requires a providers preset file which is not publically available.
257 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
258 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
259 TRUE /* enabled accounts only */);
260 gboolean accounts_exist = account_names != NULL;
261 g_slist_free (account_names);
263 if (!accounts_exist) {
264 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
265 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
266 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
267 gtk_dialog_run (GTK_DIALOG (wizard));
268 gtk_widget_destroy (GTK_WIDGET (wizard));
270 /* Show the list of accounts: */
271 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
272 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
273 gtk_dialog_run (account_win);
274 gtk_widget_destroy (GTK_WIDGET(account_win));
277 GtkWidget *dialog, *label;
279 /* Create the widgets */
281 dialog = gtk_dialog_new_with_buttons ("Message",
283 GTK_DIALOG_DESTROY_WITH_PARENT,
287 label = gtk_label_new ("Hello World!");
289 /* Ensure that the dialog box is destroyed when the user responds. */
291 g_signal_connect_swapped (dialog, "response",
292 G_CALLBACK (gtk_widget_destroy),
295 /* Add the label, and show everything we've added to the dialog. */
297 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
299 gtk_widget_show_all (dialog);
300 #endif /* MODEST_PLATFORM_MAEMO */
304 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
306 ModestWindow *msg_win;
308 TnyFolder *folder = NULL;
309 gchar *account_name = NULL;
310 gchar *from_str = NULL;
311 /* GError *err = NULL; */
312 TnyAccount *account = NULL;
313 ModestWindowMgr *mgr;
314 gchar *signature = NULL;
316 account_name = g_strdup(modest_window_get_active_account (win));
318 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
320 g_printerr ("modest: no account found\n");
324 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
326 TNY_ACCOUNT_TYPE_STORE);
328 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
332 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
334 g_printerr ("modest: failed get from string for '%s'\n", account_name);
338 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
339 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
340 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
341 MODEST_ACCOUNT_SIGNATURE, FALSE);
343 signature = g_strdup ("");
346 msg = modest_tny_msg_new ("", from_str, "", "", "", signature, NULL);
348 g_printerr ("modest: failed to create new msg\n");
352 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
354 g_printerr ("modest: failed to find Drafts folder\n");
358 /* tny_folder_add_msg (folder, msg, &err); */
360 /* g_printerr ("modest: error adding msg to Drafts folder: %s", */
362 /* g_error_free (err); */
366 /* Create and register edit window */
367 msg_win = modest_msg_edit_window_new (msg, account_name);
368 mgr = modest_runtime_get_window_mgr ();
369 modest_window_mgr_register_window (mgr, msg_win);
372 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
374 gtk_widget_show_all (GTK_WIDGET (msg_win));
377 g_free (account_name);
381 g_object_unref (G_OBJECT(account));
383 g_object_unref (G_OBJECT(msg));
385 g_object_unref (G_OBJECT(folder));
389 headers_action_open (TnyHeader *header,
393 modest_ui_actions_on_header_activated (MODEST_HEADER_VIEW (user_data),
395 MODEST_MAIN_WINDOW (win));
399 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
401 GtkWidget *header_view;
403 /* Get header view */
404 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
405 MODEST_WIDGET_TYPE_HEADER_VIEW);
407 /* Open each message */
408 do_headers_action (win, headers_action_open, header_view);
413 open_msg_func (const GObject *obj, const TnyMsg *msg, gpointer user_data)
415 ModestWindowMgr *mgr = NULL;
416 ModestWindow *parent_win = NULL;
417 ModestWindow *win = NULL;
418 HeaderActivatedHelper *helper = NULL;
419 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
420 gchar *account = NULL;
422 g_return_if_fail (MODEST_IS_WINDOW(obj));
423 g_return_if_fail (user_data != NULL);
424 parent_win = MODEST_WINDOW(obj);
425 helper = (HeaderActivatedHelper *) user_data;
428 account = g_strdup(modest_window_get_active_account(MODEST_WINDOW(parent_win)));
430 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
432 /* Gets foldert type (OUTBOX headers will be opened in edit window */
433 /* folder_type = modest_tny_folder_guess_folder_type (helper->folder); */
434 if (modest_tny_folder_is_local_folder (helper->folder))
435 folder_type = modest_tny_folder_get_local_folder_type (helper->folder);
437 switch (folder_type) {
438 case TNY_FOLDER_TYPE_DRAFTS:
439 win = modest_msg_edit_window_new ((TnyMsg *) msg, account);
442 if (helper->model != NULL)
443 win = modest_msg_view_window_new_with_header_model ((TnyMsg *) msg, account, helper->model, helper->iter);
445 win = modest_msg_view_window_new ((TnyMsg *) msg, account);
448 /* Register and show new window */
450 mgr = modest_runtime_get_window_mgr ();
451 modest_window_mgr_register_window (mgr, win);
452 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
453 gtk_widget_show_all (GTK_WIDGET(win));
458 /* g_object_unref (G_OBJECT(msg)); */
459 g_object_unref (G_OBJECT(helper->folder));
460 g_slice_free (HeaderActivatedHelper, helper);
464 reply_forward_func (const GObject *obj, const TnyMsg *msg, gpointer user_data)
467 ReplyForwardHelper *rf_helper;
468 ModestWindow *msg_win;
469 ModestEditType edit_type;
472 TnyFolder *folder = NULL;
473 TnyAccount *account = NULL;
474 ModestWindowMgr *mgr;
475 gchar *signature = NULL;
477 g_return_if_fail (user_data != NULL);
478 rf_helper = (ReplyForwardHelper *) user_data;
480 rf_helper->pending_ops--;
482 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
483 rf_helper->account_name);
484 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
485 rf_helper->account_name,
486 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
487 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
488 rf_helper->account_name,
489 MODEST_ACCOUNT_SIGNATURE, FALSE);
492 /* Create reply mail */
493 switch (rf_helper->action) {
496 modest_tny_msg_create_reply_msg ((TnyMsg *) msg, from, signature,
497 rf_helper->reply_forward_type,
498 MODEST_TNY_MSG_REPLY_MODE_SENDER);
500 case ACTION_REPLY_TO_ALL:
502 modest_tny_msg_create_reply_msg ((TnyMsg *) msg, from, signature, rf_helper->reply_forward_type,
503 MODEST_TNY_MSG_REPLY_MODE_ALL);
504 edit_type = MODEST_EDIT_TYPE_REPLY;
508 modest_tny_msg_create_forward_msg ((TnyMsg *) msg, from, signature, rf_helper->reply_forward_type);
509 edit_type = MODEST_EDIT_TYPE_FORWARD;
512 g_return_if_reached ();
519 g_printerr ("modest: failed to create message\n");
523 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
524 rf_helper->account_name,
525 TNY_ACCOUNT_TYPE_STORE);
527 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
531 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
533 g_printerr ("modest: failed to find Drafts folder\n");
537 tny_folder_add_msg (folder, (TnyMsg *) msg, &err);
539 g_printerr ("modest: error adding msg to Drafts folder: %s",
545 /* Create and register the windows */
546 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
547 mgr = modest_runtime_get_window_mgr ();
548 modest_window_mgr_register_window (mgr, msg_win);
550 /* Show edit window */
551 gtk_widget_show_all (GTK_WIDGET (msg_win));
555 g_object_unref (G_OBJECT (new_msg));
557 g_object_unref (G_OBJECT (folder));
559 g_object_unref (G_OBJECT (account));
561 if (rf_helper->pending_ops == 0) {
562 g_free (rf_helper->account_name);
563 g_slice_free (ReplyForwardHelper, rf_helper);
567 * Common code for the reply and forward actions
570 reply_forward (ReplyForwardAction action, ModestWindow *win)
572 ModestMailOperation *mail_op = NULL;
573 TnyList *header_list = NULL;
574 ReplyForwardHelper *rf_helper = NULL;
575 guint reply_forward_type;
577 g_return_if_fail (MODEST_IS_WINDOW(win));
579 header_list = get_selected_headers (win);
583 reply_forward_type = modest_conf_get_int (modest_runtime_get_conf (),
584 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
586 /* We assume that we can only select messages of the
587 same folder and that we reply all of them from the
588 same account. In fact the interface currently only
589 allows single selection */
592 rf_helper = g_slice_new0 (ReplyForwardHelper);
593 rf_helper->reply_forward_type = reply_forward_type;
594 rf_helper->action = action;
595 rf_helper->pending_ops = tny_list_get_length (header_list);
596 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
597 if (!rf_helper->account_name)
598 rf_helper->account_name =
599 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
601 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
603 msg = modest_msg_view_window_get_message(MODEST_MSG_VIEW_WINDOW(win));
605 g_printerr ("modest: no message found\n");
608 reply_forward_func (G_OBJECT(win), msg, rf_helper);
611 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
612 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
613 modest_mail_operation_process_msg (mail_op, header_list, reply_forward_func, rf_helper);
616 g_object_unref(mail_op);
621 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
623 g_return_if_fail (MODEST_IS_WINDOW(win));
625 reply_forward (ACTION_REPLY, win);
629 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
631 g_return_if_fail (MODEST_IS_WINDOW(win));
633 reply_forward (ACTION_FORWARD, win);
637 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
639 g_return_if_fail (MODEST_IS_WINDOW(win));
641 reply_forward (ACTION_REPLY_TO_ALL, win);
645 modest_ui_actions_on_next (GtkAction *action,
646 ModestWindow *window)
648 if (MODEST_IS_MAIN_WINDOW (window)) {
649 GtkWidget *header_view;
651 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
652 MODEST_WIDGET_TYPE_HEADER_VIEW);
656 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
657 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
658 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
660 g_return_if_reached ();
665 modest_ui_actions_on_prev (GtkAction *action,
666 ModestWindow *window)
668 g_return_if_fail (MODEST_IS_WINDOW(window));
670 if (MODEST_IS_MAIN_WINDOW (window)) {
671 GtkWidget *header_view;
672 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
673 MODEST_WIDGET_TYPE_HEADER_VIEW);
677 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
678 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
679 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
681 g_return_if_reached ();
686 modest_ui_actions_on_sort (GtkAction *action,
687 ModestWindow *window)
689 g_return_if_fail (MODEST_IS_WINDOW(window));
691 if (MODEST_IS_MAIN_WINDOW (window)) {
692 GtkWidget *header_view;
693 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
694 MODEST_WIDGET_TYPE_HEADER_VIEW);
698 /* Show sorting dialog */
699 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
705 action_send (const gchar* account_name)
707 TnyAccount *tny_account;
708 ModestTnySendQueue *send_queue;
710 g_return_val_if_fail (account_name, FALSE);
712 /* Get the transport account according to the open connection,
713 * because the account might specify connection-specific SMTP servers.
716 modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
719 g_printerr ("modest: cannot get tny transport account for %s\n", account_name);
723 send_queue = modest_tny_send_queue_new (TNY_CAMEL_TRANSPORT_ACCOUNT(tny_account));
725 g_object_unref (G_OBJECT(tny_account));
726 g_printerr ("modest: cannot get send queue for %s\n", account_name);
730 modest_tny_send_queue_flush (send_queue);
732 g_object_unref (G_OBJECT(send_queue));
733 g_object_unref (G_OBJECT(tny_account));
740 action_receive (const gchar* account_name,
743 TnyAccount *tny_account;
744 ModestMailOperation *mail_op;
746 g_return_val_if_fail (account_name, FALSE);
749 modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
751 TNY_ACCOUNT_TYPE_STORE);
753 g_printerr ("modest: cannot get tny store account for %s\n", account_name);
757 /* Create the mail operation */
758 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
759 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
760 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
761 modest_mail_operation_update_account (mail_op, TNY_STORE_ACCOUNT(tny_account));
763 g_object_unref (G_OBJECT(tny_account));
764 g_object_unref (G_OBJECT (mail_op));
769 /** Check that an appropriate connection is open.
771 gboolean check_for_connection (const gchar *account_name)
773 TnyDevice *device = modest_runtime_get_device ();
776 g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
778 TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);
781 if (tny_device_is_online (device))
784 modest_platform_connect_and_wait (NULL);
786 /* TODO: Wait until a result. */
792 do_send_receive_current_or_default (ModestWindow *win)
796 g_message ("%s: online? %s", __FUNCTION__,
797 tny_device_is_online(modest_runtime_get_device()) ? "yes":"no");
799 /* As per the UI spec, only the active account should be affected,
800 * else the default folder if there is no active account: */
802 g_strdup(modest_window_get_active_account(MODEST_WINDOW(win)));
804 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
806 g_printerr ("modest: cannot get default account\n");
810 /* Do not continue if no suitable connection is open: */
811 if (check_for_connection (account_name)) {
812 /* As per the UI spec,
813 * for POP accounts, we should receive,
814 * for IMAP we should synchronize everything, including receiving,
815 * for SMTP we should send,
816 * first receiving, then sending:
818 if (!action_receive(account_name, win))
819 g_printerr ("modest: failed to receive\n");
820 if (!action_send(account_name))
821 g_printerr ("modest: failed to send\n");
823 g_free (account_name);
829 do_send_receive_auto (ModestWindow *win)
831 g_message ("%s: online? %s", __FUNCTION__,
832 tny_device_is_online(modest_runtime_get_device()) ? "yes":"no");
834 /* TODO: Delete the item->data strings as well as the list? */
835 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
836 TRUE /* enabled accounts only */);
837 GSList *iter = account_names;
839 const gchar * account_name = (const char*) iter->data;
841 /* Do not continue if no suitable connection is open: */
842 if (account_name && check_for_connection (account_name)) {
843 /* As per the UI spec,
844 * for POP accounts, we should receive,
845 * for IMAP we should synchronize everything, including receiving,
846 * for SMTP we should send,
847 * first receiving, then sending:
849 if (!action_receive(account_name, win))
850 g_printerr ("modest: failed to receive for account %s\n", account_name);
851 if (!action_send(account_name))
852 g_printerr ("modest: failed to send for account %s\n", account_name);
857 g_slist_free (account_names);
861 do_send_receive (ModestWindow *win)
863 const gboolean auto_update = TRUE; /* TODO: Get gconf setting. */
865 do_send_receive_current_or_default (win);
867 do_send_receive_auto (win);
871 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
873 /* Check that at least one account exists: */
874 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
875 TRUE /* enabled accounts only */);
876 gboolean accounts_exist = account_names != NULL;
877 g_slist_free (account_names);
879 /* If not, allow the user to create an account before trying to send/receive. */
880 if (!accounts_exist) {
881 modest_ui_actions_on_accounts (NULL, win);
884 do_send_receive (win);
891 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
894 GtkWidget *header_view;
896 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
898 header_view = modest_main_window_get_child_widget (main_window,
899 MODEST_WIDGET_TYPE_HEADER_VIEW);
903 conf = modest_runtime_get_conf ();
905 /* what is saved/restored is depending on the style; thus; we save with
906 * old style, then update the style, and restore for this new style
908 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
910 if (modest_header_view_get_style
911 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
912 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
913 MODEST_HEADER_VIEW_STYLE_TWOLINES);
915 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
916 MODEST_HEADER_VIEW_STYLE_DETAILS);
918 modest_widget_memory_restore (conf, G_OBJECT(header_view),
919 MODEST_CONF_HEADER_VIEW_KEY);
924 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
926 ModestMainWindow *main_window)
928 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
930 /* If no header has been selected then exit */
934 /* Update Main window title */
935 if (GTK_WIDGET_HAS_FOCUS (header_view)) {
936 const gchar *subject = tny_header_get_subject (header);
937 if (subject && strcmp (subject, ""))
938 gtk_window_set_title (GTK_WINDOW (main_window), subject);
940 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
947 /* modest_ui_actions_on_header_activated (ModestHeaderView *header_view, TnyHeader *header, */
948 /* ModestMainWindow *main_window) */
950 /* ModestWindow *win = NULL; */
951 /* TnyFolder *folder = NULL; */
952 /* TnyMsg *msg = NULL; */
953 /* TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN; */
954 /* ModestWindowMgr *mgr; */
955 /* GtkTreeModel *model; */
956 /* GtkTreeIter iter; */
957 /* GtkTreeSelection *sel = NULL; */
958 /* GList *sel_list = NULL; */
960 /* g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window)); */
965 /* folder = tny_header_get_folder (header); */
967 /* g_printerr ("modest: cannot get folder for header\n"); */
970 /* if (modest_tny_folder_is_local_folder (folder)) */
971 /* folder_type = modest_tny_folder_get_local_folder_type (folder); */
973 /* /\* FIXME: make async?; check error *\/ */
974 /* msg = tny_folder_get_msg (folder, header, NULL); */
976 /* g_printerr ("modest: cannot get msg for header\n"); */
980 /* /\* Look if we already have a message view for that header *\/ */
981 /* mgr = modest_runtime_get_window_mgr (); */
982 /* win = modest_window_mgr_find_window_by_msguid (mgr, tny_header_get_uid (header)); */
984 /* /\* If not, create a new window *\/ */
986 /* gchar *account; */
988 /* account = g_strdup(modest_window_get_active_account(MODEST_WINDOW(main_window))); */
990 /* account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr()); */
992 /* sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view)); */
993 /* sel_list = gtk_tree_selection_get_selected_rows (sel, &model); */
994 /* if (sel_list != NULL) { */
995 /* gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) sel_list->data); */
997 /* switch (folder_type) { */
998 /* case TNY_FOLDER_TYPE_DRAFTS: */
999 /* win = modest_msg_edit_window_new (msg, account); */
1002 /* win = modest_msg_view_window_new_with_header_model (msg, account, model, iter); */
1005 /* g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL); */
1006 /* g_list_free (sel_list); */
1008 /* win = modest_msg_view_window_new (msg, account); */
1010 /* modest_window_mgr_register_window (mgr, win); */
1012 /* gtk_window_set_transient_for (GTK_WINDOW (win), */
1013 /* GTK_WINDOW (main_window)); */
1016 /* gtk_widget_show_all (GTK_WIDGET(win)); */
1018 /* g_object_unref (G_OBJECT (msg)); */
1021 /* g_object_unref (G_OBJECT (folder)); */
1025 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1027 ModestMainWindow *main_window)
1029 ModestMailOperation *mail_op = NULL;
1030 HeaderActivatedHelper *helper = NULL;
1031 ModestWindowMgr *mgr = NULL;
1032 ModestWindow *win = NULL;
1033 GtkTreeModel *model = NULL;
1035 GtkTreeSelection *sel = NULL;
1036 GList *sel_list = NULL;
1038 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1043 /* Look if we already have a message view for that header */
1044 mgr = modest_runtime_get_window_mgr ();
1045 win = modest_window_mgr_find_window_by_msguid (mgr, tny_header_get_uid (header));
1049 helper = g_slice_new0 (HeaderActivatedHelper);
1050 helper->folder = tny_header_get_folder (header);
1051 helper->model = NULL;
1053 /* Get headers tree model and selected iter to build message view */
1054 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
1055 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
1056 if (sel_list != NULL) {
1057 gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) sel_list->data);
1060 helper->model = model;
1061 helper->iter = iter;
1063 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
1064 g_list_free (sel_list);
1067 /* New mail operation */
1068 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(main_window));
1069 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1070 modest_mail_operation_get_msg (mail_op, header, open_msg_func, helper);
1073 g_object_unref (mail_op);
1077 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1078 TnyFolderStore *folder_store,
1080 ModestMainWindow *main_window)
1083 GtkWidget *header_view;
1085 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1087 header_view = modest_main_window_get_child_widget(main_window,
1088 MODEST_WIDGET_TYPE_HEADER_VIEW);
1092 conf = modest_runtime_get_conf ();
1094 if (TNY_IS_FOLDER (folder_store)) {
1096 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1099 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1100 TNY_FOLDER (folder_store));
1101 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1102 MODEST_CONF_HEADER_VIEW_KEY);
1104 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1105 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
1107 } else if (TNY_IS_ACCOUNT (folder_store)) {
1109 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1114 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1121 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1123 if (g_main_depth > 0)
1124 gdk_threads_enter ();
1125 online = tny_device_is_online (modest_runtime_get_device());
1128 /* already online -- the item is simply not there... */
1129 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1131 GTK_MESSAGE_WARNING,
1133 _("The %s you selected cannot be found"),
1135 gtk_dialog_run (GTK_DIALOG(dialog));
1137 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1141 GTK_RESPONSE_REJECT,
1143 GTK_RESPONSE_ACCEPT,
1145 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1146 "Do you want to get online?"), item);
1147 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1148 gtk_label_new (txt), FALSE, FALSE, 0);
1149 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1152 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1153 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1154 // modest_platform_connect_and_wait ();;
1157 gtk_widget_destroy (dialog);
1158 if (g_main_depth > 0)
1159 gdk_threads_leave ();
1163 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1166 g_message ("%s %s", __FUNCTION__, link);
1171 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1174 modest_platform_activate_uri (link);
1178 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1181 modest_platform_show_uri_popup (link);
1185 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1188 g_message (__FUNCTION__);
1193 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1194 const gchar *address,
1197 g_message ("%s %s", __FUNCTION__, address);
1201 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1203 TnyTransportAccount *transport_account;
1204 ModestMailOperation *mail_operation;
1206 gchar *account_name, *from;
1207 ModestAccountMgr *account_mgr;
1209 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1211 data = modest_msg_edit_window_get_msg_data (edit_window);
1213 account_mgr = modest_runtime_get_account_mgr();
1214 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1216 account_name = modest_account_mgr_get_default_account (account_mgr);
1217 if (!account_name) {
1218 g_printerr ("modest: no account found\n");
1219 modest_msg_edit_window_free_msg_data (edit_window, data);
1223 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
1224 (modest_runtime_get_account_store(),
1226 TNY_ACCOUNT_TYPE_TRANSPORT));
1227 if (!transport_account) {
1228 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1229 g_free (account_name);
1230 modest_msg_edit_window_free_msg_data (edit_window, data);
1233 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1235 /* Create the mail operation */
1236 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(edit_window));
1237 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1239 modest_mail_operation_save_to_drafts (mail_operation,
1249 data->priority_flags);
1252 g_free (account_name);
1253 g_object_unref (G_OBJECT (transport_account));
1254 g_object_unref (G_OBJECT (mail_operation));
1256 modest_msg_edit_window_free_msg_data (edit_window, data);
1258 /* Save settings and close the window */
1259 gtk_widget_destroy (GTK_WIDGET (edit_window));
1262 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1264 TnyTransportAccount *transport_account;
1265 ModestMailOperation *mail_operation;
1267 gchar *account_name, *from;
1268 ModestAccountMgr *account_mgr;
1270 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1272 if (!modest_msg_edit_window_check_names (edit_window))
1275 data = modest_msg_edit_window_get_msg_data (edit_window);
1277 /* FIXME: Code added just for testing. The final version will
1278 use the send queue provided by tinymail and some
1280 account_mgr = modest_runtime_get_account_mgr();
1281 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1283 account_name = modest_account_mgr_get_default_account (account_mgr);
1284 if (!account_name) {
1285 g_printerr ("modest: no account found\n");
1286 modest_msg_edit_window_free_msg_data (edit_window, data);
1290 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1291 (modest_runtime_get_account_store(),
1293 if (!transport_account) {
1294 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1295 g_free (account_name);
1296 modest_msg_edit_window_free_msg_data (edit_window, data);
1299 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1301 /* Create the mail operation */
1302 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_SEND, G_OBJECT(edit_window));
1303 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1305 modest_mail_operation_send_new_mail (mail_operation,
1315 data->priority_flags);
1318 g_free (account_name);
1319 g_object_unref (G_OBJECT (transport_account));
1320 g_object_unref (G_OBJECT (mail_operation));
1322 modest_msg_edit_window_free_msg_data (edit_window, data);
1324 /* Save settings and close the window */
1325 gtk_widget_destroy (GTK_WIDGET (edit_window));
1329 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1330 ModestMsgEditWindow *window)
1332 ModestMsgEditFormatState *format_state = NULL;
1334 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1335 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1337 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1340 format_state = modest_msg_edit_window_get_format_state (window);
1341 g_return_if_fail (format_state != NULL);
1343 format_state->bold = gtk_toggle_action_get_active (action);
1344 modest_msg_edit_window_set_format_state (window, format_state);
1345 g_free (format_state);
1350 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1351 ModestMsgEditWindow *window)
1353 ModestMsgEditFormatState *format_state = NULL;
1355 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1356 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1358 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1361 format_state = modest_msg_edit_window_get_format_state (window);
1362 g_return_if_fail (format_state != NULL);
1364 format_state->italics = gtk_toggle_action_get_active (action);
1365 modest_msg_edit_window_set_format_state (window, format_state);
1366 g_free (format_state);
1371 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1372 ModestMsgEditWindow *window)
1374 ModestMsgEditFormatState *format_state = NULL;
1376 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1377 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1379 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1382 format_state = modest_msg_edit_window_get_format_state (window);
1383 g_return_if_fail (format_state != NULL);
1385 format_state->bullet = gtk_toggle_action_get_active (action);
1386 modest_msg_edit_window_set_format_state (window, format_state);
1387 g_free (format_state);
1392 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1393 GtkRadioAction *selected,
1394 ModestMsgEditWindow *window)
1396 ModestMsgEditFormatState *format_state = NULL;
1397 GtkJustification value;
1399 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1401 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1404 value = gtk_radio_action_get_current_value (selected);
1406 format_state = modest_msg_edit_window_get_format_state (window);
1407 g_return_if_fail (format_state != NULL);
1409 format_state->justification = value;
1410 modest_msg_edit_window_set_format_state (window, format_state);
1411 g_free (format_state);
1415 modest_ui_actions_on_select_editor_color (GtkAction *action,
1416 ModestMsgEditWindow *window)
1418 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1419 g_return_if_fail (GTK_IS_ACTION (action));
1421 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1424 modest_msg_edit_window_select_color (window);
1428 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1429 ModestMsgEditWindow *window)
1431 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1432 g_return_if_fail (GTK_IS_ACTION (action));
1434 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1437 modest_msg_edit_window_select_background_color (window);
1441 modest_ui_actions_on_insert_image (GtkAction *action,
1442 ModestMsgEditWindow *window)
1444 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1445 g_return_if_fail (GTK_IS_ACTION (action));
1447 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1450 modest_msg_edit_window_insert_image (window);
1454 * Shows a dialog with an entry that asks for some text. The returned
1455 * value must be freed by the caller. The dialog window title will be
1459 ask_for_folder_name (GtkWindow *parent_window,
1462 GtkWidget *dialog, *entry;
1463 gchar *folder_name = NULL;
1465 /* Ask for folder name */
1466 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1470 GTK_RESPONSE_REJECT,
1472 GTK_RESPONSE_ACCEPT,
1474 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1475 gtk_label_new(title),
1478 entry = gtk_entry_new_with_max_length (40);
1479 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1483 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1485 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1486 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1488 gtk_widget_destroy (dialog);
1494 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1496 TnyFolderStore *parent_folder;
1497 GtkWidget *folder_view;
1499 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1501 folder_view = modest_main_window_get_child_widget (main_window,
1502 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1506 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1508 if (parent_folder) {
1509 gboolean finished = FALSE;
1511 gchar *folder_name = NULL, *suggested_name = NULL;
1513 /* Run the new folder dialog */
1515 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1520 if (result == GTK_RESPONSE_REJECT) {
1523 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1524 TnyFolder *new_folder = NULL;
1526 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1529 new_folder = modest_mail_operation_create_folder (mail_op,
1531 (const gchar *) folder_name);
1533 g_object_unref (new_folder);
1537 /* /\* TODO: check error and follow proper actions *\/ */
1538 /* /\* suggested_name = X; *\/ */
1539 /* /\* Show error to the user *\/ */
1540 /* modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1541 /* MODEST_INFORMATION_CREATE_FOLDER); */
1543 g_object_unref (mail_op);
1545 g_free (folder_name);
1549 g_object_unref (parent_folder);
1554 modest_ui_actions_on_rename_folder (GtkAction *action,
1555 ModestMainWindow *main_window)
1557 TnyFolderStore *folder;
1558 GtkWidget *folder_view;
1560 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1562 folder_view = modest_main_window_get_child_widget (main_window,
1563 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1567 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1569 if (folder && TNY_IS_FOLDER (folder)) {
1571 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1572 _("Please enter a new name for the folder"));
1574 if (folder_name != NULL && strlen (folder_name) > 0) {
1575 ModestMailOperation *mail_op;
1577 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1578 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1581 modest_mail_operation_rename_folder (mail_op,
1582 TNY_FOLDER (folder),
1583 (const gchar *) folder_name);
1585 g_object_unref (mail_op);
1586 g_free (folder_name);
1588 g_object_unref (folder);
1593 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1595 TnyFolderStore *folder;
1596 GtkWidget *folder_view;
1600 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1602 folder_view = modest_main_window_get_child_widget (main_window,
1603 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1607 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1610 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1611 tny_folder_get_name (TNY_FOLDER (folder)));
1612 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1613 (const gchar *) message);
1616 if (response == GTK_RESPONSE_OK) {
1617 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE, G_OBJECT(main_window));
1619 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1621 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1623 /* Show error if happened */
1624 if (modest_mail_operation_get_error (mail_op))
1625 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1626 MODEST_INFORMATION_DELETE_FOLDER);
1628 g_object_unref (G_OBJECT (mail_op));
1631 g_object_unref (G_OBJECT (folder));
1635 modest_ui_actions_on_delete_folder (GtkAction *action,
1636 ModestMainWindow *main_window)
1638 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1640 delete_folder (main_window, FALSE);
1644 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1646 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1648 delete_folder (main_window, TRUE);
1652 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1653 const gchar* account_name,
1657 ModestMainWindow *main_window)
1660 GtkWidget *dialog, *entry, *remember_pass_check;
1662 dialog = gtk_dialog_new_with_buttons (_("Password requested"),
1666 GTK_RESPONSE_REJECT,
1668 GTK_RESPONSE_ACCEPT,
1670 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1672 txt = g_strdup_printf (_("Please enter your password for %s"), account_name);
1673 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1677 entry = gtk_entry_new_with_max_length (40);
1678 gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
1679 gtk_entry_set_invisible_char (GTK_ENTRY(entry), 0x2022); /* bullet unichar */
1681 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry,
1684 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1685 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1688 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1690 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1691 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry)));
1698 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1703 gtk_widget_destroy (dialog);
1707 modest_ui_actions_on_cut (GtkAction *action,
1708 ModestWindow *window)
1710 GtkWidget *focused_widget;
1712 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1713 if (GTK_IS_EDITABLE (focused_widget)) {
1714 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1715 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1716 GtkTextBuffer *buffer;
1717 GtkClipboard *clipboard;
1719 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1720 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1721 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1726 modest_ui_actions_on_copy (GtkAction *action,
1727 ModestWindow *window)
1729 GtkClipboard *clipboard;
1730 GtkWidget *focused_widget;
1732 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1733 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1734 if (GTK_IS_LABEL (focused_widget)) {
1735 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1736 } else if (GTK_IS_EDITABLE (focused_widget)) {
1737 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1738 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1739 GtkTextBuffer *buffer;
1741 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1742 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1747 modest_ui_actions_on_undo (GtkAction *action,
1748 ModestWindow *window)
1750 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1751 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1753 g_return_if_reached ();
1758 modest_ui_actions_on_paste (GtkAction *action,
1759 ModestWindow *window)
1761 GtkWidget *focused_widget;
1763 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1764 if (GTK_IS_EDITABLE (focused_widget)) {
1765 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1766 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1767 GtkTextBuffer *buffer;
1768 GtkClipboard *clipboard;
1770 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1771 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1772 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1777 modest_ui_actions_on_select_all (GtkAction *action,
1778 ModestWindow *window)
1780 GtkWidget *focused_widget;
1782 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1783 if (GTK_IS_LABEL (focused_widget)) {
1784 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1785 } else if (GTK_IS_EDITABLE (focused_widget)) {
1786 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1787 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1788 GtkTextBuffer *buffer;
1789 GtkTextIter start, end;
1791 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1792 gtk_text_buffer_get_start_iter (buffer, &start);
1793 gtk_text_buffer_get_end_iter (buffer, &end);
1794 gtk_text_buffer_select_range (buffer, &start, &end);
1799 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
1800 GtkRadioAction *selected,
1801 ModestWindow *window)
1805 value = gtk_radio_action_get_current_value (selected);
1806 if (MODEST_IS_WINDOW (window)) {
1807 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
1811 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
1812 GtkRadioAction *selected,
1813 ModestWindow *window)
1815 TnyHeaderFlags flags;
1816 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1818 flags = gtk_radio_action_get_current_value (selected);
1819 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
1822 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
1823 GtkRadioAction *selected,
1824 ModestWindow *window)
1828 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1830 file_format = gtk_radio_action_get_current_value (selected);
1831 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
1836 modest_ui_actions_on_zoom_plus (GtkAction *action,
1837 ModestWindow *window)
1839 g_return_if_fail (MODEST_IS_WINDOW (window));
1841 modest_window_zoom_plus (MODEST_WINDOW (window));
1845 modest_ui_actions_on_zoom_minus (GtkAction *action,
1846 ModestWindow *window)
1848 g_return_if_fail (MODEST_IS_WINDOW (window));
1850 modest_window_zoom_minus (MODEST_WINDOW (window));
1854 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
1855 ModestWindow *window)
1857 ModestWindowMgr *mgr;
1858 gboolean fullscreen, active;
1859 g_return_if_fail (MODEST_IS_WINDOW (window));
1861 mgr = modest_runtime_get_window_mgr ();
1863 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
1864 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1866 if (active != fullscreen) {
1867 modest_window_mgr_set_fullscreen_mode (mgr, active);
1868 gtk_window_present (GTK_WINDOW (window));
1873 modest_ui_actions_on_change_fullscreen (GtkAction *action,
1874 ModestWindow *window)
1876 ModestWindowMgr *mgr;
1877 gboolean fullscreen;
1879 g_return_if_fail (MODEST_IS_WINDOW (window));
1881 mgr = modest_runtime_get_window_mgr ();
1882 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1883 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
1885 gtk_window_present (GTK_WINDOW (window));
1889 * Used by modest_ui_actions_on_details to call do_headers_action
1892 headers_action_show_details (TnyHeader *header,
1893 ModestWindow *window,
1900 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
1903 gtk_widget_show_all (dialog);
1904 gtk_dialog_run (GTK_DIALOG (dialog));
1906 gtk_widget_destroy (dialog);
1910 * Show the folder details in a ModestDetailsDialog widget
1913 show_folder_details (TnyFolder *folder,
1919 dialog = modest_details_dialog_new_with_folder (window, folder);
1922 gtk_widget_show_all (dialog);
1923 gtk_dialog_run (GTK_DIALOG (dialog));
1925 gtk_widget_destroy (dialog);
1929 * Show the header details in a ModestDetailsDialog widget
1932 modest_ui_actions_on_details (GtkAction *action,
1935 TnyList * headers_list;
1939 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1942 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1946 headers_list = get_selected_headers (win);
1950 iter = tny_list_create_iterator (headers_list);
1952 header = TNY_HEADER (tny_iterator_get_current (iter));
1953 headers_action_show_details (header, win, NULL);
1954 g_object_unref (header);
1956 g_object_unref (iter);
1958 } else if (MODEST_IS_MAIN_WINDOW (win)) {
1959 GtkWidget *folder_view, *header_view;
1961 /* Check which widget has the focus */
1962 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1963 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1964 if (gtk_widget_is_focus (folder_view)) {
1967 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1969 /* Show only when it's a folder */
1970 if (!folder || !TNY_IS_FOLDER (folder))
1973 show_folder_details (folder, GTK_WINDOW (win));
1976 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1977 MODEST_WIDGET_TYPE_HEADER_VIEW);
1978 /* Show details of each header */
1979 do_headers_action (win, headers_action_show_details, header_view);
1985 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
1986 ModestMsgEditWindow *window)
1988 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1990 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
1994 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
1995 ModestMsgEditWindow *window)
1997 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1999 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2003 modest_ui_actions_toggle_folders_view (GtkAction *action,
2004 ModestMainWindow *main_window)
2008 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2010 conf = modest_runtime_get_conf ();
2012 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2013 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2015 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2019 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2020 ModestWindow *window)
2022 gboolean active, fullscreen = FALSE;
2023 ModestWindowMgr *mgr;
2025 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2027 /* Check if we want to toggle the toolbar vuew in fullscreen
2029 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2030 "ViewShowToolbarFullScreen")) {
2034 /* Toggle toolbar */
2035 mgr = modest_runtime_get_window_mgr ();
2036 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2040 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2041 ModestMsgEditWindow *window)
2043 modest_msg_edit_window_select_font (window);
2047 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2048 const gchar *display_name,
2051 /* Do not change the application name if the widget has not
2052 the focus. This callback could be called even if the folder
2053 view has not the focus, because the handled signal could be
2054 emitted when the folder view is redrawn */
2055 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2057 gtk_window_set_title (window, display_name);
2059 gtk_window_set_title (window, " ");
2064 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2066 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2067 modest_msg_edit_window_select_contacts (window);
2071 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2073 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2074 modest_msg_edit_window_check_names (window);
2079 create_move_to_dialog (ModestWindow *win,
2080 GtkWidget *folder_view,
2081 GtkWidget **tree_view)
2083 GtkWidget *dialog, *scroll;
2085 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2087 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2089 GTK_RESPONSE_ACCEPT,
2091 GTK_RESPONSE_REJECT,
2094 /* Create scrolled window */
2095 scroll = gtk_scrolled_window_new (NULL, NULL);
2096 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2097 GTK_POLICY_AUTOMATIC,
2098 GTK_POLICY_AUTOMATIC);
2100 /* Create folder view */
2101 *tree_view = modest_folder_view_new (NULL);
2102 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2103 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2104 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2106 /* Add scroll to dialog */
2107 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2108 scroll, FALSE, FALSE, 0);
2110 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2116 * Returns TRUE if at least one of the headers of the list belongs to
2117 * a message that has been fully retrieved.
2120 has_retrieved_msgs (TnyList *list)
2123 gboolean found = FALSE;
2125 iter = tny_list_create_iterator (list);
2126 while (tny_iterator_is_done (iter) && !found) {
2128 TnyHeaderFlags flags;
2130 header = TNY_HEADER (tny_iterator_get_current (iter));
2131 flags = tny_header_get_flags (header);
2132 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2136 tny_iterator_next (iter);
2138 g_object_unref (iter);
2144 * Shows a confirmation dialog to the user when we're moving messages
2145 * from a remote server to the local storage. Returns the dialog
2146 * response. If it's other kind of movement the it always returns
2150 msgs_move_to_confirmation (GtkWindow *win,
2151 TnyFolder *dest_folder,
2154 gint response = GTK_RESPONSE_OK;
2156 /* If the destination is a local folder */
2157 if (modest_tny_folder_is_local_folder (dest_folder)) {
2158 TnyFolder *src_folder;
2162 /* Get source folder */
2163 iter = tny_list_create_iterator (headers);
2164 header = TNY_HEADER (tny_iterator_get_current (iter));
2165 src_folder = tny_header_get_folder (header);
2166 g_object_unref (header);
2167 g_object_unref (iter);
2169 /* If the source is a remote folder */
2170 if (!modest_tny_folder_is_local_folder (src_folder)) {
2171 const gchar *message;
2173 if (tny_list_get_length (headers) == 1)
2174 if (has_retrieved_msgs (headers))
2175 message = _("mcen_nc_move_retrieve");
2177 message = _("mcen_nc_move_header");
2179 if (has_retrieved_msgs (headers))
2180 message = _("mcen_nc_move_retrieves");
2182 message = _("mcen_nc_move_headers");
2184 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2185 (const gchar *) message);
2192 * UI handler for the "Move to" action when invoked from the
2196 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2197 ModestMainWindow *win)
2199 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2201 TnyFolderStore *folder_store;
2202 ModestMailOperation *mail_op = NULL;
2204 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2206 /* Get the folder view */
2207 folder_view = modest_main_window_get_child_widget (win,
2208 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2210 /* Create and run the dialog */
2211 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2212 result = gtk_dialog_run (GTK_DIALOG(dialog));
2214 /* We do this to save an indentation level ;-) */
2215 if (result != GTK_RESPONSE_ACCEPT)
2218 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2220 if (TNY_IS_ACCOUNT (folder_store))
2223 /* Get folder or messages to transfer */
2224 if (gtk_widget_is_focus (folder_view)) {
2225 TnyFolderStore *src_folder;
2226 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2228 if (TNY_IS_FOLDER (src_folder)) {
2229 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2230 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2233 modest_mail_operation_xfer_folder (mail_op,
2234 TNY_FOLDER (src_folder),
2237 g_object_unref (G_OBJECT (mail_op));
2241 g_object_unref (G_OBJECT (src_folder));
2243 GtkWidget *header_view;
2244 header_view = modest_main_window_get_child_widget (win,
2245 MODEST_WIDGET_TYPE_HEADER_VIEW);
2246 if (gtk_widget_is_focus (header_view)) {
2250 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2252 /* Ask for user confirmation */
2253 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2254 TNY_FOLDER (folder_store),
2257 /* Transfer messages */
2258 if (response == GTK_RESPONSE_OK) {
2259 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2260 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2263 modest_mail_operation_xfer_msgs (mail_op,
2265 TNY_FOLDER (folder_store),
2267 g_object_unref (G_OBJECT (mail_op));
2271 g_object_unref (folder_store);
2274 gtk_widget_destroy (dialog);
2279 * UI handler for the "Move to" action when invoked from the
2280 * ModestMsgViewWindow
2283 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2284 ModestMsgViewWindow *win)
2286 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2288 ModestMainWindow *main_window;
2293 /* Get the folder view */
2294 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2295 folder_view = modest_main_window_get_child_widget (main_window,
2296 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2298 /* Create and run the dialog */
2299 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2300 result = gtk_dialog_run (GTK_DIALOG(dialog));
2302 if (result == GTK_RESPONSE_ACCEPT) {
2303 TnyFolderStore *folder_store;
2306 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2308 /* Create header list */
2309 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2310 header = tny_msg_get_header (msg);
2311 headers = tny_simple_list_new ();
2312 tny_list_prepend (headers, G_OBJECT (header));
2313 g_object_unref (header);
2314 g_object_unref (msg);
2316 /* Ask user for confirmation. MSG-NOT404 */
2317 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2318 TNY_FOLDER (folder_store),
2321 /* Transfer current msg */
2322 if (response == GTK_RESPONSE_OK) {
2323 ModestMailOperation *mail_op;
2325 /* Create mail op */
2326 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2327 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2330 /* Transfer messages */
2331 modest_mail_operation_xfer_msgs (mail_op,
2333 TNY_FOLDER (folder_store),
2335 g_object_unref (G_OBJECT (mail_op));
2337 g_object_unref (headers);
2339 g_object_unref (folder_store);
2341 gtk_widget_destroy (dialog);
2345 modest_ui_actions_on_move_to (GtkAction *action,
2348 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2349 MODEST_IS_MSG_VIEW_WINDOW (win));
2351 if (MODEST_IS_MAIN_WINDOW (win))
2352 modest_ui_actions_on_main_window_move_to (action,
2353 MODEST_MAIN_WINDOW (win));
2355 modest_ui_actions_on_msg_view_window_move_to (action,
2356 MODEST_MSG_VIEW_WINDOW (win));
2360 * Calls #HeadersFunc for each header already selected in the main
2361 * window or the message currently being shown in the msg view window
2364 do_headers_action (ModestWindow *win,
2368 TnyList *headers_list;
2372 headers_list = get_selected_headers (win);
2376 /* Call the function for each header */
2377 iter = tny_list_create_iterator (headers_list);
2378 while (!tny_iterator_is_done (iter)) {
2381 header = TNY_HEADER (tny_iterator_get_current (iter));
2382 func (header, win, user_data);
2383 g_object_unref (header);
2384 tny_iterator_next (iter);
2386 g_object_unref (iter);