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 */
51 #include "widgets/modest-ui-constants.h"
52 #include <widgets/modest-main-window.h>
53 #include <widgets/modest-msg-view-window.h>
54 #include <widgets/modest-account-view-window.h>
55 #include <widgets/modest-details-dialog.h>
56 #include <widgets/modest-attachments-view.h>
57 #include "widgets/modest-global-settings-dialog.h"
58 #include "modest-account-mgr-helpers.h"
59 #include "modest-mail-operation.h"
60 #include "modest-text-utils.h"
62 #ifdef MODEST_HAVE_EASYSETUP
63 #include "easysetup/modest-easysetup-wizard.h"
64 #endif /* MODEST_HAVE_EASYSETUP */
66 #include <modest-widget-memory.h>
67 #include <tny-error.h>
68 #include <tny-simple-list.h>
69 #include <tny-msg-view.h>
70 #include <tny-device.h>
72 typedef struct _GetMsgAsyncHelper {
74 ModestMailOperation *mail_op;
81 typedef enum _ReplyForwardAction {
87 typedef struct _ReplyForwardHelper {
88 guint reply_forward_type;
89 ReplyForwardAction action;
94 typedef struct _HeaderActivatedHelper {
98 } HeaderActivatedHelper;
101 * The do_headers_action uses this kind of functions to perform some
102 * action to each member of a list of headers
104 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
107 do_headers_action (ModestWindow *win,
112 static void open_msg_func (const GObject *obj, const TnyMsg *msg, gpointer user_data);
114 static void reply_forward_func (const GObject *obj, const TnyMsg *msg, gpointer user_data);
116 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
118 static gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
121 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
124 const gchar *authors[] = {
125 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
128 about = gtk_about_dialog_new ();
129 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
130 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
131 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
132 _("Copyright (c) 2006, Nokia Corporation\n"
133 "All rights reserved."));
134 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
135 _("a modest e-mail client\n\n"
136 "design and implementation: Dirk-Jan C. Binnema\n"
137 "contributions from the fine people at KC and Ig\n"
138 "uses the tinymail email framework written by Philip van Hoof"));
139 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
140 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
142 gtk_dialog_run (GTK_DIALOG (about));
143 gtk_widget_destroy(about);
148 get_selected_headers (ModestWindow *win)
150 if (MODEST_IS_MAIN_WINDOW(win)) {
151 GtkWidget *header_view;
153 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
154 MODEST_WIDGET_TYPE_HEADER_VIEW);
155 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
157 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
158 /* for MsgViewWindows, we simply return a list with one element */
161 TnyList *list = NULL;
163 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
165 header = tny_msg_get_header (msg);
166 list = tny_simple_list_new ();
167 tny_list_prepend (list, G_OBJECT(header));
168 g_object_unref (G_OBJECT(header));
177 headers_action_delete (TnyHeader *header,
181 ModestMailOperation *mail_op;
183 /* TODO: add confirmation dialog */
184 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE, G_OBJECT(win));
185 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
188 /* Always delete. TODO: Move to trash still not supported */
189 modest_mail_operation_remove_msg (mail_op, header, FALSE);
190 g_object_unref (G_OBJECT (mail_op));
194 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
196 g_return_if_fail (MODEST_IS_WINDOW(win));
198 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
200 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
204 /* Remove each header */
205 do_headers_action (win, headers_action_delete, NULL);
207 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
208 gtk_widget_destroy (GTK_WIDGET(win));
214 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
216 #ifdef MODEST_PLATFORM_MAEMO
217 modest_osso_save_state();
218 #endif /* MODEST_PLATFORM_MAEMO */
224 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
226 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
227 gtk_widget_destroy (GTK_WIDGET (win));
228 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
230 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
231 } else if (MODEST_IS_WINDOW (win)) {
232 gtk_widget_destroy (GTK_WIDGET (win));
234 g_return_if_reached ();
239 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
241 GtkClipboard *clipboard = NULL;
242 gchar *selection = NULL;
244 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
245 selection = gtk_clipboard_wait_for_text (clipboard);
247 modest_address_book_add_address (selection);
252 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
255 /* This is currently only implemented for Maemo,
256 * because it requires a providers preset file which is not publically available.
258 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
259 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
260 TRUE /* enabled accounts only */);
261 gboolean accounts_exist = account_names != NULL;
262 g_slist_free (account_names);
264 if (!accounts_exist) {
265 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
266 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
267 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
268 gtk_dialog_run (GTK_DIALOG (wizard));
269 gtk_widget_destroy (GTK_WIDGET (wizard));
271 /* Show the list of accounts: */
272 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
273 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
274 gtk_dialog_run (account_win);
275 gtk_widget_destroy (GTK_WIDGET(account_win));
278 GtkWidget *dialog, *label;
280 /* Create the widgets */
282 dialog = gtk_dialog_new_with_buttons ("Message",
284 GTK_DIALOG_DESTROY_WITH_PARENT,
288 label = gtk_label_new ("Hello World!");
290 /* Ensure that the dialog box is destroyed when the user responds. */
292 g_signal_connect_swapped (dialog, "response",
293 G_CALLBACK (gtk_widget_destroy),
296 /* Add the label, and show everything we've added to the dialog. */
298 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
300 gtk_widget_show_all (dialog);
301 #endif /* MODEST_PLATFORM_MAEMO */
305 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
307 ModestWindow *msg_win;
309 TnyFolder *folder = NULL;
310 gchar *account_name = NULL;
311 gchar *from_str = NULL;
312 /* GError *err = NULL; */
313 TnyAccount *account = NULL;
314 ModestWindowMgr *mgr;
315 gchar *signature = NULL;
317 account_name = g_strdup(modest_window_get_active_account (win));
319 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
321 g_printerr ("modest: no account found\n");
325 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
327 TNY_ACCOUNT_TYPE_STORE);
329 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
333 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
335 g_printerr ("modest: failed get from string for '%s'\n", account_name);
339 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
340 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
341 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
342 MODEST_ACCOUNT_SIGNATURE, FALSE);
344 signature = g_strdup ("");
347 msg = modest_tny_msg_new ("", from_str, "", "", "", signature, NULL);
349 g_printerr ("modest: failed to create new msg\n");
353 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
355 g_printerr ("modest: failed to find Drafts folder\n");
359 /* tny_folder_add_msg (folder, msg, &err); */
361 /* g_printerr ("modest: error adding msg to Drafts folder: %s", */
363 /* g_error_free (err); */
367 /* Create and register edit window */
368 msg_win = modest_msg_edit_window_new (msg, account_name);
369 mgr = modest_runtime_get_window_mgr ();
370 modest_window_mgr_register_window (mgr, msg_win);
373 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
375 gtk_widget_show_all (GTK_WIDGET (msg_win));
378 g_free (account_name);
382 g_object_unref (G_OBJECT(account));
384 g_object_unref (G_OBJECT(msg));
386 g_object_unref (G_OBJECT(folder));
390 headers_action_open (TnyHeader *header,
394 modest_ui_actions_on_header_activated (MODEST_HEADER_VIEW (user_data),
396 MODEST_MAIN_WINDOW (win));
400 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
402 GtkWidget *header_view;
404 /* Get header view */
405 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
406 MODEST_WIDGET_TYPE_HEADER_VIEW);
408 /* Open each message */
409 do_headers_action (win, headers_action_open, header_view);
414 open_msg_func (const GObject *obj, const TnyMsg *msg, gpointer user_data)
416 ModestWindowMgr *mgr = NULL;
417 ModestWindow *parent_win = NULL;
418 ModestWindow *win = NULL;
419 HeaderActivatedHelper *helper = NULL;
420 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
421 gchar *account = NULL;
423 g_return_if_fail (MODEST_IS_WINDOW(obj));
424 g_return_if_fail (user_data != NULL);
425 parent_win = MODEST_WINDOW(obj);
426 helper = (HeaderActivatedHelper *) user_data;
429 account = g_strdup(modest_window_get_active_account(MODEST_WINDOW(parent_win)));
431 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
433 /* Gets foldert type (OUTBOX headers will be opened in edit window */
434 if (modest_tny_folder_is_local_folder (helper->folder))
435 folder_type = modest_tny_folder_get_local_folder_type (helper->folder);
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 * This function performs the send & receive required actions. The
793 * window it's used to create the mail operation. Tipically it should
794 * be allways the main window, but we pass it as argument in order to
798 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
800 gchar *acc_name = NULL;
802 /* If no account name was provided get the current account, if
803 there is none either then pick the default one */
805 acc_name = g_strdup (modest_window_get_active_account(win));
807 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
809 g_printerr ("modest: cannot get default account\n");
813 acc_name = g_strdup (account_name);
816 /* Send & receive. Do not continue if no suitable connection
818 if (check_for_connection (acc_name)) {
819 /* As per the UI spec,
820 * for POP accounts, we should receive,
821 * for IMAP we should synchronize everything, including receiving,
822 * for SMTP we should send,
823 * first receiving, then sending:
825 if (!action_receive(acc_name, win))
826 g_printerr ("modest: failed to receive\n");
827 if (!action_send(acc_name))
828 g_printerr ("modest: failed to send\n");
835 * Refreshes all accounts. This function will be used by automatic
839 modest_ui_actions_do_send_receive_all (ModestWindow *win)
841 GSList *account_names, *iter;
843 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
846 iter = account_names;
848 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
849 iter = g_slist_next (iter);
852 g_slist_foreach (account_names, (GFunc) g_free, NULL);
853 g_slist_free (account_names);
857 * Handler of the click on Send&Receive button in the main toolbar
860 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
862 /* Check that at least one account exists: */
863 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
864 TRUE /* enabled accounts only */);
865 gboolean accounts_exist = account_names != NULL;
866 g_slist_free (account_names);
868 /* If not, allow the user to create an account before trying to send/receive. */
870 modest_ui_actions_on_accounts (NULL, win);
872 /* Refresh the active account */
873 modest_ui_actions_do_send_receive (NULL, win);
878 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
881 GtkWidget *header_view;
883 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
885 header_view = modest_main_window_get_child_widget (main_window,
886 MODEST_WIDGET_TYPE_HEADER_VIEW);
890 conf = modest_runtime_get_conf ();
892 /* what is saved/restored is depending on the style; thus; we save with
893 * old style, then update the style, and restore for this new style
895 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
897 if (modest_header_view_get_style
898 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
899 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
900 MODEST_HEADER_VIEW_STYLE_TWOLINES);
902 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
903 MODEST_HEADER_VIEW_STYLE_DETAILS);
905 modest_widget_memory_restore (conf, G_OBJECT(header_view),
906 MODEST_CONF_HEADER_VIEW_KEY);
911 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
913 ModestMainWindow *main_window)
915 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
917 /* If no header has been selected then exit */
921 /* Update Main window title */
922 if (GTK_WIDGET_HAS_FOCUS (header_view)) {
923 const gchar *subject = tny_header_get_subject (header);
924 if (subject && strcmp (subject, ""))
925 gtk_window_set_title (GTK_WINDOW (main_window), subject);
927 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
932 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
934 ModestMainWindow *main_window)
936 ModestMailOperation *mail_op = NULL;
937 HeaderActivatedHelper *helper = NULL;
938 ModestWindowMgr *mgr = NULL;
939 ModestWindow *win = NULL;
940 GtkTreeModel *model = NULL;
942 GtkTreeSelection *sel = NULL;
943 GList *sel_list = NULL;
945 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
950 /* Look if we already have a message view for that header */
951 mgr = modest_runtime_get_window_mgr ();
952 win = modest_window_mgr_find_window_by_msguid (mgr, tny_header_get_uid (header));
956 helper = g_slice_new0 (HeaderActivatedHelper);
957 helper->folder = tny_header_get_folder (header);
958 helper->model = NULL;
960 /* Get headers tree model and selected iter to build message view */
961 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
962 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
963 if (sel_list != NULL) {
964 gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) sel_list->data);
967 helper->model = model;
970 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
971 g_list_free (sel_list);
974 /* New mail operation */
975 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(main_window));
976 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
977 modest_mail_operation_get_msg (mail_op, header, open_msg_func, helper);
980 g_object_unref (mail_op);
984 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
985 TnyFolderStore *folder_store,
987 ModestMainWindow *main_window)
990 GtkWidget *header_view;
992 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
994 header_view = modest_main_window_get_child_widget(main_window,
995 MODEST_WIDGET_TYPE_HEADER_VIEW);
999 conf = modest_runtime_get_conf ();
1001 if (TNY_IS_FOLDER (folder_store)) {
1004 modest_main_window_set_contents_style (main_window,
1005 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1006 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1007 TNY_FOLDER (folder_store));
1008 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1009 MODEST_CONF_HEADER_VIEW_KEY);
1011 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1012 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
1014 } else if (TNY_IS_ACCOUNT (folder_store)) {
1016 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1021 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1028 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1030 if (g_main_depth > 0)
1031 gdk_threads_enter ();
1032 online = tny_device_is_online (modest_runtime_get_device());
1035 /* already online -- the item is simply not there... */
1036 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1038 GTK_MESSAGE_WARNING,
1040 _("The %s you selected cannot be found"),
1042 gtk_dialog_run (GTK_DIALOG(dialog));
1044 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1048 GTK_RESPONSE_REJECT,
1050 GTK_RESPONSE_ACCEPT,
1052 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1053 "Do you want to get online?"), item);
1054 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1055 gtk_label_new (txt), FALSE, FALSE, 0);
1056 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1059 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1060 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1061 // modest_platform_connect_and_wait ();;
1064 gtk_widget_destroy (dialog);
1065 if (g_main_depth > 0)
1066 gdk_threads_leave ();
1070 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1073 /* g_message ("%s %s", __FUNCTION__, link); */
1078 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1081 modest_platform_activate_uri (link);
1085 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1088 modest_platform_show_uri_popup (link);
1092 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1095 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1099 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1100 const gchar *address,
1103 /* g_message ("%s %s", __FUNCTION__, address); */
1107 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1109 TnyTransportAccount *transport_account;
1110 ModestMailOperation *mail_operation;
1112 gchar *account_name, *from;
1113 ModestAccountMgr *account_mgr;
1115 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1117 data = modest_msg_edit_window_get_msg_data (edit_window);
1119 account_mgr = modest_runtime_get_account_mgr();
1120 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1122 account_name = modest_account_mgr_get_default_account (account_mgr);
1123 if (!account_name) {
1124 g_printerr ("modest: no account found\n");
1125 modest_msg_edit_window_free_msg_data (edit_window, data);
1129 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
1130 (modest_runtime_get_account_store(),
1132 TNY_ACCOUNT_TYPE_TRANSPORT));
1133 if (!transport_account) {
1134 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1135 g_free (account_name);
1136 modest_msg_edit_window_free_msg_data (edit_window, data);
1139 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1141 /* Create the mail operation */
1142 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(edit_window));
1143 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1145 modest_mail_operation_save_to_drafts (mail_operation,
1155 data->priority_flags);
1158 g_free (account_name);
1159 g_object_unref (G_OBJECT (transport_account));
1160 g_object_unref (G_OBJECT (mail_operation));
1162 modest_msg_edit_window_free_msg_data (edit_window, data);
1164 /* Save settings and close the window */
1165 gtk_widget_destroy (GTK_WIDGET (edit_window));
1168 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1170 TnyTransportAccount *transport_account;
1171 ModestMailOperation *mail_operation;
1173 gchar *account_name, *from;
1174 ModestAccountMgr *account_mgr;
1176 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1178 if (!modest_msg_edit_window_check_names (edit_window))
1181 data = modest_msg_edit_window_get_msg_data (edit_window);
1183 /* FIXME: Code added just for testing. The final version will
1184 use the send queue provided by tinymail and some
1186 account_mgr = modest_runtime_get_account_mgr();
1187 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1189 account_name = modest_account_mgr_get_default_account (account_mgr);
1190 if (!account_name) {
1191 g_printerr ("modest: no account found\n");
1192 modest_msg_edit_window_free_msg_data (edit_window, data);
1196 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1197 (modest_runtime_get_account_store(),
1199 if (!transport_account) {
1200 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1201 g_free (account_name);
1202 modest_msg_edit_window_free_msg_data (edit_window, data);
1205 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1207 /* Create the mail operation */
1208 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_SEND, G_OBJECT(edit_window));
1209 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1211 modest_mail_operation_send_new_mail (mail_operation,
1221 data->priority_flags);
1224 g_free (account_name);
1225 g_object_unref (G_OBJECT (transport_account));
1226 g_object_unref (G_OBJECT (mail_operation));
1228 modest_msg_edit_window_free_msg_data (edit_window, data);
1230 /* Save settings and close the window */
1231 gtk_widget_destroy (GTK_WIDGET (edit_window));
1235 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1236 ModestMsgEditWindow *window)
1238 ModestMsgEditFormatState *format_state = NULL;
1240 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1241 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1243 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1246 format_state = modest_msg_edit_window_get_format_state (window);
1247 g_return_if_fail (format_state != NULL);
1249 format_state->bold = gtk_toggle_action_get_active (action);
1250 modest_msg_edit_window_set_format_state (window, format_state);
1251 g_free (format_state);
1256 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1257 ModestMsgEditWindow *window)
1259 ModestMsgEditFormatState *format_state = NULL;
1261 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1262 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1264 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1267 format_state = modest_msg_edit_window_get_format_state (window);
1268 g_return_if_fail (format_state != NULL);
1270 format_state->italics = gtk_toggle_action_get_active (action);
1271 modest_msg_edit_window_set_format_state (window, format_state);
1272 g_free (format_state);
1277 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1278 ModestMsgEditWindow *window)
1280 ModestMsgEditFormatState *format_state = NULL;
1282 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1283 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1285 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1288 format_state = modest_msg_edit_window_get_format_state (window);
1289 g_return_if_fail (format_state != NULL);
1291 format_state->bullet = gtk_toggle_action_get_active (action);
1292 modest_msg_edit_window_set_format_state (window, format_state);
1293 g_free (format_state);
1298 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1299 GtkRadioAction *selected,
1300 ModestMsgEditWindow *window)
1302 ModestMsgEditFormatState *format_state = NULL;
1303 GtkJustification value;
1305 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1307 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1310 value = gtk_radio_action_get_current_value (selected);
1312 format_state = modest_msg_edit_window_get_format_state (window);
1313 g_return_if_fail (format_state != NULL);
1315 format_state->justification = value;
1316 modest_msg_edit_window_set_format_state (window, format_state);
1317 g_free (format_state);
1321 modest_ui_actions_on_select_editor_color (GtkAction *action,
1322 ModestMsgEditWindow *window)
1324 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1325 g_return_if_fail (GTK_IS_ACTION (action));
1327 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1330 modest_msg_edit_window_select_color (window);
1334 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1335 ModestMsgEditWindow *window)
1337 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1338 g_return_if_fail (GTK_IS_ACTION (action));
1340 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1343 modest_msg_edit_window_select_background_color (window);
1347 modest_ui_actions_on_insert_image (GtkAction *action,
1348 ModestMsgEditWindow *window)
1350 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1351 g_return_if_fail (GTK_IS_ACTION (action));
1353 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1356 modest_msg_edit_window_insert_image (window);
1360 modest_ui_actions_on_attach_file (GtkAction *action,
1361 ModestMsgEditWindow *window)
1363 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1364 g_return_if_fail (GTK_IS_ACTION (action));
1366 modest_msg_edit_window_attach_file (window);
1370 modest_ui_actions_on_remove_attachments (GtkAction *action,
1371 ModestMsgEditWindow *window)
1373 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1374 g_return_if_fail (GTK_IS_ACTION (action));
1376 modest_msg_edit_window_remove_attachments (window, NULL);
1380 * Shows a dialog with an entry that asks for some text. The returned
1381 * value must be freed by the caller. The dialog window title will be
1385 ask_for_folder_name (GtkWindow *parent_window,
1388 GtkWidget *dialog, *entry;
1389 gchar *folder_name = NULL;
1391 /* Ask for folder name */
1392 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1396 GTK_RESPONSE_REJECT,
1398 GTK_RESPONSE_ACCEPT,
1400 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1401 gtk_label_new(title),
1404 entry = gtk_entry_new_with_max_length (40);
1405 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1409 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1411 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1412 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1414 gtk_widget_destroy (dialog);
1420 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1422 TnyFolderStore *parent_folder;
1423 GtkWidget *folder_view;
1425 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1427 folder_view = modest_main_window_get_child_widget (main_window,
1428 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1432 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1434 if (parent_folder) {
1435 gboolean finished = FALSE;
1437 gchar *folder_name = NULL, *suggested_name = NULL;
1439 /* Run the new folder dialog */
1441 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1446 if (result == GTK_RESPONSE_REJECT) {
1449 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1450 TnyFolder *new_folder = NULL;
1452 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1455 new_folder = modest_mail_operation_create_folder (mail_op,
1457 (const gchar *) folder_name);
1459 g_object_unref (new_folder);
1463 /* /\* TODO: check error and follow proper actions *\/ */
1464 /* /\* suggested_name = X; *\/ */
1465 /* /\* Show error to the user *\/ */
1466 /* modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1467 /* MODEST_INFORMATION_CREATE_FOLDER); */
1469 g_object_unref (mail_op);
1471 g_free (folder_name);
1475 g_object_unref (parent_folder);
1480 modest_ui_actions_on_rename_folder (GtkAction *action,
1481 ModestMainWindow *main_window)
1483 TnyFolderStore *folder;
1484 GtkWidget *folder_view;
1486 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1488 folder_view = modest_main_window_get_child_widget (main_window,
1489 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1493 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1495 if (folder && TNY_IS_FOLDER (folder)) {
1497 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1498 _("Please enter a new name for the folder"));
1500 if (folder_name != NULL && strlen (folder_name) > 0) {
1501 ModestMailOperation *mail_op;
1503 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO, G_OBJECT(main_window));
1504 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1507 modest_mail_operation_rename_folder (mail_op,
1508 TNY_FOLDER (folder),
1509 (const gchar *) folder_name);
1511 g_object_unref (mail_op);
1512 g_free (folder_name);
1514 g_object_unref (folder);
1519 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1521 TnyFolderStore *folder;
1522 GtkWidget *folder_view;
1526 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1528 folder_view = modest_main_window_get_child_widget (main_window,
1529 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1533 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1536 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1537 tny_folder_get_name (TNY_FOLDER (folder)));
1538 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1539 (const gchar *) message);
1542 if (response == GTK_RESPONSE_OK) {
1543 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_DELETE, G_OBJECT(main_window));
1545 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1547 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1549 /* Show error if happened */
1550 if (modest_mail_operation_get_error (mail_op))
1551 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1552 MODEST_INFORMATION_DELETE_FOLDER);
1554 g_object_unref (G_OBJECT (mail_op));
1557 g_object_unref (G_OBJECT (folder));
1561 modest_ui_actions_on_delete_folder (GtkAction *action,
1562 ModestMainWindow *main_window)
1564 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1566 delete_folder (main_window, FALSE);
1570 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1572 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1574 delete_folder (main_window, TRUE);
1578 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1579 const gchar* server_account_name,
1584 ModestMainWindow *main_window)
1586 g_return_if_fail(server_account_name);
1587 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1589 #ifdef MODEST_PLATFORM_MAEMO
1590 /* Maemo uses a different (awkward) button order,
1591 * It should probably just use gtk_alternative_dialog_button_order ().
1593 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1597 GTK_RESPONSE_ACCEPT,
1599 GTK_RESPONSE_REJECT,
1602 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1606 GTK_RESPONSE_REJECT,
1608 GTK_RESPONSE_ACCEPT,
1610 #endif /* MODEST_PLATFORM_MAEMO */
1612 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1614 gchar *server_name = modest_server_account_get_hostname (
1615 modest_runtime_get_account_mgr(), server_account_name);
1617 /* This causes a warning because the logical ID has no %s in it,
1618 * though the translation does, but there is not much we can do about that: */
1619 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
1620 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1623 g_free (server_name);
1627 gchar *initial_username = modest_server_account_get_username (
1628 modest_runtime_get_account_mgr(), server_account_name);
1630 GtkWidget *entry_username = gtk_entry_new ();
1631 if (initial_username)
1632 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
1633 /* Dim this if a connection has ever succeeded with this username,
1634 * as per the UI spec: */
1635 const gboolean username_known =
1636 modest_server_account_get_username_has_succeeded(
1637 modest_runtime_get_account_mgr(), server_account_name);
1638 gtk_widget_set_sensitive (entry_username, !username_known);
1640 #ifdef MODEST_PLATFORM_MAEMO
1641 /* Auto-capitalization is the default, so let's turn it off: */
1642 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
1644 /* Create a size group to be used by all captions.
1645 * Note that HildonCaption does not create a default size group if we do not specify one.
1646 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
1647 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1649 GtkWidget *caption = hildon_caption_new (sizegroup,
1650 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
1651 gtk_widget_show (entry_username);
1652 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1653 FALSE, FALSE, MODEST_MARGIN_HALF);
1654 gtk_widget_show (caption);
1656 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
1658 #endif /* MODEST_PLATFORM_MAEMO */
1661 GtkWidget *entry_password = gtk_entry_new ();
1662 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
1663 gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), 0x2022); /* bullet unichar */
1665 #ifdef MODEST_PLATFORM_MAEMO
1666 /* Auto-capitalization is the default, so let's turn it off: */
1667 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password), HILDON_GTK_INPUT_MODE_FULL);
1669 caption = hildon_caption_new (sizegroup,
1670 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
1671 gtk_widget_show (entry_password);
1672 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1673 FALSE, FALSE, MODEST_MARGIN_HALF);
1674 gtk_widget_show (caption);
1675 g_object_unref (sizegroup);
1677 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
1679 #endif /* MODEST_PLATFORM_MAEMO */
1681 /* This is not in the Maemo UI spec:
1682 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1683 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1687 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1689 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1691 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
1693 modest_server_account_set_username (
1694 modest_runtime_get_account_mgr(), server_account_name,
1697 const gboolean username_was_changed =
1698 (strcmp (*username, initial_username) != 0);
1699 if (username_was_changed) {
1700 /* To actually use a changed username,
1701 * we must reset the connection, according to pvanhoof.
1702 * This _might_ be a sensible way to do that: */
1703 TnyDevice *device = modest_runtime_get_device();
1704 tny_device_force_offline (device);
1705 tny_device_force_online (device);
1710 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
1712 /* We do not save the password in the configuration,
1713 * because this function is only called for passwords that should
1714 * not be remembered:
1715 modest_server_account_set_password (
1716 modest_runtime_get_account_mgr(), server_account_name,
1735 /* This is not in the Maemo UI spec:
1736 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1742 gtk_widget_destroy (dialog);
1746 modest_ui_actions_on_cut (GtkAction *action,
1747 ModestWindow *window)
1749 GtkWidget *focused_widget;
1751 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1752 if (GTK_IS_EDITABLE (focused_widget)) {
1753 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1754 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1755 GtkTextBuffer *buffer;
1756 GtkClipboard *clipboard;
1758 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1759 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1760 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1765 modest_ui_actions_on_copy (GtkAction *action,
1766 ModestWindow *window)
1768 GtkClipboard *clipboard;
1769 GtkWidget *focused_widget;
1771 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1772 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1773 if (GTK_IS_LABEL (focused_widget)) {
1774 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1775 } else if (GTK_IS_EDITABLE (focused_widget)) {
1776 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1777 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1778 GtkTextBuffer *buffer;
1780 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1781 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1786 modest_ui_actions_on_undo (GtkAction *action,
1787 ModestWindow *window)
1789 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1790 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1792 g_return_if_reached ();
1797 modest_ui_actions_on_paste (GtkAction *action,
1798 ModestWindow *window)
1800 GtkWidget *focused_widget;
1802 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1803 if (GTK_IS_EDITABLE (focused_widget)) {
1804 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1805 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1806 GtkTextBuffer *buffer;
1807 GtkClipboard *clipboard;
1809 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1810 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1811 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1816 modest_ui_actions_on_select_all (GtkAction *action,
1817 ModestWindow *window)
1819 GtkWidget *focused_widget;
1821 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1822 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
1823 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
1824 } else if (GTK_IS_LABEL (focused_widget)) {
1825 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1826 } else if (GTK_IS_EDITABLE (focused_widget)) {
1827 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1828 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1829 GtkTextBuffer *buffer;
1830 GtkTextIter start, end;
1832 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1833 gtk_text_buffer_get_start_iter (buffer, &start);
1834 gtk_text_buffer_get_end_iter (buffer, &end);
1835 gtk_text_buffer_select_range (buffer, &start, &end);
1840 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
1841 GtkRadioAction *selected,
1842 ModestWindow *window)
1846 value = gtk_radio_action_get_current_value (selected);
1847 if (MODEST_IS_WINDOW (window)) {
1848 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
1852 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
1853 GtkRadioAction *selected,
1854 ModestWindow *window)
1856 TnyHeaderFlags flags;
1857 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1859 flags = gtk_radio_action_get_current_value (selected);
1860 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
1863 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
1864 GtkRadioAction *selected,
1865 ModestWindow *window)
1869 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1871 file_format = gtk_radio_action_get_current_value (selected);
1872 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
1877 modest_ui_actions_on_zoom_plus (GtkAction *action,
1878 ModestWindow *window)
1880 g_return_if_fail (MODEST_IS_WINDOW (window));
1882 modest_window_zoom_plus (MODEST_WINDOW (window));
1886 modest_ui_actions_on_zoom_minus (GtkAction *action,
1887 ModestWindow *window)
1889 g_return_if_fail (MODEST_IS_WINDOW (window));
1891 modest_window_zoom_minus (MODEST_WINDOW (window));
1895 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
1896 ModestWindow *window)
1898 ModestWindowMgr *mgr;
1899 gboolean fullscreen, active;
1900 g_return_if_fail (MODEST_IS_WINDOW (window));
1902 mgr = modest_runtime_get_window_mgr ();
1904 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
1905 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1907 if (active != fullscreen) {
1908 modest_window_mgr_set_fullscreen_mode (mgr, active);
1909 gtk_window_present (GTK_WINDOW (window));
1914 modest_ui_actions_on_change_fullscreen (GtkAction *action,
1915 ModestWindow *window)
1917 ModestWindowMgr *mgr;
1918 gboolean fullscreen;
1920 g_return_if_fail (MODEST_IS_WINDOW (window));
1922 mgr = modest_runtime_get_window_mgr ();
1923 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1924 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
1926 gtk_window_present (GTK_WINDOW (window));
1930 * Used by modest_ui_actions_on_details to call do_headers_action
1933 headers_action_show_details (TnyHeader *header,
1934 ModestWindow *window,
1941 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
1944 gtk_widget_show_all (dialog);
1945 gtk_dialog_run (GTK_DIALOG (dialog));
1947 gtk_widget_destroy (dialog);
1951 * Show the folder details in a ModestDetailsDialog widget
1954 show_folder_details (TnyFolder *folder,
1960 dialog = modest_details_dialog_new_with_folder (window, folder);
1963 gtk_widget_show_all (dialog);
1964 gtk_dialog_run (GTK_DIALOG (dialog));
1966 gtk_widget_destroy (dialog);
1970 * Show the header details in a ModestDetailsDialog widget
1973 modest_ui_actions_on_details (GtkAction *action,
1976 TnyList * headers_list;
1980 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1983 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1987 headers_list = get_selected_headers (win);
1991 iter = tny_list_create_iterator (headers_list);
1993 header = TNY_HEADER (tny_iterator_get_current (iter));
1994 headers_action_show_details (header, win, NULL);
1995 g_object_unref (header);
1997 g_object_unref (iter);
1999 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2000 GtkWidget *folder_view, *header_view;
2002 /* Check which widget has the focus */
2003 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2004 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2005 if (gtk_widget_is_focus (folder_view)) {
2008 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2010 /* Show only when it's a folder */
2011 if (!folder || !TNY_IS_FOLDER (folder))
2014 show_folder_details (folder, GTK_WINDOW (win));
2017 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2018 MODEST_WIDGET_TYPE_HEADER_VIEW);
2019 /* Show details of each header */
2020 do_headers_action (win, headers_action_show_details, header_view);
2026 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2027 ModestMsgEditWindow *window)
2029 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2031 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2035 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2036 ModestMsgEditWindow *window)
2038 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2040 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2044 modest_ui_actions_toggle_folders_view (GtkAction *action,
2045 ModestMainWindow *main_window)
2049 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2051 conf = modest_runtime_get_conf ();
2053 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2054 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2056 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2060 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2061 ModestWindow *window)
2063 gboolean active, fullscreen = FALSE;
2064 ModestWindowMgr *mgr;
2066 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2068 /* Check if we want to toggle the toolbar vuew in fullscreen
2070 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2071 "ViewShowToolbarFullScreen")) {
2075 /* Toggle toolbar */
2076 mgr = modest_runtime_get_window_mgr ();
2077 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2081 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2082 ModestMsgEditWindow *window)
2084 modest_msg_edit_window_select_font (window);
2088 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2089 const gchar *display_name,
2092 /* Do not change the application name if the widget has not
2093 the focus. This callback could be called even if the folder
2094 view has not the focus, because the handled signal could be
2095 emitted when the folder view is redrawn */
2096 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2098 gtk_window_set_title (window, display_name);
2100 gtk_window_set_title (window, " ");
2105 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2107 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2108 modest_msg_edit_window_select_contacts (window);
2112 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2114 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2115 modest_msg_edit_window_check_names (window);
2120 create_move_to_dialog (ModestWindow *win,
2121 GtkWidget *folder_view,
2122 GtkWidget **tree_view)
2124 GtkWidget *dialog, *scroll;
2126 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2128 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2130 GTK_RESPONSE_ACCEPT,
2132 GTK_RESPONSE_REJECT,
2135 /* Create scrolled window */
2136 scroll = gtk_scrolled_window_new (NULL, NULL);
2137 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2138 GTK_POLICY_AUTOMATIC,
2139 GTK_POLICY_AUTOMATIC);
2141 /* Create folder view */
2142 *tree_view = modest_folder_view_new (NULL);
2143 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2144 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2145 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2147 /* Add scroll to dialog */
2148 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2149 scroll, FALSE, FALSE, 0);
2151 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2157 * Returns TRUE if at least one of the headers of the list belongs to
2158 * a message that has been fully retrieved.
2161 has_retrieved_msgs (TnyList *list)
2164 gboolean found = FALSE;
2166 iter = tny_list_create_iterator (list);
2167 while (tny_iterator_is_done (iter) && !found) {
2169 TnyHeaderFlags flags;
2171 header = TNY_HEADER (tny_iterator_get_current (iter));
2172 flags = tny_header_get_flags (header);
2173 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2177 tny_iterator_next (iter);
2179 g_object_unref (iter);
2185 * Shows a confirmation dialog to the user when we're moving messages
2186 * from a remote server to the local storage. Returns the dialog
2187 * response. If it's other kind of movement the it always returns
2191 msgs_move_to_confirmation (GtkWindow *win,
2192 TnyFolder *dest_folder,
2195 gint response = GTK_RESPONSE_OK;
2197 /* If the destination is a local folder */
2198 if (modest_tny_folder_is_local_folder (dest_folder)) {
2199 TnyFolder *src_folder;
2203 /* Get source folder */
2204 iter = tny_list_create_iterator (headers);
2205 header = TNY_HEADER (tny_iterator_get_current (iter));
2206 src_folder = tny_header_get_folder (header);
2207 g_object_unref (header);
2208 g_object_unref (iter);
2210 /* If the source is a remote folder */
2211 if (!modest_tny_folder_is_local_folder (src_folder)) {
2212 const gchar *message;
2214 if (tny_list_get_length (headers) == 1)
2215 if (has_retrieved_msgs (headers))
2216 message = _("mcen_nc_move_retrieve");
2218 message = _("mcen_nc_move_header");
2220 if (has_retrieved_msgs (headers))
2221 message = _("mcen_nc_move_retrieves");
2223 message = _("mcen_nc_move_headers");
2225 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2226 (const gchar *) message);
2233 * UI handler for the "Move to" action when invoked from the
2237 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2238 ModestMainWindow *win)
2240 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2242 TnyFolderStore *folder_store;
2243 ModestMailOperation *mail_op = NULL;
2245 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2247 /* Get the folder view */
2248 folder_view = modest_main_window_get_child_widget (win,
2249 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2251 /* Create and run the dialog */
2252 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2253 result = gtk_dialog_run (GTK_DIALOG(dialog));
2255 /* We do this to save an indentation level ;-) */
2256 if (result != GTK_RESPONSE_ACCEPT)
2259 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2261 if (TNY_IS_ACCOUNT (folder_store))
2264 /* Get folder or messages to transfer */
2265 if (gtk_widget_is_focus (folder_view)) {
2266 TnyFolderStore *src_folder;
2267 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2269 if (TNY_IS_FOLDER (src_folder)) {
2270 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2271 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2274 modest_mail_operation_xfer_folder (mail_op,
2275 TNY_FOLDER (src_folder),
2278 g_object_unref (G_OBJECT (mail_op));
2282 g_object_unref (G_OBJECT (src_folder));
2284 GtkWidget *header_view;
2285 header_view = modest_main_window_get_child_widget (win,
2286 MODEST_WIDGET_TYPE_HEADER_VIEW);
2287 if (gtk_widget_is_focus (header_view)) {
2291 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2293 /* Ask for user confirmation */
2294 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2295 TNY_FOLDER (folder_store),
2298 /* Transfer messages */
2299 if (response == GTK_RESPONSE_OK) {
2300 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2301 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2304 modest_mail_operation_xfer_msgs (mail_op,
2306 TNY_FOLDER (folder_store),
2308 g_object_unref (G_OBJECT (mail_op));
2312 g_object_unref (folder_store);
2315 gtk_widget_destroy (dialog);
2320 * UI handler for the "Move to" action when invoked from the
2321 * ModestMsgViewWindow
2324 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2325 ModestMsgViewWindow *win)
2327 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2329 ModestMainWindow *main_window;
2334 /* Get the folder view */
2335 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2336 folder_view = modest_main_window_get_child_widget (main_window,
2337 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2339 /* Create and run the dialog */
2340 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2341 result = gtk_dialog_run (GTK_DIALOG(dialog));
2343 if (result == GTK_RESPONSE_ACCEPT) {
2344 TnyFolderStore *folder_store;
2347 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2349 /* Create header list */
2350 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2351 header = tny_msg_get_header (msg);
2352 headers = tny_simple_list_new ();
2353 tny_list_prepend (headers, G_OBJECT (header));
2354 g_object_unref (header);
2355 g_object_unref (msg);
2357 /* Ask user for confirmation. MSG-NOT404 */
2358 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2359 TNY_FOLDER (folder_store),
2362 /* Transfer current msg */
2363 if (response == GTK_RESPONSE_OK) {
2364 ModestMailOperation *mail_op;
2366 /* Create mail op */
2367 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2368 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2371 /* Transfer messages */
2372 modest_mail_operation_xfer_msgs (mail_op,
2374 TNY_FOLDER (folder_store),
2376 g_object_unref (G_OBJECT (mail_op));
2378 g_object_unref (headers);
2380 g_object_unref (folder_store);
2382 gtk_widget_destroy (dialog);
2386 modest_ui_actions_on_move_to (GtkAction *action,
2389 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2390 MODEST_IS_MSG_VIEW_WINDOW (win));
2392 if (MODEST_IS_MAIN_WINDOW (win))
2393 modest_ui_actions_on_main_window_move_to (action,
2394 MODEST_MAIN_WINDOW (win));
2396 modest_ui_actions_on_msg_view_window_move_to (action,
2397 MODEST_MSG_VIEW_WINDOW (win));
2401 * Calls #HeadersFunc for each header already selected in the main
2402 * window or the message currently being shown in the msg view window
2405 do_headers_action (ModestWindow *win,
2409 TnyList *headers_list;
2413 headers_list = get_selected_headers (win);
2417 /* Call the function for each header */
2418 iter = tny_list_create_iterator (headers_list);
2419 while (!tny_iterator_is_done (iter)) {
2422 header = TNY_HEADER (tny_iterator_get_current (iter));
2423 func (header, win, user_data);
2424 g_object_unref (header);
2425 tny_iterator_next (iter);
2427 g_object_unref (iter);
2431 modest_ui_actions_view_attachment (GtkAction *action,
2432 ModestWindow *window)
2434 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2435 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
2437 /* not supported window for this action */
2438 g_return_if_reached ();
2443 modest_ui_actions_save_attachments (GtkAction *action,
2444 ModestWindow *window)
2446 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2447 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2449 /* not supported window for this action */
2450 g_return_if_reached ();
2455 modest_ui_actions_remove_attachments (GtkAction *action,
2456 ModestWindow *window)
2458 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2459 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2461 /* not supported window for this action */
2462 g_return_if_reached ();
2467 modest_ui_actions_on_settings (GtkAction *action,
2472 dialog = modest_global_settings_dialog_new ();
2473 gtk_widget_show (dialog);
2474 gtk_dialog_run (GTK_DIALOG (dialog));
2475 gtk_widget_destroy (dialog);