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);
1676 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
1678 #endif /* MODEST_PLATFORM_MAEMO */
1680 /* This is not in the Maemo UI spec:
1681 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1682 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1686 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1688 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1690 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
1692 modest_server_account_set_username (
1693 modest_runtime_get_account_mgr(), server_account_name,
1696 const gboolean username_was_changed =
1697 (strcmp (*username, initial_username) != 0);
1698 if (username_was_changed) {
1699 /* To actually use a changed username,
1700 * we must reset the connection, according to pvanhoof.
1701 * This _might_ be a sensible way to do that: */
1702 TnyDevice *device = modest_runtime_get_device();
1703 tny_device_force_offline (device);
1704 tny_device_force_online (device);
1709 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
1711 /* We do not save the password in the configuration,
1712 * because this function is only called for passwords that should
1713 * not be remembered:
1714 modest_server_account_set_password (
1715 modest_runtime_get_account_mgr(), server_account_name,
1734 /* This is not in the Maemo UI spec:
1735 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1741 gtk_widget_destroy (dialog);
1745 modest_ui_actions_on_cut (GtkAction *action,
1746 ModestWindow *window)
1748 GtkWidget *focused_widget;
1750 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1751 if (GTK_IS_EDITABLE (focused_widget)) {
1752 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1753 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1754 GtkTextBuffer *buffer;
1755 GtkClipboard *clipboard;
1757 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1758 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1759 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1764 modest_ui_actions_on_copy (GtkAction *action,
1765 ModestWindow *window)
1767 GtkClipboard *clipboard;
1768 GtkWidget *focused_widget;
1770 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1771 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1772 if (GTK_IS_LABEL (focused_widget)) {
1773 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1774 } else if (GTK_IS_EDITABLE (focused_widget)) {
1775 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1776 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1777 GtkTextBuffer *buffer;
1779 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1780 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1785 modest_ui_actions_on_undo (GtkAction *action,
1786 ModestWindow *window)
1788 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1789 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1791 g_return_if_reached ();
1796 modest_ui_actions_on_paste (GtkAction *action,
1797 ModestWindow *window)
1799 GtkWidget *focused_widget;
1801 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1802 if (GTK_IS_EDITABLE (focused_widget)) {
1803 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1804 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1805 GtkTextBuffer *buffer;
1806 GtkClipboard *clipboard;
1808 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1809 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1810 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1815 modest_ui_actions_on_select_all (GtkAction *action,
1816 ModestWindow *window)
1818 GtkWidget *focused_widget;
1820 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1821 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
1822 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
1823 } else if (GTK_IS_LABEL (focused_widget)) {
1824 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1825 } else if (GTK_IS_EDITABLE (focused_widget)) {
1826 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1827 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1828 GtkTextBuffer *buffer;
1829 GtkTextIter start, end;
1831 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1832 gtk_text_buffer_get_start_iter (buffer, &start);
1833 gtk_text_buffer_get_end_iter (buffer, &end);
1834 gtk_text_buffer_select_range (buffer, &start, &end);
1839 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
1840 GtkRadioAction *selected,
1841 ModestWindow *window)
1845 value = gtk_radio_action_get_current_value (selected);
1846 if (MODEST_IS_WINDOW (window)) {
1847 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
1851 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
1852 GtkRadioAction *selected,
1853 ModestWindow *window)
1855 TnyHeaderFlags flags;
1856 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1858 flags = gtk_radio_action_get_current_value (selected);
1859 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
1862 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
1863 GtkRadioAction *selected,
1864 ModestWindow *window)
1868 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1870 file_format = gtk_radio_action_get_current_value (selected);
1871 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
1876 modest_ui_actions_on_zoom_plus (GtkAction *action,
1877 ModestWindow *window)
1879 g_return_if_fail (MODEST_IS_WINDOW (window));
1881 modest_window_zoom_plus (MODEST_WINDOW (window));
1885 modest_ui_actions_on_zoom_minus (GtkAction *action,
1886 ModestWindow *window)
1888 g_return_if_fail (MODEST_IS_WINDOW (window));
1890 modest_window_zoom_minus (MODEST_WINDOW (window));
1894 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
1895 ModestWindow *window)
1897 ModestWindowMgr *mgr;
1898 gboolean fullscreen, active;
1899 g_return_if_fail (MODEST_IS_WINDOW (window));
1901 mgr = modest_runtime_get_window_mgr ();
1903 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
1904 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1906 if (active != fullscreen) {
1907 modest_window_mgr_set_fullscreen_mode (mgr, active);
1908 gtk_window_present (GTK_WINDOW (window));
1913 modest_ui_actions_on_change_fullscreen (GtkAction *action,
1914 ModestWindow *window)
1916 ModestWindowMgr *mgr;
1917 gboolean fullscreen;
1919 g_return_if_fail (MODEST_IS_WINDOW (window));
1921 mgr = modest_runtime_get_window_mgr ();
1922 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1923 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
1925 gtk_window_present (GTK_WINDOW (window));
1929 * Used by modest_ui_actions_on_details to call do_headers_action
1932 headers_action_show_details (TnyHeader *header,
1933 ModestWindow *window,
1940 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
1943 gtk_widget_show_all (dialog);
1944 gtk_dialog_run (GTK_DIALOG (dialog));
1946 gtk_widget_destroy (dialog);
1950 * Show the folder details in a ModestDetailsDialog widget
1953 show_folder_details (TnyFolder *folder,
1959 dialog = modest_details_dialog_new_with_folder (window, folder);
1962 gtk_widget_show_all (dialog);
1963 gtk_dialog_run (GTK_DIALOG (dialog));
1965 gtk_widget_destroy (dialog);
1969 * Show the header details in a ModestDetailsDialog widget
1972 modest_ui_actions_on_details (GtkAction *action,
1975 TnyList * headers_list;
1979 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1982 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1986 headers_list = get_selected_headers (win);
1990 iter = tny_list_create_iterator (headers_list);
1992 header = TNY_HEADER (tny_iterator_get_current (iter));
1993 headers_action_show_details (header, win, NULL);
1994 g_object_unref (header);
1996 g_object_unref (iter);
1998 } else if (MODEST_IS_MAIN_WINDOW (win)) {
1999 GtkWidget *folder_view, *header_view;
2001 /* Check which widget has the focus */
2002 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2003 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2004 if (gtk_widget_is_focus (folder_view)) {
2007 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2009 /* Show only when it's a folder */
2010 if (!folder || !TNY_IS_FOLDER (folder))
2013 show_folder_details (folder, GTK_WINDOW (win));
2016 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2017 MODEST_WIDGET_TYPE_HEADER_VIEW);
2018 /* Show details of each header */
2019 do_headers_action (win, headers_action_show_details, header_view);
2025 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2026 ModestMsgEditWindow *window)
2028 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2030 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2034 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2035 ModestMsgEditWindow *window)
2037 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2039 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2043 modest_ui_actions_toggle_folders_view (GtkAction *action,
2044 ModestMainWindow *main_window)
2048 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2050 conf = modest_runtime_get_conf ();
2052 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2053 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2055 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2059 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2060 ModestWindow *window)
2062 gboolean active, fullscreen = FALSE;
2063 ModestWindowMgr *mgr;
2065 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2067 /* Check if we want to toggle the toolbar vuew in fullscreen
2069 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2070 "ViewShowToolbarFullScreen")) {
2074 /* Toggle toolbar */
2075 mgr = modest_runtime_get_window_mgr ();
2076 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2080 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2081 ModestMsgEditWindow *window)
2083 modest_msg_edit_window_select_font (window);
2087 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2088 const gchar *display_name,
2091 /* Do not change the application name if the widget has not
2092 the focus. This callback could be called even if the folder
2093 view has not the focus, because the handled signal could be
2094 emitted when the folder view is redrawn */
2095 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2097 gtk_window_set_title (window, display_name);
2099 gtk_window_set_title (window, " ");
2104 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2106 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2107 modest_msg_edit_window_select_contacts (window);
2111 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2113 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2114 modest_msg_edit_window_check_names (window);
2119 create_move_to_dialog (ModestWindow *win,
2120 GtkWidget *folder_view,
2121 GtkWidget **tree_view)
2123 GtkWidget *dialog, *scroll;
2125 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2127 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2129 GTK_RESPONSE_ACCEPT,
2131 GTK_RESPONSE_REJECT,
2134 /* Create scrolled window */
2135 scroll = gtk_scrolled_window_new (NULL, NULL);
2136 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2137 GTK_POLICY_AUTOMATIC,
2138 GTK_POLICY_AUTOMATIC);
2140 /* Create folder view */
2141 *tree_view = modest_folder_view_new (NULL);
2142 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2143 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2144 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2146 /* Add scroll to dialog */
2147 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2148 scroll, FALSE, FALSE, 0);
2150 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2156 * Returns TRUE if at least one of the headers of the list belongs to
2157 * a message that has been fully retrieved.
2160 has_retrieved_msgs (TnyList *list)
2163 gboolean found = FALSE;
2165 iter = tny_list_create_iterator (list);
2166 while (tny_iterator_is_done (iter) && !found) {
2168 TnyHeaderFlags flags;
2170 header = TNY_HEADER (tny_iterator_get_current (iter));
2171 flags = tny_header_get_flags (header);
2172 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2176 tny_iterator_next (iter);
2178 g_object_unref (iter);
2184 * Shows a confirmation dialog to the user when we're moving messages
2185 * from a remote server to the local storage. Returns the dialog
2186 * response. If it's other kind of movement the it always returns
2190 msgs_move_to_confirmation (GtkWindow *win,
2191 TnyFolder *dest_folder,
2194 gint response = GTK_RESPONSE_OK;
2196 /* If the destination is a local folder */
2197 if (modest_tny_folder_is_local_folder (dest_folder)) {
2198 TnyFolder *src_folder;
2202 /* Get source folder */
2203 iter = tny_list_create_iterator (headers);
2204 header = TNY_HEADER (tny_iterator_get_current (iter));
2205 src_folder = tny_header_get_folder (header);
2206 g_object_unref (header);
2207 g_object_unref (iter);
2209 /* If the source is a remote folder */
2210 if (!modest_tny_folder_is_local_folder (src_folder)) {
2211 const gchar *message;
2213 if (tny_list_get_length (headers) == 1)
2214 if (has_retrieved_msgs (headers))
2215 message = _("mcen_nc_move_retrieve");
2217 message = _("mcen_nc_move_header");
2219 if (has_retrieved_msgs (headers))
2220 message = _("mcen_nc_move_retrieves");
2222 message = _("mcen_nc_move_headers");
2224 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2225 (const gchar *) message);
2232 * UI handler for the "Move to" action when invoked from the
2236 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2237 ModestMainWindow *win)
2239 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2241 TnyFolderStore *folder_store;
2242 ModestMailOperation *mail_op = NULL;
2244 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2246 /* Get the folder view */
2247 folder_view = modest_main_window_get_child_widget (win,
2248 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2250 /* Create and run the dialog */
2251 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2252 result = gtk_dialog_run (GTK_DIALOG(dialog));
2254 /* We do this to save an indentation level ;-) */
2255 if (result != GTK_RESPONSE_ACCEPT)
2258 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2260 if (TNY_IS_ACCOUNT (folder_store))
2263 /* Get folder or messages to transfer */
2264 if (gtk_widget_is_focus (folder_view)) {
2265 TnyFolderStore *src_folder;
2266 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2268 if (TNY_IS_FOLDER (src_folder)) {
2269 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2270 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2273 modest_mail_operation_xfer_folder (mail_op,
2274 TNY_FOLDER (src_folder),
2277 g_object_unref (G_OBJECT (mail_op));
2281 g_object_unref (G_OBJECT (src_folder));
2283 GtkWidget *header_view;
2284 header_view = modest_main_window_get_child_widget (win,
2285 MODEST_WIDGET_TYPE_HEADER_VIEW);
2286 if (gtk_widget_is_focus (header_view)) {
2290 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2292 /* Ask for user confirmation */
2293 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2294 TNY_FOLDER (folder_store),
2297 /* Transfer messages */
2298 if (response == GTK_RESPONSE_OK) {
2299 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2300 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2303 modest_mail_operation_xfer_msgs (mail_op,
2305 TNY_FOLDER (folder_store),
2307 g_object_unref (G_OBJECT (mail_op));
2311 g_object_unref (folder_store);
2314 gtk_widget_destroy (dialog);
2319 * UI handler for the "Move to" action when invoked from the
2320 * ModestMsgViewWindow
2323 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2324 ModestMsgViewWindow *win)
2326 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2328 ModestMainWindow *main_window;
2333 /* Get the folder view */
2334 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2335 folder_view = modest_main_window_get_child_widget (main_window,
2336 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2338 /* Create and run the dialog */
2339 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2340 result = gtk_dialog_run (GTK_DIALOG(dialog));
2342 if (result == GTK_RESPONSE_ACCEPT) {
2343 TnyFolderStore *folder_store;
2346 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2348 /* Create header list */
2349 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2350 header = tny_msg_get_header (msg);
2351 headers = tny_simple_list_new ();
2352 tny_list_prepend (headers, G_OBJECT (header));
2353 g_object_unref (header);
2354 g_object_unref (msg);
2356 /* Ask user for confirmation. MSG-NOT404 */
2357 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2358 TNY_FOLDER (folder_store),
2361 /* Transfer current msg */
2362 if (response == GTK_RESPONSE_OK) {
2363 ModestMailOperation *mail_op;
2365 /* Create mail op */
2366 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(win));
2367 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2370 /* Transfer messages */
2371 modest_mail_operation_xfer_msgs (mail_op,
2373 TNY_FOLDER (folder_store),
2375 g_object_unref (G_OBJECT (mail_op));
2377 g_object_unref (headers);
2379 g_object_unref (folder_store);
2381 gtk_widget_destroy (dialog);
2385 modest_ui_actions_on_move_to (GtkAction *action,
2388 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2389 MODEST_IS_MSG_VIEW_WINDOW (win));
2391 if (MODEST_IS_MAIN_WINDOW (win))
2392 modest_ui_actions_on_main_window_move_to (action,
2393 MODEST_MAIN_WINDOW (win));
2395 modest_ui_actions_on_msg_view_window_move_to (action,
2396 MODEST_MSG_VIEW_WINDOW (win));
2400 * Calls #HeadersFunc for each header already selected in the main
2401 * window or the message currently being shown in the msg view window
2404 do_headers_action (ModestWindow *win,
2408 TnyList *headers_list;
2412 headers_list = get_selected_headers (win);
2416 /* Call the function for each header */
2417 iter = tny_list_create_iterator (headers_list);
2418 while (!tny_iterator_is_done (iter)) {
2421 header = TNY_HEADER (tny_iterator_get_current (iter));
2422 func (header, win, user_data);
2423 g_object_unref (header);
2424 tny_iterator_next (iter);
2426 g_object_unref (iter);
2430 modest_ui_actions_view_attachment (GtkAction *action,
2431 ModestWindow *window)
2433 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2434 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
2436 /* not supported window for this action */
2437 g_return_if_reached ();
2442 modest_ui_actions_save_attachments (GtkAction *action,
2443 ModestWindow *window)
2445 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2446 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2448 /* not supported window for this action */
2449 g_return_if_reached ();
2454 modest_ui_actions_remove_attachments (GtkAction *action,
2455 ModestWindow *window)
2457 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2458 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2460 /* not supported window for this action */
2461 g_return_if_reached ();
2466 modest_ui_actions_on_settings (GtkAction *action,
2471 dialog = modest_global_settings_dialog_new ();
2472 gtk_widget_show (dialog);
2473 gtk_dialog_run (GTK_DIALOG (dialog));
2474 gtk_widget_destroy (dialog);