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-connection-specific-smtp-window.h"
59 #include "modest-account-mgr-helpers.h"
60 #include "modest-mail-operation.h"
61 #include "modest-text-utils.h"
63 #ifdef MODEST_HAVE_EASYSETUP
64 #include "easysetup/modest-easysetup-wizard.h"
65 #endif /* MODEST_HAVE_EASYSETUP */
67 #include <modest-widget-memory.h>
68 #include <tny-error.h>
69 #include <tny-simple-list.h>
70 #include <tny-msg-view.h>
71 #include <tny-device.h>
72 #include <tny-merge-folder.h>
74 typedef struct _GetMsgAsyncHelper {
76 ModestMailOperation *mail_op;
83 typedef enum _ReplyForwardAction {
89 typedef struct _ReplyForwardHelper {
90 guint reply_forward_type;
91 ReplyForwardAction action;
96 * The do_headers_action uses this kind of functions to perform some
97 * action to each member of a list of headers
99 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
102 do_headers_action (ModestWindow *win,
107 static void open_msg_cb (ModestMailOperation *mail_op,
112 static void reply_forward_cb (ModestMailOperation *mail_op,
117 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
119 static gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
122 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
125 const gchar *authors[] = {
126 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
129 about = gtk_about_dialog_new ();
130 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
131 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
132 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
133 _("Copyright (c) 2006, Nokia Corporation\n"
134 "All rights reserved."));
135 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
136 _("a modest e-mail client\n\n"
137 "design and implementation: Dirk-Jan C. Binnema\n"
138 "contributions from the fine people at KC and Ig\n"
139 "uses the tinymail email framework written by Philip van Hoof"));
140 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
141 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
143 gtk_dialog_run (GTK_DIALOG (about));
144 gtk_widget_destroy(about);
148 * Gets the list of currently selected messages. If the win is the
149 * main window, then it returns a newly allocated list of the headers
150 * selected in the header view. If win is the msg view window, then
151 * the value returned is a list with just a single header.
153 * The caller of this funcion must free the list.
156 get_selected_headers (ModestWindow *win)
158 if (MODEST_IS_MAIN_WINDOW(win)) {
159 GtkWidget *header_view;
161 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
162 MODEST_WIDGET_TYPE_HEADER_VIEW);
163 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
165 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
166 /* for MsgViewWindows, we simply return a list with one element */
168 TnyList *list = NULL;
170 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
171 if (header != NULL) {
172 list = tny_simple_list_new ();
173 tny_list_prepend (list, G_OBJECT(header));
174 g_object_unref (G_OBJECT(header));
184 headers_action_mark_as_read (TnyHeader *header,
188 TnyHeaderFlags flags;
190 g_return_if_fail (TNY_IS_HEADER(header));
192 flags = tny_header_get_flags (header);
193 if (flags & TNY_HEADER_FLAG_SEEN) return;
194 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
198 headers_action_mark_as_unread (TnyHeader *header,
202 TnyHeaderFlags flags;
204 g_return_if_fail (TNY_IS_HEADER(header));
206 flags = tny_header_get_flags (header);
207 if (flags & TNY_HEADER_FLAG_SEEN) {
208 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
214 headers_action_delete (TnyHeader *header,
218 ModestMailOperation *mail_op = NULL;
220 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
221 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
224 /* Always delete. TODO: Move to trash still not supported */
225 modest_mail_operation_remove_msg (mail_op, header, FALSE);
226 g_object_unref (G_OBJECT (mail_op));
230 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
232 TnyList *header_list = NULL;
233 TnyIterator *iter = NULL;
234 TnyHeader *header = NULL;
235 gchar *message = NULL;
239 g_return_if_fail (MODEST_IS_WINDOW(win));
241 header_list = get_selected_headers (win);
242 if (!header_list) return;
245 if (tny_list_get_length(header_list) > 1)
246 message = g_strdup(_("emev_nc_delete_messages"));
248 iter = tny_list_create_iterator (header_list);
249 header = TNY_HEADER (tny_iterator_get_current (iter));
250 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
251 message = g_strdup_printf(_("emev_nc_delete_message"), desc);
254 /* Confirmation dialog */
255 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
259 if (response == GTK_RESPONSE_OK) {
260 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
262 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
266 /* Remove each header */
267 do_headers_action (win, headers_action_delete, NULL);
269 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
270 gtk_widget_destroy (GTK_WIDGET(win));
277 g_object_unref (header_list);
278 g_object_unref (iter);
283 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
285 #ifdef MODEST_PLATFORM_MAEMO
286 modest_osso_save_state();
287 #endif /* MODEST_PLATFORM_MAEMO */
293 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
295 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
296 gtk_widget_destroy (GTK_WIDGET (win));
297 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
299 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
300 } else if (MODEST_IS_WINDOW (win)) {
301 gtk_widget_destroy (GTK_WIDGET (win));
303 g_return_if_reached ();
308 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
310 GtkClipboard *clipboard = NULL;
311 gchar *selection = NULL;
313 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
314 selection = gtk_clipboard_wait_for_text (clipboard);
316 modest_address_book_add_address (selection);
321 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
323 /* This is currently only implemented for Maemo,
324 * because it requires a providers preset file which is not publically available.
326 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
327 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
328 TRUE /* enabled accounts only */);
329 gboolean accounts_exist = account_names != NULL;
330 g_slist_free (account_names);
332 if (!accounts_exist) {
333 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
334 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
335 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
336 gtk_dialog_run (GTK_DIALOG (wizard));
337 gtk_widget_destroy (GTK_WIDGET (wizard));
339 /* Show the list of accounts: */
340 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
341 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
342 gtk_dialog_run (account_win);
343 gtk_widget_destroy (GTK_WIDGET(account_win));
346 GtkWidget *dialog, *label;
348 /* Create the widgets */
350 dialog = gtk_dialog_new_with_buttons ("Message",
352 GTK_DIALOG_DESTROY_WITH_PARENT,
356 label = gtk_label_new ("Hello World!");
358 /* Ensure that the dialog box is destroyed when the user responds. */
360 g_signal_connect_swapped (dialog, "response",
361 G_CALLBACK (gtk_widget_destroy),
364 /* Add the label, and show everything we've added to the dialog. */
366 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
368 gtk_widget_show_all (dialog);
369 #endif /* MODEST_PLATFORM_MAEMO */
373 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
375 ModestWindow *main_window = MODEST_WINDOW (user_data);
377 /* Save any changes. */
378 modest_connection_specific_smtp_window_save_server_accounts (
379 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
380 modest_window_get_active_account (main_window));
381 gtk_widget_destroy (GTK_WIDGET (window));
385 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
387 /* This is currently only implemented for Maemo,
388 * because it requires an API (libconic) to detect different connection
391 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
393 /* Create the window if necessary: */
394 const gchar *active_account_name = modest_window_get_active_account (win);
396 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
397 * or show the default account?
398 * If we show the default account then the account name should be shown in
399 * the window when we show it. */
400 if (!active_account_name) {
401 g_warning ("%s: No account is active.", __FUNCTION__);
405 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
406 modest_connection_specific_smtp_window_fill_with_connections (
407 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
408 modest_runtime_get_account_mgr(),
409 active_account_name);
411 /* Show the window: */
412 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
413 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
414 gtk_widget_show (specific_window);
416 /* Save changes when the window is hidden: */
417 g_signal_connect (specific_window, "hide",
418 G_CALLBACK (on_smtp_servers_window_hide), win);
419 #endif /* MODEST_PLATFORM_MAEMO */
423 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
425 ModestWindow *msg_win;
427 TnyFolder *folder = NULL;
428 gchar *account_name = NULL;
429 gchar *from_str = NULL;
430 /* GError *err = NULL; */
431 TnyAccount *account = NULL;
432 ModestWindowMgr *mgr;
433 gchar *signature = NULL;
435 account_name = g_strdup(modest_window_get_active_account (win));
437 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
439 g_printerr ("modest: no account found\n");
443 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
445 TNY_ACCOUNT_TYPE_STORE);
447 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
451 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
453 g_printerr ("modest: failed get from string for '%s'\n", account_name);
457 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
458 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
459 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
460 MODEST_ACCOUNT_SIGNATURE, FALSE);
462 signature = g_strdup ("");
465 msg = modest_tny_msg_new ("", from_str, "", "", "", signature, NULL);
467 g_printerr ("modest: failed to create new msg\n");
471 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
473 g_printerr ("modest: failed to find Drafts folder\n");
477 /* tny_folder_add_msg (folder, msg, &err); */
479 /* g_printerr ("modest: error adding msg to Drafts folder: %s", */
481 /* g_error_free (err); */
485 /* Create and register edit window */
486 /* This is destroyed by TOOD. */
487 msg_win = modest_msg_edit_window_new (msg, account_name);
488 mgr = modest_runtime_get_window_mgr ();
489 modest_window_mgr_register_window (mgr, msg_win);
492 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
494 gtk_widget_show_all (GTK_WIDGET (msg_win));
497 g_free (account_name);
501 g_object_unref (G_OBJECT(account));
503 g_object_unref (G_OBJECT(msg));
505 g_object_unref (G_OBJECT(folder));
509 open_msg_cb (ModestMailOperation *mail_op,
514 ModestWindowMgr *mgr = NULL;
515 ModestWindow *parent_win = NULL;
516 ModestWindow *win = NULL;
517 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
518 gchar *account = NULL;
521 /* TODO: Show an error? (review the specs) */
525 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
526 folder = tny_header_get_folder (header);
528 /* Mark header as read */
529 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
532 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
534 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
536 /* Gets folder type (OUTBOX headers will be opened in edit window */
537 if (modest_tny_folder_is_local_folder (folder))
538 folder_type = modest_tny_folder_get_local_folder_type (folder);
540 /* If the header is in the drafts folder then open the editor,
541 else the message view window */
542 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
543 win = modest_msg_edit_window_new (msg, account);
545 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
546 GtkWidget *header_view;
547 GtkTreeSelection *sel;
548 GList *sel_list = NULL;
551 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
552 MODEST_WIDGET_TYPE_HEADER_VIEW);
554 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
555 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
557 if (sel_list != NULL) {
558 GtkTreeRowReference *row_reference;
560 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
561 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
562 g_list_free (sel_list);
564 win = modest_msg_view_window_new_with_header_model (msg,
568 gtk_tree_row_reference_free (row_reference);
570 win = modest_msg_view_window_new (msg, account);
573 win = modest_msg_view_window_new (msg, account);
577 /* Register and show new window */
579 mgr = modest_runtime_get_window_mgr ();
580 modest_window_mgr_register_window (mgr, win);
581 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
582 gtk_widget_show_all (GTK_WIDGET(win));
587 g_object_unref (msg);
588 g_object_unref (folder);
589 g_object_unref (header);
593 * This function is used by both modest_ui_actions_on_open and
594 * modest_ui_actions_on_header_activated. This way we always do the
595 * same when trying to open messages.
598 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
600 ModestWindowMgr *mgr;
602 ModestMailOperation *mail_op;
604 /* Look if we already have a message view for each header. If
605 true, then remove the header from the list of headers to
607 mgr = modest_runtime_get_window_mgr ();
608 iter = tny_list_create_iterator (headers);
609 while (!tny_iterator_is_done (iter)) {
610 ModestWindow *window;
613 header = TNY_HEADER (tny_iterator_get_current (iter));
614 window = modest_window_mgr_find_window_by_msguid (mgr, tny_header_get_uid (header));
616 tny_list_remove (headers, G_OBJECT (header));
618 g_object_unref (header);
619 tny_iterator_next (iter);
622 /* Open each message */
623 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT (win));
624 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
625 modest_mail_operation_get_msgs_full (mail_op,
632 g_object_unref(mail_op);
636 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
641 headers = get_selected_headers (win);
646 _modest_ui_actions_open (headers, win);
648 g_object_unref(headers);
653 free_reply_forward_helper (gpointer data)
655 ReplyForwardHelper *helper;
657 helper = (ReplyForwardHelper *) data;
658 g_free (helper->account_name);
659 g_slice_free (ReplyForwardHelper, helper);
663 reply_forward_cb (ModestMailOperation *mail_op,
669 ReplyForwardHelper *rf_helper;
670 ModestWindow *msg_win;
671 ModestEditType edit_type;
674 TnyFolder *folder = NULL;
675 TnyAccount *account = NULL;
676 ModestWindowMgr *mgr;
677 gchar *signature = NULL;
679 g_return_if_fail (user_data != NULL);
680 rf_helper = (ReplyForwardHelper *) user_data;
682 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
683 rf_helper->account_name);
684 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
685 rf_helper->account_name,
686 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
687 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
688 rf_helper->account_name,
689 MODEST_ACCOUNT_SIGNATURE, FALSE);
692 /* Create reply mail */
693 switch (rf_helper->action) {
696 modest_tny_msg_create_reply_msg (msg, from, signature,
697 rf_helper->reply_forward_type,
698 MODEST_TNY_MSG_REPLY_MODE_SENDER);
700 case ACTION_REPLY_TO_ALL:
702 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
703 MODEST_TNY_MSG_REPLY_MODE_ALL);
704 edit_type = MODEST_EDIT_TYPE_REPLY;
708 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
709 edit_type = MODEST_EDIT_TYPE_FORWARD;
712 g_return_if_reached ();
719 g_printerr ("modest: failed to create message\n");
723 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
724 rf_helper->account_name,
725 TNY_ACCOUNT_TYPE_STORE);
727 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
731 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
733 g_printerr ("modest: failed to find Drafts folder\n");
737 tny_folder_add_msg (folder, msg, &err);
739 g_printerr ("modest: error adding msg to Drafts folder: %s",
745 /* Create and register the windows */
746 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
747 mgr = modest_runtime_get_window_mgr ();
748 modest_window_mgr_register_window (mgr, msg_win);
750 /* Show edit window */
751 gtk_widget_show_all (GTK_WIDGET (msg_win));
755 g_object_unref (G_OBJECT (new_msg));
757 g_object_unref (G_OBJECT (folder));
759 g_object_unref (G_OBJECT (account));
760 g_object_unref (msg);
761 g_object_unref (header);
765 * Checks a list of headers. If any of them are not currently
766 * downloaded (CACHED) then it asks the user for permission to
769 * Returns FALSE if the user does not want to download the
770 * messages. Returns TRUE if the user allowed the download or if all
771 * of them are currently downloaded
774 download_uncached_messages (TnyList *header_list, GtkWindow *win)
777 gboolean found, retval;
779 iter = tny_list_create_iterator (header_list);
781 while (!tny_iterator_is_done (iter) && !found) {
783 TnyHeaderFlags flags;
785 header = TNY_HEADER (tny_iterator_get_current (iter));
786 flags = tny_header_get_flags (header);
787 found = !(flags & TNY_HEADER_FLAG_CACHED);
788 g_object_unref (header);
789 tny_iterator_next (iter);
791 g_object_unref (iter);
793 /* Ask for user permission to download the messages */
796 GtkResponseType response;
798 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
799 _("mcen_nc_get_multi_msg_txt"));
800 if (response == GTK_RESPONSE_CANCEL)
808 * Common code for the reply and forward actions
811 reply_forward (ReplyForwardAction action, ModestWindow *win)
813 ModestMailOperation *mail_op = NULL;
814 TnyList *header_list = NULL;
815 ReplyForwardHelper *rf_helper = NULL;
816 guint reply_forward_type;
817 gboolean continue_download;
819 g_return_if_fail (MODEST_IS_WINDOW(win));
821 header_list = get_selected_headers (win);
825 /* Check that the messages have been previously downloaded */
826 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
827 if (!continue_download) {
828 g_object_unref (header_list);
833 modest_conf_get_int (modest_runtime_get_conf (),
834 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
836 /* We assume that we can only select messages of the
837 same folder and that we reply all of them from the
838 same account. In fact the interface currently only
839 allows single selection */
842 rf_helper = g_slice_new0 (ReplyForwardHelper);
843 rf_helper->reply_forward_type = reply_forward_type;
844 rf_helper->action = action;
845 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
846 if (!rf_helper->account_name)
847 rf_helper->account_name =
848 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
850 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
853 /* Get header and message. Do not free them here, the
854 reply_forward_cb must do it */
855 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
856 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
857 if (!msg || !header) {
859 g_object_unref (msg);
861 g_object_unref (header);
862 g_printerr ("modest: no message found\n");
865 reply_forward_cb (NULL, header, msg, rf_helper);
867 /* Retrieve messages */
868 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
869 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
870 modest_mail_operation_get_msgs_full (mail_op,
874 free_reply_forward_helper);
877 g_object_unref(mail_op);
881 g_object_unref (header_list);
885 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
887 g_return_if_fail (MODEST_IS_WINDOW(win));
889 reply_forward (ACTION_REPLY, win);
893 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
895 g_return_if_fail (MODEST_IS_WINDOW(win));
897 reply_forward (ACTION_FORWARD, win);
901 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
903 g_return_if_fail (MODEST_IS_WINDOW(win));
905 reply_forward (ACTION_REPLY_TO_ALL, win);
909 modest_ui_actions_on_next (GtkAction *action,
910 ModestWindow *window)
912 if (MODEST_IS_MAIN_WINDOW (window)) {
913 GtkWidget *header_view;
915 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
916 MODEST_WIDGET_TYPE_HEADER_VIEW);
920 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
921 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
922 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
924 g_return_if_reached ();
929 modest_ui_actions_on_prev (GtkAction *action,
930 ModestWindow *window)
932 g_return_if_fail (MODEST_IS_WINDOW(window));
934 if (MODEST_IS_MAIN_WINDOW (window)) {
935 GtkWidget *header_view;
936 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
937 MODEST_WIDGET_TYPE_HEADER_VIEW);
941 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
942 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
943 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
945 g_return_if_reached ();
950 modest_ui_actions_on_sort (GtkAction *action,
951 ModestWindow *window)
953 g_return_if_fail (MODEST_IS_WINDOW(window));
955 if (MODEST_IS_MAIN_WINDOW (window)) {
956 GtkWidget *header_view;
957 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
958 MODEST_WIDGET_TYPE_HEADER_VIEW);
962 /* Show sorting dialog */
963 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
968 * This function performs the send & receive required actions. The
969 * window is used to create the mail operation. Typically it should
970 * always be the main window, but we pass it as argument in order to
974 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
976 gchar *acc_name = NULL;
977 ModestMailOperation *mail_op;
979 /* If no account name was provided then get the current account, and if
980 there is no current account then pick the default one: */
982 acc_name = g_strdup (modest_window_get_active_account(win));
984 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
986 g_printerr ("modest: cannot get default account\n");
990 acc_name = g_strdup (account_name);
993 /* Send & receive. */
994 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
995 /* Receive and then send. The operation is tagged initially as
996 a receive operation because the account update performs a
997 receive and then a send. The operation changes its type
998 internally, so the progress objects will receive the proper
999 progress information */
1000 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
1001 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1002 modest_mail_operation_update_account (mail_op, acc_name);
1003 g_object_unref (G_OBJECT (mail_op));
1010 * Refreshes all accounts. This function will be used by automatic
1014 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1016 GSList *account_names, *iter;
1018 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1021 iter = account_names;
1023 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1024 iter = g_slist_next (iter);
1027 g_slist_foreach (account_names, (GFunc) g_free, NULL);
1028 g_slist_free (account_names);
1032 * Handler of the click on Send&Receive button in the main toolbar
1035 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1037 /* Check that at least one account exists: */
1038 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1039 TRUE /* enabled accounts only */);
1040 gboolean accounts_exist = account_names != NULL;
1041 g_slist_free (account_names);
1043 /* If not, allow the user to create an account before trying to send/receive. */
1044 if (!accounts_exist)
1045 modest_ui_actions_on_accounts (NULL, win);
1047 /* Refresh the active account */
1048 modest_ui_actions_do_send_receive (NULL, win);
1053 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1056 GtkWidget *header_view;
1058 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1060 header_view = modest_main_window_get_child_widget (main_window,
1061 MODEST_WIDGET_TYPE_HEADER_VIEW);
1065 conf = modest_runtime_get_conf ();
1067 /* what is saved/restored is depending on the style; thus; we save with
1068 * old style, then update the style, and restore for this new style
1070 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1072 if (modest_header_view_get_style
1073 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1074 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1075 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1077 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1078 MODEST_HEADER_VIEW_STYLE_DETAILS);
1080 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1081 MODEST_CONF_HEADER_VIEW_KEY);
1086 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1088 ModestMainWindow *main_window)
1090 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1092 /* If no header has been selected then exit */
1096 /* Update Main window title */
1097 if (GTK_WIDGET_HAS_FOCUS (header_view)) {
1098 const gchar *subject = tny_header_get_subject (header);
1099 if (subject && strcmp (subject, ""))
1100 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1102 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1107 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1109 ModestMainWindow *main_window)
1113 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1118 headers = tny_simple_list_new ();
1119 tny_list_prepend (headers, G_OBJECT (header));
1121 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1123 g_object_unref (headers);
1127 set_active_account_from_tny_account (TnyAccount *account,
1128 ModestWindow *window)
1130 const gchar *server_acc_name = tny_account_get_id (account);
1132 /* We need the TnyAccount provided by the
1133 account store because that is the one that
1134 knows the name of the Modest account */
1135 TnyAccount *modest_server_account = modest_server_account =
1136 modest_tny_account_store_get_tny_account_by_id (modest_runtime_get_account_store (),
1139 const gchar *modest_acc_name =
1140 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1141 modest_window_set_active_account (window, modest_acc_name);
1142 g_object_unref (modest_server_account);
1146 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1147 TnyFolderStore *folder_store,
1149 ModestMainWindow *main_window)
1152 GtkWidget *header_view;
1154 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1156 header_view = modest_main_window_get_child_widget(main_window,
1157 MODEST_WIDGET_TYPE_HEADER_VIEW);
1161 conf = modest_runtime_get_conf ();
1163 if (TNY_IS_ACCOUNT (folder_store)) {
1164 /* Update active account */
1165 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1166 /* Show account details */
1167 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1168 } else if (modest_tny_folder_store_is_virtual_local_folders (folder_store )) {
1169 printf ("DEBUG: %s: folder store.\n", __FUNCTION__);
1170 //TODO: Set the virtual folder store as the "active account" somehow:
1171 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1173 if (TNY_IS_FOLDER (folder_store) && selected) {
1175 if (!TNY_IS_MERGE_FOLDER (folder_store)) { /* TnyMergeFolder can have no get_account() implementation. */
1176 /* Update the active account */
1177 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder_store));
1178 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1179 g_object_unref (account);
1182 /* Set folder on header view */
1183 modest_main_window_set_contents_style (main_window,
1184 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1185 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1186 TNY_FOLDER (folder_store));
1187 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1188 MODEST_CONF_HEADER_VIEW_KEY);
1190 /* Update the active account */
1191 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1192 /* Do not show folder */
1193 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1194 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
1200 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1207 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1209 if (g_main_depth > 0)
1210 gdk_threads_enter ();
1211 online = tny_device_is_online (modest_runtime_get_device());
1214 /* already online -- the item is simply not there... */
1215 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1217 GTK_MESSAGE_WARNING,
1219 _("The %s you selected cannot be found"),
1221 gtk_dialog_run (GTK_DIALOG(dialog));
1223 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1227 GTK_RESPONSE_REJECT,
1229 GTK_RESPONSE_ACCEPT,
1231 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1232 "Do you want to get online?"), item);
1233 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1234 gtk_label_new (txt), FALSE, FALSE, 0);
1235 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1238 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1239 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1240 // modest_platform_connect_and_wait ();;
1243 gtk_widget_destroy (dialog);
1244 if (g_main_depth > 0)
1245 gdk_threads_leave ();
1249 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1252 /* g_message ("%s %s", __FUNCTION__, link); */
1257 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1260 modest_platform_activate_uri (link);
1264 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1267 modest_platform_show_uri_popup (link);
1271 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1274 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1278 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1279 const gchar *address,
1282 /* g_message ("%s %s", __FUNCTION__, address); */
1286 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1288 TnyTransportAccount *transport_account;
1289 ModestMailOperation *mail_operation;
1291 gchar *account_name, *from;
1292 ModestAccountMgr *account_mgr;
1294 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1296 data = modest_msg_edit_window_get_msg_data (edit_window);
1298 account_mgr = modest_runtime_get_account_mgr();
1299 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1301 account_name = modest_account_mgr_get_default_account (account_mgr);
1302 if (!account_name) {
1303 g_printerr ("modest: no account found\n");
1304 modest_msg_edit_window_free_msg_data (edit_window, data);
1308 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
1309 (modest_runtime_get_account_store(),
1311 TNY_ACCOUNT_TYPE_TRANSPORT));
1312 if (!transport_account) {
1313 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1314 g_free (account_name);
1315 modest_msg_edit_window_free_msg_data (edit_window, data);
1318 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1320 /* Create the mail operation */
1321 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1322 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1324 modest_mail_operation_save_to_drafts (mail_operation,
1334 data->priority_flags);
1337 g_free (account_name);
1338 g_object_unref (G_OBJECT (transport_account));
1339 g_object_unref (G_OBJECT (mail_operation));
1341 modest_msg_edit_window_free_msg_data (edit_window, data);
1343 /* Save settings and close the window */
1344 gtk_widget_destroy (GTK_WIDGET (edit_window));
1347 /* For instance, when clicking the Send toolbar button when editing a message: */
1349 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1351 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1353 if (!modest_msg_edit_window_check_names (edit_window))
1356 /* FIXME: Code added just for testing. The final version will
1357 use the send queue provided by tinymail and some
1359 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1360 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1362 account_name = modest_account_mgr_get_default_account (account_mgr);
1364 if (!account_name) {
1365 g_printerr ("modest: no account found\n");
1369 /* Get the currently-active transport account for this modest account: */
1370 TnyTransportAccount *transport_account =
1371 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1372 (modest_runtime_get_account_store(),
1374 if (!transport_account) {
1375 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1376 g_free (account_name);
1380 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1382 /* Create the mail operation */
1383 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1384 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1386 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1387 modest_mail_operation_send_new_mail (mail_operation,
1397 data->priority_flags);
1401 g_free (account_name);
1402 g_object_unref (G_OBJECT (transport_account));
1403 g_object_unref (G_OBJECT (mail_operation));
1405 modest_msg_edit_window_free_msg_data (edit_window, data);
1407 /* Save settings and close the window: */
1408 gtk_widget_destroy (GTK_WIDGET (edit_window));
1412 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1413 ModestMsgEditWindow *window)
1415 ModestMsgEditFormatState *format_state = NULL;
1417 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1418 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1420 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1423 format_state = modest_msg_edit_window_get_format_state (window);
1424 g_return_if_fail (format_state != NULL);
1426 format_state->bold = gtk_toggle_action_get_active (action);
1427 modest_msg_edit_window_set_format_state (window, format_state);
1428 g_free (format_state);
1433 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1434 ModestMsgEditWindow *window)
1436 ModestMsgEditFormatState *format_state = NULL;
1438 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1439 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1441 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1444 format_state = modest_msg_edit_window_get_format_state (window);
1445 g_return_if_fail (format_state != NULL);
1447 format_state->italics = gtk_toggle_action_get_active (action);
1448 modest_msg_edit_window_set_format_state (window, format_state);
1449 g_free (format_state);
1454 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1455 ModestMsgEditWindow *window)
1457 ModestMsgEditFormatState *format_state = NULL;
1459 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1460 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1462 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1465 format_state = modest_msg_edit_window_get_format_state (window);
1466 g_return_if_fail (format_state != NULL);
1468 format_state->bullet = gtk_toggle_action_get_active (action);
1469 modest_msg_edit_window_set_format_state (window, format_state);
1470 g_free (format_state);
1475 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1476 GtkRadioAction *selected,
1477 ModestMsgEditWindow *window)
1479 ModestMsgEditFormatState *format_state = NULL;
1480 GtkJustification value;
1482 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1484 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1487 value = gtk_radio_action_get_current_value (selected);
1489 format_state = modest_msg_edit_window_get_format_state (window);
1490 g_return_if_fail (format_state != NULL);
1492 format_state->justification = value;
1493 modest_msg_edit_window_set_format_state (window, format_state);
1494 g_free (format_state);
1498 modest_ui_actions_on_select_editor_color (GtkAction *action,
1499 ModestMsgEditWindow *window)
1501 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1502 g_return_if_fail (GTK_IS_ACTION (action));
1504 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1507 modest_msg_edit_window_select_color (window);
1511 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1512 ModestMsgEditWindow *window)
1514 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1515 g_return_if_fail (GTK_IS_ACTION (action));
1517 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1520 modest_msg_edit_window_select_background_color (window);
1524 modest_ui_actions_on_insert_image (GtkAction *action,
1525 ModestMsgEditWindow *window)
1527 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1528 g_return_if_fail (GTK_IS_ACTION (action));
1530 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1533 modest_msg_edit_window_insert_image (window);
1537 modest_ui_actions_on_attach_file (GtkAction *action,
1538 ModestMsgEditWindow *window)
1540 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1541 g_return_if_fail (GTK_IS_ACTION (action));
1543 modest_msg_edit_window_attach_file (window);
1547 modest_ui_actions_on_remove_attachments (GtkAction *action,
1548 ModestMsgEditWindow *window)
1550 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1551 g_return_if_fail (GTK_IS_ACTION (action));
1553 modest_msg_edit_window_remove_attachments (window, NULL);
1557 * Shows a dialog with an entry that asks for some text. The returned
1558 * value must be freed by the caller. The dialog window title will be
1562 ask_for_folder_name (GtkWindow *parent_window,
1565 GtkWidget *dialog, *entry;
1566 gchar *folder_name = NULL;
1568 /* Ask for folder name */
1569 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1573 GTK_RESPONSE_REJECT,
1575 GTK_RESPONSE_ACCEPT,
1577 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1578 gtk_label_new(title),
1581 entry = gtk_entry_new_with_max_length (40);
1582 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1586 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1588 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1589 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1591 gtk_widget_destroy (dialog);
1597 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1599 TnyFolderStore *parent_folder;
1600 GtkWidget *folder_view;
1602 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1604 folder_view = modest_main_window_get_child_widget (main_window,
1605 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1609 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1611 if (parent_folder) {
1612 gboolean finished = FALSE;
1614 gchar *folder_name = NULL, *suggested_name = NULL;
1616 /* Run the new folder dialog */
1618 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1623 if (result == GTK_RESPONSE_REJECT) {
1626 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1627 TnyFolder *new_folder = NULL;
1629 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1632 new_folder = modest_mail_operation_create_folder (mail_op,
1634 (const gchar *) folder_name);
1636 g_object_unref (new_folder);
1640 /* /\* TODO: check error and follow proper actions *\/ */
1641 /* /\* suggested_name = X; *\/ */
1642 /* /\* Show error to the user *\/ */
1643 /* modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1644 /* _("mail_in_ui_folder_create_error")); */
1646 g_object_unref (mail_op);
1648 g_free (folder_name);
1652 g_object_unref (parent_folder);
1657 modest_ui_actions_on_rename_folder (GtkAction *action,
1658 ModestMainWindow *main_window)
1660 TnyFolderStore *folder;
1661 GtkWidget *folder_view;
1662 GtkWidget *header_view;
1664 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1666 folder_view = modest_main_window_get_child_widget (main_window,
1667 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1671 header_view = modest_main_window_get_child_widget (main_window,
1672 MODEST_WIDGET_TYPE_HEADER_VIEW);
1677 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1679 if (folder && TNY_IS_FOLDER (folder)) {
1681 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1682 _("Please enter a new name for the folder"));
1684 if (folder_name != NULL && strlen (folder_name) > 0) {
1685 ModestMailOperation *mail_op;
1687 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1688 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1691 modest_header_view_set_folder (MODEST_HEADER_VIEW (header_view), NULL);
1693 modest_mail_operation_rename_folder (mail_op,
1694 TNY_FOLDER (folder),
1695 (const gchar *) folder_name);
1697 g_object_unref (mail_op);
1698 g_free (folder_name);
1700 g_object_unref (folder);
1705 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1707 TnyFolderStore *folder;
1708 GtkWidget *folder_view;
1712 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1714 folder_view = modest_main_window_get_child_widget (main_window,
1715 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1719 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1721 /* Show an error if it's an account */
1722 if (!TNY_IS_FOLDER (folder)) {
1723 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1724 _("mail_in_ui_folder_delete_error"));
1729 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1730 tny_folder_get_name (TNY_FOLDER (folder)));
1731 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1732 (const gchar *) message);
1735 if (response == GTK_RESPONSE_OK) {
1736 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(main_window));
1738 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1740 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1742 /* Show error if happened */
1743 if (modest_mail_operation_get_error (mail_op))
1744 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1745 _("mail_in_ui_folder_delete_error"));
1747 g_object_unref (G_OBJECT (mail_op));
1750 g_object_unref (G_OBJECT (folder));
1754 modest_ui_actions_on_delete_folder (GtkAction *action,
1755 ModestMainWindow *main_window)
1757 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1759 delete_folder (main_window, FALSE);
1763 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1765 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1767 delete_folder (main_window, TRUE);
1771 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1772 const gchar* server_account_name,
1777 ModestMainWindow *main_window)
1779 g_return_if_fail(server_account_name);
1780 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1782 /* Initalize output parameters: */
1789 #ifdef MODEST_PLATFORM_MAEMO
1790 /* Maemo uses a different (awkward) button order,
1791 * It should probably just use gtk_alternative_dialog_button_order ().
1793 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1797 GTK_RESPONSE_ACCEPT,
1799 GTK_RESPONSE_REJECT,
1802 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1806 GTK_RESPONSE_REJECT,
1808 GTK_RESPONSE_ACCEPT,
1810 #endif /* MODEST_PLATFORM_MAEMO */
1812 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1814 gchar *server_name = modest_server_account_get_hostname (
1815 modest_runtime_get_account_mgr(), server_account_name);
1817 /* This causes a warning because the logical ID has no %s in it,
1818 * though the translation does, but there is not much we can do about that: */
1819 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
1820 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1823 g_free (server_name);
1827 gchar *initial_username = modest_server_account_get_username (
1828 modest_runtime_get_account_mgr(), server_account_name);
1830 GtkWidget *entry_username = gtk_entry_new ();
1831 if (initial_username)
1832 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
1833 /* Dim this if a connection has ever succeeded with this username,
1834 * as per the UI spec: */
1835 const gboolean username_known =
1836 modest_server_account_get_username_has_succeeded(
1837 modest_runtime_get_account_mgr(), server_account_name);
1838 gtk_widget_set_sensitive (entry_username, !username_known);
1840 #ifdef MODEST_PLATFORM_MAEMO
1841 /* Auto-capitalization is the default, so let's turn it off: */
1842 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
1844 /* Create a size group to be used by all captions.
1845 * Note that HildonCaption does not create a default size group if we do not specify one.
1846 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
1847 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1849 GtkWidget *caption = hildon_caption_new (sizegroup,
1850 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
1851 gtk_widget_show (entry_username);
1852 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1853 FALSE, FALSE, MODEST_MARGIN_HALF);
1854 gtk_widget_show (caption);
1856 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
1858 #endif /* MODEST_PLATFORM_MAEMO */
1861 GtkWidget *entry_password = gtk_entry_new ();
1862 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
1863 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
1865 #ifdef MODEST_PLATFORM_MAEMO
1866 /* Auto-capitalization is the default, so let's turn it off: */
1867 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
1868 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
1870 caption = hildon_caption_new (sizegroup,
1871 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
1872 gtk_widget_show (entry_password);
1873 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1874 FALSE, FALSE, MODEST_MARGIN_HALF);
1875 gtk_widget_show (caption);
1876 g_object_unref (sizegroup);
1878 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
1880 #endif /* MODEST_PLATFORM_MAEMO */
1882 /* This is not in the Maemo UI spec:
1883 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1884 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1888 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1890 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1892 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
1894 modest_server_account_set_username (
1895 modest_runtime_get_account_mgr(), server_account_name,
1898 const gboolean username_was_changed =
1899 (strcmp (*username, initial_username) != 0);
1900 if (username_was_changed) {
1901 /* To actually use a changed username,
1902 * we must reset the connection, according to pvanhoof.
1903 * This _might_ be a sensible way to do that: */
1904 TnyDevice *device = modest_runtime_get_device();
1905 tny_device_force_offline (device);
1906 tny_device_force_online (device);
1911 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
1913 /* We do not save the password in the configuration,
1914 * because this function is only called for passwords that should
1915 * not be remembered:
1916 modest_server_account_set_password (
1917 modest_runtime_get_account_mgr(), server_account_name,
1936 /* This is not in the Maemo UI spec:
1937 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1943 gtk_widget_destroy (dialog);
1945 printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel);
1949 modest_ui_actions_on_cut (GtkAction *action,
1950 ModestWindow *window)
1952 GtkWidget *focused_widget;
1954 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1955 if (GTK_IS_EDITABLE (focused_widget)) {
1956 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1957 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1958 GtkTextBuffer *buffer;
1959 GtkClipboard *clipboard;
1961 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1962 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1963 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1968 modest_ui_actions_on_copy (GtkAction *action,
1969 ModestWindow *window)
1971 GtkClipboard *clipboard;
1972 GtkWidget *focused_widget;
1974 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1975 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1976 if (GTK_IS_LABEL (focused_widget)) {
1977 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1978 } else if (GTK_IS_EDITABLE (focused_widget)) {
1979 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1980 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1981 GtkTextBuffer *buffer;
1983 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1984 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1989 modest_ui_actions_on_undo (GtkAction *action,
1990 ModestWindow *window)
1992 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1993 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1995 g_return_if_reached ();
2000 modest_ui_actions_on_paste (GtkAction *action,
2001 ModestWindow *window)
2003 GtkWidget *focused_widget;
2005 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2006 if (GTK_IS_EDITABLE (focused_widget)) {
2007 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2008 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2009 GtkTextBuffer *buffer;
2010 GtkClipboard *clipboard;
2012 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
2013 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2014 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2019 modest_ui_actions_on_select_all (GtkAction *action,
2020 ModestWindow *window)
2022 GtkWidget *focused_widget;
2024 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2025 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2026 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2027 } else if (GTK_IS_LABEL (focused_widget)) {
2028 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2029 } else if (GTK_IS_EDITABLE (focused_widget)) {
2030 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2031 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2032 GtkTextBuffer *buffer;
2033 GtkTextIter start, end;
2035 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2036 gtk_text_buffer_get_start_iter (buffer, &start);
2037 gtk_text_buffer_get_end_iter (buffer, &end);
2038 gtk_text_buffer_select_range (buffer, &start, &end);
2043 modest_ui_actions_on_mark_as_read (GtkAction *action,
2044 ModestWindow *window)
2046 g_return_if_fail (MODEST_IS_WINDOW(window));
2048 /* Mark each header as read */
2049 do_headers_action (window, headers_action_mark_as_read, NULL);
2053 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2054 ModestWindow *window)
2056 g_return_if_fail (MODEST_IS_WINDOW(window));
2058 /* Mark each header as read */
2059 do_headers_action (window, headers_action_mark_as_unread, NULL);
2063 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2064 GtkRadioAction *selected,
2065 ModestWindow *window)
2069 value = gtk_radio_action_get_current_value (selected);
2070 if (MODEST_IS_WINDOW (window)) {
2071 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2075 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2076 GtkRadioAction *selected,
2077 ModestWindow *window)
2079 TnyHeaderFlags flags;
2080 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2082 flags = gtk_radio_action_get_current_value (selected);
2083 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2086 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2087 GtkRadioAction *selected,
2088 ModestWindow *window)
2092 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2094 file_format = gtk_radio_action_get_current_value (selected);
2095 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2100 modest_ui_actions_on_zoom_plus (GtkAction *action,
2101 ModestWindow *window)
2103 g_return_if_fail (MODEST_IS_WINDOW (window));
2105 modest_window_zoom_plus (MODEST_WINDOW (window));
2109 modest_ui_actions_on_zoom_minus (GtkAction *action,
2110 ModestWindow *window)
2112 g_return_if_fail (MODEST_IS_WINDOW (window));
2114 modest_window_zoom_minus (MODEST_WINDOW (window));
2118 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2119 ModestWindow *window)
2121 ModestWindowMgr *mgr;
2122 gboolean fullscreen, active;
2123 g_return_if_fail (MODEST_IS_WINDOW (window));
2125 mgr = modest_runtime_get_window_mgr ();
2127 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2128 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2130 if (active != fullscreen) {
2131 modest_window_mgr_set_fullscreen_mode (mgr, active);
2132 gtk_window_present (GTK_WINDOW (window));
2137 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2138 ModestWindow *window)
2140 ModestWindowMgr *mgr;
2141 gboolean fullscreen;
2143 g_return_if_fail (MODEST_IS_WINDOW (window));
2145 mgr = modest_runtime_get_window_mgr ();
2146 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2147 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2149 gtk_window_present (GTK_WINDOW (window));
2153 * Used by modest_ui_actions_on_details to call do_headers_action
2156 headers_action_show_details (TnyHeader *header,
2157 ModestWindow *window,
2164 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2167 gtk_widget_show_all (dialog);
2168 gtk_dialog_run (GTK_DIALOG (dialog));
2170 gtk_widget_destroy (dialog);
2174 * Show the folder details in a ModestDetailsDialog widget
2177 show_folder_details (TnyFolder *folder,
2183 dialog = modest_details_dialog_new_with_folder (window, folder);
2186 gtk_widget_show_all (dialog);
2187 gtk_dialog_run (GTK_DIALOG (dialog));
2189 gtk_widget_destroy (dialog);
2193 * Show the header details in a ModestDetailsDialog widget
2196 modest_ui_actions_on_details (GtkAction *action,
2199 TnyList * headers_list;
2203 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2206 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2209 g_object_unref (msg);
2211 headers_list = get_selected_headers (win);
2215 iter = tny_list_create_iterator (headers_list);
2217 header = TNY_HEADER (tny_iterator_get_current (iter));
2218 headers_action_show_details (header, win, NULL);
2219 g_object_unref (header);
2221 g_object_unref (iter);
2222 g_object_unref (headers_list);
2224 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2225 GtkWidget *folder_view, *header_view;
2227 /* Check which widget has the focus */
2228 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2229 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2230 if (gtk_widget_is_focus (folder_view)) {
2233 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2235 /* Show only when it's a folder */
2236 if (!folder || !TNY_IS_FOLDER (folder))
2239 show_folder_details (folder, GTK_WINDOW (win));
2242 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2243 MODEST_WIDGET_TYPE_HEADER_VIEW);
2244 /* Show details of each header */
2245 do_headers_action (win, headers_action_show_details, header_view);
2251 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2252 ModestMsgEditWindow *window)
2254 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2256 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2260 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2261 ModestMsgEditWindow *window)
2263 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2265 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2269 modest_ui_actions_toggle_folders_view (GtkAction *action,
2270 ModestMainWindow *main_window)
2274 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2276 conf = modest_runtime_get_conf ();
2278 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2279 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2281 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2285 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2286 ModestWindow *window)
2288 gboolean active, fullscreen = FALSE;
2289 ModestWindowMgr *mgr;
2291 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2293 /* Check if we want to toggle the toolbar vuew in fullscreen
2295 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2296 "ViewShowToolbarFullScreen")) {
2300 /* Toggle toolbar */
2301 mgr = modest_runtime_get_window_mgr ();
2302 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2306 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2307 ModestMsgEditWindow *window)
2309 modest_msg_edit_window_select_font (window);
2313 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2314 const gchar *display_name,
2317 /* Do not change the application name if the widget has not
2318 the focus. This callback could be called even if the folder
2319 view has not the focus, because the handled signal could be
2320 emitted when the folder view is redrawn */
2321 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2323 gtk_window_set_title (window, display_name);
2325 gtk_window_set_title (window, " ");
2330 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2332 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2333 modest_msg_edit_window_select_contacts (window);
2337 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2339 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2340 modest_msg_edit_window_check_names (window);
2345 create_move_to_dialog (ModestWindow *win,
2346 GtkWidget *folder_view,
2347 GtkWidget **tree_view)
2349 GtkWidget *dialog, *scroll;
2351 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2353 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2355 GTK_RESPONSE_ACCEPT,
2357 GTK_RESPONSE_REJECT,
2360 /* Create scrolled window */
2361 scroll = gtk_scrolled_window_new (NULL, NULL);
2362 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2363 GTK_POLICY_AUTOMATIC,
2364 GTK_POLICY_AUTOMATIC);
2366 /* Create folder view */
2367 *tree_view = modest_folder_view_new (NULL);
2368 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2369 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2370 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2372 /* Add scroll to dialog */
2373 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2374 scroll, FALSE, FALSE, 0);
2376 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2382 * Returns TRUE if at least one of the headers of the list belongs to
2383 * a message that has been fully retrieved.
2386 has_retrieved_msgs (TnyList *list)
2389 gboolean found = FALSE;
2391 iter = tny_list_create_iterator (list);
2392 while (tny_iterator_is_done (iter) && !found) {
2394 TnyHeaderFlags flags;
2396 header = TNY_HEADER (tny_iterator_get_current (iter));
2397 flags = tny_header_get_flags (header);
2398 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2402 tny_iterator_next (iter);
2404 g_object_unref (iter);
2410 * Shows a confirmation dialog to the user when we're moving messages
2411 * from a remote server to the local storage. Returns the dialog
2412 * response. If it's other kind of movement the it always returns
2416 msgs_move_to_confirmation (GtkWindow *win,
2417 TnyFolder *dest_folder,
2420 gint response = GTK_RESPONSE_OK;
2422 /* If the destination is a local folder */
2423 if (modest_tny_folder_is_local_folder (dest_folder)) {
2424 TnyFolder *src_folder;
2428 /* Get source folder */
2429 iter = tny_list_create_iterator (headers);
2430 header = TNY_HEADER (tny_iterator_get_current (iter));
2431 src_folder = tny_header_get_folder (header);
2432 g_object_unref (header);
2433 g_object_unref (iter);
2435 /* If the source is a remote folder */
2436 if (!modest_tny_folder_is_local_folder (src_folder)) {
2437 const gchar *message;
2439 if (tny_list_get_length (headers) == 1)
2440 if (has_retrieved_msgs (headers))
2441 message = _("mcen_nc_move_retrieve");
2443 message = _("mcen_nc_move_header");
2445 if (has_retrieved_msgs (headers))
2446 message = _("mcen_nc_move_retrieves");
2448 message = _("mcen_nc_move_headers");
2450 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2451 (const gchar *) message);
2453 g_object_unref (src_folder);
2460 tranasfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2462 ModestMsgViewWindow *self = NULL;
2463 gboolean found = FALSE;
2465 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2466 self = MODEST_MSG_VIEW_WINDOW (object);
2468 found = modest_msg_view_window_select_first_message (self);
2469 g_return_if_fail (found);
2473 move_to_error_checking (const GObject *obj, gpointer user_data)
2475 ModestWindow *win = NULL;
2477 g_return_if_fail (MODEST_IS_WINDOW (obj));
2478 win = MODEST_WINDOW (obj);
2480 /* TODO: show error message */
2481 /* modest_platform_run_information_dialog (GTK_WINDOW (win), */
2482 /* _("mail_in_ui_folder_move_target_error")); */
2486 * UI handler for the "Move to" action when invoked from the
2490 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2491 ModestMainWindow *win)
2493 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2494 GtkWidget *header_view = NULL;
2496 TnyFolderStore *folder_store = NULL;
2497 ModestMailOperation *mail_op = NULL;
2499 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2501 /* Get the folder view */
2502 folder_view = modest_main_window_get_child_widget (win,
2503 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2505 /* Get header view */
2506 header_view = modest_main_window_get_child_widget (win,
2507 MODEST_WIDGET_TYPE_HEADER_VIEW);
2509 /* Create and run the dialog */
2510 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2511 result = gtk_dialog_run (GTK_DIALOG(dialog));
2512 g_object_ref (tree_view);
2514 /* We do this to save an indentation level ;-) */
2515 if (result != GTK_RESPONSE_ACCEPT)
2518 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2520 if (TNY_IS_ACCOUNT (folder_store))
2523 /* Get folder or messages to transfer */
2524 if (gtk_widget_is_focus (folder_view)) {
2525 TnyFolderStore *src_folder;
2526 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2528 /* Clean folder on header view before moving it */
2529 modest_header_view_set_folder (MODEST_HEADER_VIEW (header_view), NULL);
2531 if (TNY_IS_FOLDER (src_folder)) {
2532 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2534 move_to_error_checking);
2535 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2538 modest_mail_operation_xfer_folder (mail_op,
2539 TNY_FOLDER (src_folder),
2542 g_object_unref (G_OBJECT (mail_op));
2547 g_object_unref (G_OBJECT (src_folder));
2549 if (gtk_widget_is_focus (header_view)) {
2553 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2555 /* Ask for user confirmation */
2556 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2557 TNY_FOLDER (folder_store),
2560 /* Transfer messages */
2561 if (response == GTK_RESPONSE_OK) {
2562 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2563 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2566 modest_mail_operation_xfer_msgs (mail_op,
2568 TNY_FOLDER (folder_store),
2572 g_object_unref (G_OBJECT (mail_op));
2574 g_object_unref (headers);
2577 g_object_unref (folder_store);
2580 gtk_widget_destroy (dialog);
2585 * UI handler for the "Move to" action when invoked from the
2586 * ModestMsgViewWindow
2589 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2590 ModestMsgViewWindow *win)
2592 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2594 ModestMainWindow *main_window;
2598 /* Get the folder view */
2599 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2600 folder_view = modest_main_window_get_child_widget (main_window,
2601 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2603 /* Create and run the dialog */
2604 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2605 result = gtk_dialog_run (GTK_DIALOG(dialog));
2606 g_object_ref (tree_view);
2608 if (result == GTK_RESPONSE_ACCEPT) {
2609 TnyFolderStore *folder_store;
2612 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2614 /* Create header list */
2615 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2616 headers = tny_simple_list_new ();
2617 tny_list_prepend (headers, G_OBJECT (header));
2618 g_object_unref (header);
2620 /* Ask user for confirmation. MSG-NOT404 */
2621 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2622 TNY_FOLDER (folder_store),
2625 /* Transfer current msg */
2626 if (response == GTK_RESPONSE_OK) {
2627 ModestMailOperation *mail_op;
2629 /* Create mail op */
2630 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2631 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2634 /* Transfer messages */
2635 modest_mail_operation_xfer_msgs (mail_op,
2637 TNY_FOLDER (folder_store),
2639 tranasfer_msgs_from_viewer_cb,
2641 g_object_unref (G_OBJECT (mail_op));
2643 g_object_unref (headers);
2644 g_object_unref (folder_store);
2646 gtk_widget_destroy (dialog);
2650 modest_ui_actions_on_move_to (GtkAction *action,
2653 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2654 MODEST_IS_MSG_VIEW_WINDOW (win));
2656 if (MODEST_IS_MAIN_WINDOW (win))
2657 modest_ui_actions_on_main_window_move_to (action,
2658 MODEST_MAIN_WINDOW (win));
2660 modest_ui_actions_on_msg_view_window_move_to (action,
2661 MODEST_MSG_VIEW_WINDOW (win));
2665 * Calls #HeadersFunc for each header already selected in the main
2666 * window or the message currently being shown in the msg view window
2669 do_headers_action (ModestWindow *win,
2673 TnyList *headers_list;
2677 headers_list = get_selected_headers (win);
2681 /* Call the function for each header */
2682 iter = tny_list_create_iterator (headers_list);
2683 while (!tny_iterator_is_done (iter)) {
2686 header = TNY_HEADER (tny_iterator_get_current (iter));
2687 func (header, win, user_data);
2688 g_object_unref (header);
2689 tny_iterator_next (iter);
2691 g_object_unref (iter);
2692 g_object_unref (headers_list);
2696 modest_ui_actions_view_attachment (GtkAction *action,
2697 ModestWindow *window)
2699 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2700 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
2702 /* not supported window for this action */
2703 g_return_if_reached ();
2708 modest_ui_actions_save_attachments (GtkAction *action,
2709 ModestWindow *window)
2711 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2712 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2714 /* not supported window for this action */
2715 g_return_if_reached ();
2720 modest_ui_actions_remove_attachments (GtkAction *action,
2721 ModestWindow *window)
2723 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2724 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2726 /* not supported window for this action */
2727 g_return_if_reached ();
2732 modest_ui_actions_on_settings (GtkAction *action,
2737 dialog = modest_platform_get_global_settings_dialog ();
2738 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
2739 gtk_widget_show (dialog);
2741 gtk_dialog_run (GTK_DIALOG (dialog));
2743 gtk_widget_destroy (dialog);
2747 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
2748 ModestWindow *window)
2750 ModestMailOperation *mail_op;
2754 headers = get_selected_headers (window);
2758 /* Create mail operation */
2759 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT (window));
2760 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2761 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
2764 g_object_unref (headers);
2765 g_object_unref (mail_op);