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);
967 /** Check that an appropriate connection is open.
969 gboolean check_for_connection (const gchar *account_name)
971 TnyDevice *device = modest_runtime_get_device ();
974 g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
976 TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);
979 if (tny_device_is_online (device))
982 modest_platform_connect_and_wait (NULL);
984 /* TODO: Wait until a result. */
990 * This function performs the send & receive required actions. The
991 * window is used to create the mail operation. Typically it should
992 * always be the main window, but we pass it as argument in order to
996 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
998 gchar *acc_name = NULL;
1000 /* If no account name was provided then get the current account, and if
1001 there is no current account then pick the default one: */
1002 if (!account_name) {
1003 acc_name = g_strdup (modest_window_get_active_account(win));
1005 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1007 g_printerr ("modest: cannot get default account\n");
1011 acc_name = g_strdup (account_name);
1014 /* Send & receive. */
1016 /* Do not continue if no suitable connection
1018 if (!check_for_connection (acc_name)) {
1023 /* TODO: Do not continue if an operation is already in progress:
1024 * Maybe there are some operations that tinymail allows to
1025 * happen simulatenously.
1026 * TODO: Maybe a simple global gboolean is_updating is enough?
1030 /* As per the UI spec,
1032 * - for POP accounts, we should receive,
1033 * - for IMAP we should synchronize everything, including receiving,
1035 * - for SMTP we should send.
1036 * First receiving (store), then sending (transport):
1038 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1040 /* Receive, by creating the mail operation */
1041 ModestMailOperation *mail_op;
1042 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
1043 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1044 modest_mail_operation_update_account (mail_op, acc_name);
1045 g_object_unref (G_OBJECT (mail_op));
1052 * Refreshes all accounts. This function will be used by automatic
1056 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1058 GSList *account_names, *iter;
1060 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1063 iter = account_names;
1065 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1066 iter = g_slist_next (iter);
1069 g_slist_foreach (account_names, (GFunc) g_free, NULL);
1070 g_slist_free (account_names);
1074 * Handler of the click on Send&Receive button in the main toolbar
1077 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1079 /* Check that at least one account exists: */
1080 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1081 TRUE /* enabled accounts only */);
1082 gboolean accounts_exist = account_names != NULL;
1083 g_slist_free (account_names);
1085 /* If not, allow the user to create an account before trying to send/receive. */
1086 if (!accounts_exist)
1087 modest_ui_actions_on_accounts (NULL, win);
1089 /* Refresh the active account */
1090 modest_ui_actions_do_send_receive (NULL, win);
1095 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1098 GtkWidget *header_view;
1100 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1102 header_view = modest_main_window_get_child_widget (main_window,
1103 MODEST_WIDGET_TYPE_HEADER_VIEW);
1107 conf = modest_runtime_get_conf ();
1109 /* what is saved/restored is depending on the style; thus; we save with
1110 * old style, then update the style, and restore for this new style
1112 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1114 if (modest_header_view_get_style
1115 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1116 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1117 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1119 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1120 MODEST_HEADER_VIEW_STYLE_DETAILS);
1122 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1123 MODEST_CONF_HEADER_VIEW_KEY);
1128 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1130 ModestMainWindow *main_window)
1132 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1134 /* If no header has been selected then exit */
1138 /* Update Main window title */
1139 if (GTK_WIDGET_HAS_FOCUS (header_view)) {
1140 const gchar *subject = tny_header_get_subject (header);
1141 if (subject && strcmp (subject, ""))
1142 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1144 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1149 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1151 ModestMainWindow *main_window)
1155 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1160 headers = tny_simple_list_new ();
1161 tny_list_prepend (headers, G_OBJECT (header));
1163 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1165 g_object_unref (headers);
1169 set_active_account_from_tny_account (TnyAccount *account,
1170 ModestWindow *window)
1172 const gchar *server_acc_name = tny_account_get_id (account);
1174 /* We need the TnyAccount provided by the
1175 account store because that is the one that
1176 knows the name of the Modest account */
1177 TnyAccount *modest_server_account = modest_server_account =
1178 modest_tny_account_store_get_tny_account_by_id (modest_runtime_get_account_store (),
1181 const gchar *modest_acc_name =
1182 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1183 modest_window_set_active_account (window, modest_acc_name);
1184 g_object_unref (modest_server_account);
1188 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1189 TnyFolderStore *folder_store,
1191 ModestMainWindow *main_window)
1194 GtkWidget *header_view;
1196 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1198 header_view = modest_main_window_get_child_widget(main_window,
1199 MODEST_WIDGET_TYPE_HEADER_VIEW);
1203 conf = modest_runtime_get_conf ();
1205 if (TNY_IS_ACCOUNT (folder_store)) {
1206 /* Update active account */
1207 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1208 /* Show account details */
1209 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1210 } else if (modest_tny_folder_store_is_virtual_local_folders (folder_store )) {
1211 printf ("DEBUG: %s: folder store.\n", __FUNCTION__);
1212 //TODO: Set the virtual folder store as the "active account" somehow:
1213 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1215 if (TNY_IS_FOLDER (folder_store) && selected) {
1217 if (!TNY_IS_MERGE_FOLDER (folder_store)) { /* TnyMergeFolder can have no get_account() implementation. */
1218 /* Update the active account */
1219 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder_store));
1220 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1221 g_object_unref (account);
1224 /* Set folder on header view */
1225 modest_main_window_set_contents_style (main_window,
1226 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1227 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1228 TNY_FOLDER (folder_store));
1229 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1230 MODEST_CONF_HEADER_VIEW_KEY);
1232 /* Update the active account */
1233 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1234 /* Do not show folder */
1235 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1236 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
1242 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1249 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1251 if (g_main_depth > 0)
1252 gdk_threads_enter ();
1253 online = tny_device_is_online (modest_runtime_get_device());
1256 /* already online -- the item is simply not there... */
1257 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1259 GTK_MESSAGE_WARNING,
1261 _("The %s you selected cannot be found"),
1263 gtk_dialog_run (GTK_DIALOG(dialog));
1265 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1269 GTK_RESPONSE_REJECT,
1271 GTK_RESPONSE_ACCEPT,
1273 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1274 "Do you want to get online?"), item);
1275 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1276 gtk_label_new (txt), FALSE, FALSE, 0);
1277 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1280 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1281 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1282 // modest_platform_connect_and_wait ();;
1285 gtk_widget_destroy (dialog);
1286 if (g_main_depth > 0)
1287 gdk_threads_leave ();
1291 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1294 /* g_message ("%s %s", __FUNCTION__, link); */
1299 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1302 modest_platform_activate_uri (link);
1306 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1309 modest_platform_show_uri_popup (link);
1313 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1316 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1320 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1321 const gchar *address,
1324 /* g_message ("%s %s", __FUNCTION__, address); */
1328 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1330 TnyTransportAccount *transport_account;
1331 ModestMailOperation *mail_operation;
1333 gchar *account_name, *from;
1334 ModestAccountMgr *account_mgr;
1336 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1338 data = modest_msg_edit_window_get_msg_data (edit_window);
1340 account_mgr = modest_runtime_get_account_mgr();
1341 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1343 account_name = modest_account_mgr_get_default_account (account_mgr);
1344 if (!account_name) {
1345 g_printerr ("modest: no account found\n");
1346 modest_msg_edit_window_free_msg_data (edit_window, data);
1350 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_tny_account_by_account
1351 (modest_runtime_get_account_store(),
1353 TNY_ACCOUNT_TYPE_TRANSPORT));
1354 if (!transport_account) {
1355 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1356 g_free (account_name);
1357 modest_msg_edit_window_free_msg_data (edit_window, data);
1360 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1362 /* Create the mail operation */
1363 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1364 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1366 modest_mail_operation_save_to_drafts (mail_operation,
1376 data->priority_flags);
1379 g_free (account_name);
1380 g_object_unref (G_OBJECT (transport_account));
1381 g_object_unref (G_OBJECT (mail_operation));
1383 modest_msg_edit_window_free_msg_data (edit_window, data);
1385 /* Save settings and close the window */
1386 gtk_widget_destroy (GTK_WIDGET (edit_window));
1389 /* For instance, when clicking the Send toolbar button when editing a message: */
1391 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1393 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1395 if (!modest_msg_edit_window_check_names (edit_window))
1398 /* FIXME: Code added just for testing. The final version will
1399 use the send queue provided by tinymail and some
1401 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1402 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1404 account_name = modest_account_mgr_get_default_account (account_mgr);
1406 if (!account_name) {
1407 g_printerr ("modest: no account found\n");
1411 /* Get the currently-active transport account for this modest account: */
1412 TnyTransportAccount *transport_account =
1413 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1414 (modest_runtime_get_account_store(),
1416 if (!transport_account) {
1417 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1418 g_free (account_name);
1422 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1424 /* Create the mail operation */
1425 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1426 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1428 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1429 modest_mail_operation_send_new_mail (mail_operation,
1439 data->priority_flags);
1443 g_free (account_name);
1444 g_object_unref (G_OBJECT (transport_account));
1445 g_object_unref (G_OBJECT (mail_operation));
1447 modest_msg_edit_window_free_msg_data (edit_window, data);
1449 /* Save settings and close the window: */
1450 gtk_widget_destroy (GTK_WIDGET (edit_window));
1454 modest_ui_actions_on_toggle_bold (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->bold = 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_toggle_italics (GtkToggleAction *action,
1476 ModestMsgEditWindow *window)
1478 ModestMsgEditFormatState *format_state = NULL;
1480 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1481 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1483 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1486 format_state = modest_msg_edit_window_get_format_state (window);
1487 g_return_if_fail (format_state != NULL);
1489 format_state->italics = gtk_toggle_action_get_active (action);
1490 modest_msg_edit_window_set_format_state (window, format_state);
1491 g_free (format_state);
1496 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1497 ModestMsgEditWindow *window)
1499 ModestMsgEditFormatState *format_state = NULL;
1501 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1502 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1504 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1507 format_state = modest_msg_edit_window_get_format_state (window);
1508 g_return_if_fail (format_state != NULL);
1510 format_state->bullet = gtk_toggle_action_get_active (action);
1511 modest_msg_edit_window_set_format_state (window, format_state);
1512 g_free (format_state);
1517 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1518 GtkRadioAction *selected,
1519 ModestMsgEditWindow *window)
1521 ModestMsgEditFormatState *format_state = NULL;
1522 GtkJustification value;
1524 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1526 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1529 value = gtk_radio_action_get_current_value (selected);
1531 format_state = modest_msg_edit_window_get_format_state (window);
1532 g_return_if_fail (format_state != NULL);
1534 format_state->justification = value;
1535 modest_msg_edit_window_set_format_state (window, format_state);
1536 g_free (format_state);
1540 modest_ui_actions_on_select_editor_color (GtkAction *action,
1541 ModestMsgEditWindow *window)
1543 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1544 g_return_if_fail (GTK_IS_ACTION (action));
1546 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1549 modest_msg_edit_window_select_color (window);
1553 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1554 ModestMsgEditWindow *window)
1556 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1557 g_return_if_fail (GTK_IS_ACTION (action));
1559 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1562 modest_msg_edit_window_select_background_color (window);
1566 modest_ui_actions_on_insert_image (GtkAction *action,
1567 ModestMsgEditWindow *window)
1569 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1570 g_return_if_fail (GTK_IS_ACTION (action));
1572 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1575 modest_msg_edit_window_insert_image (window);
1579 modest_ui_actions_on_attach_file (GtkAction *action,
1580 ModestMsgEditWindow *window)
1582 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1583 g_return_if_fail (GTK_IS_ACTION (action));
1585 modest_msg_edit_window_attach_file (window);
1589 modest_ui_actions_on_remove_attachments (GtkAction *action,
1590 ModestMsgEditWindow *window)
1592 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1593 g_return_if_fail (GTK_IS_ACTION (action));
1595 modest_msg_edit_window_remove_attachments (window, NULL);
1599 * Shows a dialog with an entry that asks for some text. The returned
1600 * value must be freed by the caller. The dialog window title will be
1604 ask_for_folder_name (GtkWindow *parent_window,
1607 GtkWidget *dialog, *entry;
1608 gchar *folder_name = NULL;
1610 /* Ask for folder name */
1611 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1615 GTK_RESPONSE_REJECT,
1617 GTK_RESPONSE_ACCEPT,
1619 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1620 gtk_label_new(title),
1623 entry = gtk_entry_new_with_max_length (40);
1624 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1628 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1630 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1631 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1633 gtk_widget_destroy (dialog);
1639 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1641 TnyFolderStore *parent_folder;
1642 GtkWidget *folder_view;
1644 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1646 folder_view = modest_main_window_get_child_widget (main_window,
1647 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1651 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1653 if (parent_folder) {
1654 gboolean finished = FALSE;
1656 gchar *folder_name = NULL, *suggested_name = NULL;
1658 /* Run the new folder dialog */
1660 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1665 if (result == GTK_RESPONSE_REJECT) {
1668 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1669 TnyFolder *new_folder = NULL;
1671 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1674 new_folder = modest_mail_operation_create_folder (mail_op,
1676 (const gchar *) folder_name);
1678 g_object_unref (new_folder);
1682 /* /\* TODO: check error and follow proper actions *\/ */
1683 /* /\* suggested_name = X; *\/ */
1684 /* /\* Show error to the user *\/ */
1685 /* modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1686 /* _("mail_in_ui_folder_create_error")); */
1688 g_object_unref (mail_op);
1690 g_free (folder_name);
1694 g_object_unref (parent_folder);
1699 modest_ui_actions_on_rename_folder (GtkAction *action,
1700 ModestMainWindow *main_window)
1702 TnyFolderStore *folder;
1703 GtkWidget *folder_view;
1704 GtkWidget *header_view;
1706 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1708 folder_view = modest_main_window_get_child_widget (main_window,
1709 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1713 header_view = modest_main_window_get_child_widget (main_window,
1714 MODEST_WIDGET_TYPE_HEADER_VIEW);
1719 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1721 if (folder && TNY_IS_FOLDER (folder)) {
1723 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1724 _("Please enter a new name for the folder"));
1726 if (folder_name != NULL && strlen (folder_name) > 0) {
1727 ModestMailOperation *mail_op;
1729 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1730 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1733 modest_header_view_set_folder (MODEST_HEADER_VIEW (header_view), NULL);
1735 modest_mail_operation_rename_folder (mail_op,
1736 TNY_FOLDER (folder),
1737 (const gchar *) folder_name);
1739 g_object_unref (mail_op);
1740 g_free (folder_name);
1742 g_object_unref (folder);
1747 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1749 TnyFolderStore *folder;
1750 GtkWidget *folder_view;
1754 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1756 folder_view = modest_main_window_get_child_widget (main_window,
1757 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1761 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1763 /* Show an error if it's an account */
1764 if (!TNY_IS_FOLDER (folder)) {
1765 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1766 _("mail_in_ui_folder_delete_error"));
1771 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1772 tny_folder_get_name (TNY_FOLDER (folder)));
1773 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1774 (const gchar *) message);
1777 if (response == GTK_RESPONSE_OK) {
1778 ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(main_window));
1780 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1782 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1784 /* Show error if happened */
1785 if (modest_mail_operation_get_error (mail_op))
1786 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1787 _("mail_in_ui_folder_delete_error"));
1789 g_object_unref (G_OBJECT (mail_op));
1792 g_object_unref (G_OBJECT (folder));
1796 modest_ui_actions_on_delete_folder (GtkAction *action,
1797 ModestMainWindow *main_window)
1799 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1801 delete_folder (main_window, FALSE);
1805 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1807 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1809 delete_folder (main_window, TRUE);
1813 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1814 const gchar* server_account_name,
1819 ModestMainWindow *main_window)
1821 g_return_if_fail(server_account_name);
1822 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1824 /* Initalize output parameters: */
1831 #ifdef MODEST_PLATFORM_MAEMO
1832 /* Maemo uses a different (awkward) button order,
1833 * It should probably just use gtk_alternative_dialog_button_order ().
1835 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1839 GTK_RESPONSE_ACCEPT,
1841 GTK_RESPONSE_REJECT,
1844 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1848 GTK_RESPONSE_REJECT,
1850 GTK_RESPONSE_ACCEPT,
1852 #endif /* MODEST_PLATFORM_MAEMO */
1854 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1856 gchar *server_name = modest_server_account_get_hostname (
1857 modest_runtime_get_account_mgr(), server_account_name);
1859 /* This causes a warning because the logical ID has no %s in it,
1860 * though the translation does, but there is not much we can do about that: */
1861 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
1862 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1865 g_free (server_name);
1869 gchar *initial_username = modest_server_account_get_username (
1870 modest_runtime_get_account_mgr(), server_account_name);
1872 GtkWidget *entry_username = gtk_entry_new ();
1873 if (initial_username)
1874 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
1875 /* Dim this if a connection has ever succeeded with this username,
1876 * as per the UI spec: */
1877 const gboolean username_known =
1878 modest_server_account_get_username_has_succeeded(
1879 modest_runtime_get_account_mgr(), server_account_name);
1880 gtk_widget_set_sensitive (entry_username, !username_known);
1882 #ifdef MODEST_PLATFORM_MAEMO
1883 /* Auto-capitalization is the default, so let's turn it off: */
1884 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
1886 /* Create a size group to be used by all captions.
1887 * Note that HildonCaption does not create a default size group if we do not specify one.
1888 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
1889 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1891 GtkWidget *caption = hildon_caption_new (sizegroup,
1892 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
1893 gtk_widget_show (entry_username);
1894 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1895 FALSE, FALSE, MODEST_MARGIN_HALF);
1896 gtk_widget_show (caption);
1898 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
1900 #endif /* MODEST_PLATFORM_MAEMO */
1903 GtkWidget *entry_password = gtk_entry_new ();
1904 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
1905 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
1907 #ifdef MODEST_PLATFORM_MAEMO
1908 /* Auto-capitalization is the default, so let's turn it off: */
1909 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
1910 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
1912 caption = hildon_caption_new (sizegroup,
1913 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
1914 gtk_widget_show (entry_password);
1915 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1916 FALSE, FALSE, MODEST_MARGIN_HALF);
1917 gtk_widget_show (caption);
1918 g_object_unref (sizegroup);
1920 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
1922 #endif /* MODEST_PLATFORM_MAEMO */
1924 /* This is not in the Maemo UI spec:
1925 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1926 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1930 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1932 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1934 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
1936 modest_server_account_set_username (
1937 modest_runtime_get_account_mgr(), server_account_name,
1940 const gboolean username_was_changed =
1941 (strcmp (*username, initial_username) != 0);
1942 if (username_was_changed) {
1943 /* To actually use a changed username,
1944 * we must reset the connection, according to pvanhoof.
1945 * This _might_ be a sensible way to do that: */
1946 TnyDevice *device = modest_runtime_get_device();
1947 tny_device_force_offline (device);
1948 tny_device_force_online (device);
1953 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
1955 /* We do not save the password in the configuration,
1956 * because this function is only called for passwords that should
1957 * not be remembered:
1958 modest_server_account_set_password (
1959 modest_runtime_get_account_mgr(), server_account_name,
1978 /* This is not in the Maemo UI spec:
1979 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1985 gtk_widget_destroy (dialog);
1987 printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel);
1991 modest_ui_actions_on_cut (GtkAction *action,
1992 ModestWindow *window)
1994 GtkWidget *focused_widget;
1996 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1997 if (GTK_IS_EDITABLE (focused_widget)) {
1998 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1999 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2000 GtkTextBuffer *buffer;
2001 GtkClipboard *clipboard;
2003 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
2004 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2005 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2010 modest_ui_actions_on_copy (GtkAction *action,
2011 ModestWindow *window)
2013 GtkClipboard *clipboard;
2014 GtkWidget *focused_widget;
2016 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
2017 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2018 if (GTK_IS_LABEL (focused_widget)) {
2019 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2020 } else if (GTK_IS_EDITABLE (focused_widget)) {
2021 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2022 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2023 GtkTextBuffer *buffer;
2025 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2026 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2031 modest_ui_actions_on_undo (GtkAction *action,
2032 ModestWindow *window)
2034 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2035 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2037 g_return_if_reached ();
2042 modest_ui_actions_on_paste (GtkAction *action,
2043 ModestWindow *window)
2045 GtkWidget *focused_widget;
2047 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2048 if (GTK_IS_EDITABLE (focused_widget)) {
2049 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2050 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2051 GtkTextBuffer *buffer;
2052 GtkClipboard *clipboard;
2054 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
2055 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2056 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2061 modest_ui_actions_on_select_all (GtkAction *action,
2062 ModestWindow *window)
2064 GtkWidget *focused_widget;
2066 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2067 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2068 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2069 } else if (GTK_IS_LABEL (focused_widget)) {
2070 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2071 } else if (GTK_IS_EDITABLE (focused_widget)) {
2072 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2073 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2074 GtkTextBuffer *buffer;
2075 GtkTextIter start, end;
2077 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2078 gtk_text_buffer_get_start_iter (buffer, &start);
2079 gtk_text_buffer_get_end_iter (buffer, &end);
2080 gtk_text_buffer_select_range (buffer, &start, &end);
2085 modest_ui_actions_on_mark_as_read (GtkAction *action,
2086 ModestWindow *window)
2088 g_return_if_fail (MODEST_IS_WINDOW(window));
2090 /* Mark each header as read */
2091 do_headers_action (window, headers_action_mark_as_read, NULL);
2095 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2096 ModestWindow *window)
2098 g_return_if_fail (MODEST_IS_WINDOW(window));
2100 /* Mark each header as read */
2101 do_headers_action (window, headers_action_mark_as_unread, NULL);
2105 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2106 GtkRadioAction *selected,
2107 ModestWindow *window)
2111 value = gtk_radio_action_get_current_value (selected);
2112 if (MODEST_IS_WINDOW (window)) {
2113 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2117 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2118 GtkRadioAction *selected,
2119 ModestWindow *window)
2121 TnyHeaderFlags flags;
2122 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2124 flags = gtk_radio_action_get_current_value (selected);
2125 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2128 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2129 GtkRadioAction *selected,
2130 ModestWindow *window)
2134 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2136 file_format = gtk_radio_action_get_current_value (selected);
2137 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2142 modest_ui_actions_on_zoom_plus (GtkAction *action,
2143 ModestWindow *window)
2145 g_return_if_fail (MODEST_IS_WINDOW (window));
2147 modest_window_zoom_plus (MODEST_WINDOW (window));
2151 modest_ui_actions_on_zoom_minus (GtkAction *action,
2152 ModestWindow *window)
2154 g_return_if_fail (MODEST_IS_WINDOW (window));
2156 modest_window_zoom_minus (MODEST_WINDOW (window));
2160 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2161 ModestWindow *window)
2163 ModestWindowMgr *mgr;
2164 gboolean fullscreen, active;
2165 g_return_if_fail (MODEST_IS_WINDOW (window));
2167 mgr = modest_runtime_get_window_mgr ();
2169 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2170 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2172 if (active != fullscreen) {
2173 modest_window_mgr_set_fullscreen_mode (mgr, active);
2174 gtk_window_present (GTK_WINDOW (window));
2179 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2180 ModestWindow *window)
2182 ModestWindowMgr *mgr;
2183 gboolean fullscreen;
2185 g_return_if_fail (MODEST_IS_WINDOW (window));
2187 mgr = modest_runtime_get_window_mgr ();
2188 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2189 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2191 gtk_window_present (GTK_WINDOW (window));
2195 * Used by modest_ui_actions_on_details to call do_headers_action
2198 headers_action_show_details (TnyHeader *header,
2199 ModestWindow *window,
2206 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2209 gtk_widget_show_all (dialog);
2210 gtk_dialog_run (GTK_DIALOG (dialog));
2212 gtk_widget_destroy (dialog);
2216 * Show the folder details in a ModestDetailsDialog widget
2219 show_folder_details (TnyFolder *folder,
2225 dialog = modest_details_dialog_new_with_folder (window, folder);
2228 gtk_widget_show_all (dialog);
2229 gtk_dialog_run (GTK_DIALOG (dialog));
2231 gtk_widget_destroy (dialog);
2235 * Show the header details in a ModestDetailsDialog widget
2238 modest_ui_actions_on_details (GtkAction *action,
2241 TnyList * headers_list;
2245 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2248 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2251 g_object_unref (msg);
2253 headers_list = get_selected_headers (win);
2257 iter = tny_list_create_iterator (headers_list);
2259 header = TNY_HEADER (tny_iterator_get_current (iter));
2260 headers_action_show_details (header, win, NULL);
2261 g_object_unref (header);
2263 g_object_unref (iter);
2264 g_object_unref (headers_list);
2266 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2267 GtkWidget *folder_view, *header_view;
2269 /* Check which widget has the focus */
2270 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2271 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2272 if (gtk_widget_is_focus (folder_view)) {
2275 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2277 /* Show only when it's a folder */
2278 if (!folder || !TNY_IS_FOLDER (folder))
2281 show_folder_details (folder, GTK_WINDOW (win));
2284 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2285 MODEST_WIDGET_TYPE_HEADER_VIEW);
2286 /* Show details of each header */
2287 do_headers_action (win, headers_action_show_details, header_view);
2293 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2294 ModestMsgEditWindow *window)
2296 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2298 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2302 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2303 ModestMsgEditWindow *window)
2305 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2307 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2311 modest_ui_actions_toggle_folders_view (GtkAction *action,
2312 ModestMainWindow *main_window)
2316 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2318 conf = modest_runtime_get_conf ();
2320 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2321 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2323 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2327 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2328 ModestWindow *window)
2330 gboolean active, fullscreen = FALSE;
2331 ModestWindowMgr *mgr;
2333 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2335 /* Check if we want to toggle the toolbar vuew in fullscreen
2337 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2338 "ViewShowToolbarFullScreen")) {
2342 /* Toggle toolbar */
2343 mgr = modest_runtime_get_window_mgr ();
2344 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2348 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2349 ModestMsgEditWindow *window)
2351 modest_msg_edit_window_select_font (window);
2355 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2356 const gchar *display_name,
2359 /* Do not change the application name if the widget has not
2360 the focus. This callback could be called even if the folder
2361 view has not the focus, because the handled signal could be
2362 emitted when the folder view is redrawn */
2363 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2365 gtk_window_set_title (window, display_name);
2367 gtk_window_set_title (window, " ");
2372 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2374 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2375 modest_msg_edit_window_select_contacts (window);
2379 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2381 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2382 modest_msg_edit_window_check_names (window);
2387 create_move_to_dialog (ModestWindow *win,
2388 GtkWidget *folder_view,
2389 GtkWidget **tree_view)
2391 GtkWidget *dialog, *scroll;
2393 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2395 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2397 GTK_RESPONSE_ACCEPT,
2399 GTK_RESPONSE_REJECT,
2402 /* Create scrolled window */
2403 scroll = gtk_scrolled_window_new (NULL, NULL);
2404 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2405 GTK_POLICY_AUTOMATIC,
2406 GTK_POLICY_AUTOMATIC);
2408 /* Create folder view */
2409 *tree_view = modest_folder_view_new (NULL);
2410 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2411 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2412 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2414 /* Add scroll to dialog */
2415 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2416 scroll, FALSE, FALSE, 0);
2418 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2424 * Returns TRUE if at least one of the headers of the list belongs to
2425 * a message that has been fully retrieved.
2428 has_retrieved_msgs (TnyList *list)
2431 gboolean found = FALSE;
2433 iter = tny_list_create_iterator (list);
2434 while (tny_iterator_is_done (iter) && !found) {
2436 TnyHeaderFlags flags;
2438 header = TNY_HEADER (tny_iterator_get_current (iter));
2439 flags = tny_header_get_flags (header);
2440 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2444 tny_iterator_next (iter);
2446 g_object_unref (iter);
2452 * Shows a confirmation dialog to the user when we're moving messages
2453 * from a remote server to the local storage. Returns the dialog
2454 * response. If it's other kind of movement the it always returns
2458 msgs_move_to_confirmation (GtkWindow *win,
2459 TnyFolder *dest_folder,
2462 gint response = GTK_RESPONSE_OK;
2464 /* If the destination is a local folder */
2465 if (modest_tny_folder_is_local_folder (dest_folder)) {
2466 TnyFolder *src_folder;
2470 /* Get source folder */
2471 iter = tny_list_create_iterator (headers);
2472 header = TNY_HEADER (tny_iterator_get_current (iter));
2473 src_folder = tny_header_get_folder (header);
2474 g_object_unref (header);
2475 g_object_unref (iter);
2477 /* If the source is a remote folder */
2478 if (!modest_tny_folder_is_local_folder (src_folder)) {
2479 const gchar *message;
2481 if (tny_list_get_length (headers) == 1)
2482 if (has_retrieved_msgs (headers))
2483 message = _("mcen_nc_move_retrieve");
2485 message = _("mcen_nc_move_header");
2487 if (has_retrieved_msgs (headers))
2488 message = _("mcen_nc_move_retrieves");
2490 message = _("mcen_nc_move_headers");
2492 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2493 (const gchar *) message);
2495 g_object_unref (src_folder);
2502 tranasfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2504 ModestMsgViewWindow *self = NULL;
2505 gboolean found = FALSE;
2507 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2508 self = MODEST_MSG_VIEW_WINDOW (object);
2510 found = modest_msg_view_window_select_first_message (self);
2511 g_return_if_fail (found);
2515 move_to_error_checking (const GObject *obj, gpointer user_data)
2517 ModestWindow *win = NULL;
2519 g_return_if_fail (MODEST_IS_WINDOW (obj));
2520 win = MODEST_WINDOW (obj);
2522 /* TODO: show error message */
2523 /* modest_platform_run_information_dialog (GTK_WINDOW (win), */
2524 /* _("mail_in_ui_folder_move_target_error")); */
2528 * UI handler for the "Move to" action when invoked from the
2532 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2533 ModestMainWindow *win)
2535 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2536 GtkWidget *header_view = NULL;
2538 TnyFolderStore *folder_store = NULL;
2539 ModestMailOperation *mail_op = NULL;
2541 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2543 /* Get the folder view */
2544 folder_view = modest_main_window_get_child_widget (win,
2545 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2547 /* Get header view */
2548 header_view = modest_main_window_get_child_widget (win,
2549 MODEST_WIDGET_TYPE_HEADER_VIEW);
2551 /* Create and run the dialog */
2552 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2553 result = gtk_dialog_run (GTK_DIALOG(dialog));
2554 g_object_ref (tree_view);
2556 /* We do this to save an indentation level ;-) */
2557 if (result != GTK_RESPONSE_ACCEPT)
2560 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2562 if (TNY_IS_ACCOUNT (folder_store))
2565 /* Get folder or messages to transfer */
2566 if (gtk_widget_is_focus (folder_view)) {
2567 TnyFolderStore *src_folder;
2568 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2570 /* Clean folder on header view before moving it */
2571 modest_header_view_set_folder (MODEST_HEADER_VIEW (header_view), NULL);
2573 if (TNY_IS_FOLDER (src_folder)) {
2574 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2576 move_to_error_checking);
2577 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2580 modest_mail_operation_xfer_folder (mail_op,
2581 TNY_FOLDER (src_folder),
2584 g_object_unref (G_OBJECT (mail_op));
2589 g_object_unref (G_OBJECT (src_folder));
2591 if (gtk_widget_is_focus (header_view)) {
2595 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2597 /* Ask for user confirmation */
2598 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2599 TNY_FOLDER (folder_store),
2602 /* Transfer messages */
2603 if (response == GTK_RESPONSE_OK) {
2604 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2605 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2608 modest_mail_operation_xfer_msgs (mail_op,
2610 TNY_FOLDER (folder_store),
2614 g_object_unref (G_OBJECT (mail_op));
2616 g_object_unref (headers);
2619 g_object_unref (folder_store);
2622 gtk_widget_destroy (dialog);
2627 * UI handler for the "Move to" action when invoked from the
2628 * ModestMsgViewWindow
2631 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2632 ModestMsgViewWindow *win)
2634 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2636 ModestMainWindow *main_window;
2640 /* Get the folder view */
2641 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2642 folder_view = modest_main_window_get_child_widget (main_window,
2643 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2645 /* Create and run the dialog */
2646 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2647 result = gtk_dialog_run (GTK_DIALOG(dialog));
2648 g_object_ref (tree_view);
2650 if (result == GTK_RESPONSE_ACCEPT) {
2651 TnyFolderStore *folder_store;
2654 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2656 /* Create header list */
2657 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2658 headers = tny_simple_list_new ();
2659 tny_list_prepend (headers, G_OBJECT (header));
2660 g_object_unref (header);
2662 /* Ask user for confirmation. MSG-NOT404 */
2663 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2664 TNY_FOLDER (folder_store),
2667 /* Transfer current msg */
2668 if (response == GTK_RESPONSE_OK) {
2669 ModestMailOperation *mail_op;
2671 /* Create mail op */
2672 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2673 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2676 /* Transfer messages */
2677 modest_mail_operation_xfer_msgs (mail_op,
2679 TNY_FOLDER (folder_store),
2681 tranasfer_msgs_from_viewer_cb,
2683 g_object_unref (G_OBJECT (mail_op));
2685 g_object_unref (headers);
2686 g_object_unref (folder_store);
2688 gtk_widget_destroy (dialog);
2692 modest_ui_actions_on_move_to (GtkAction *action,
2695 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2696 MODEST_IS_MSG_VIEW_WINDOW (win));
2698 if (MODEST_IS_MAIN_WINDOW (win))
2699 modest_ui_actions_on_main_window_move_to (action,
2700 MODEST_MAIN_WINDOW (win));
2702 modest_ui_actions_on_msg_view_window_move_to (action,
2703 MODEST_MSG_VIEW_WINDOW (win));
2707 * Calls #HeadersFunc for each header already selected in the main
2708 * window or the message currently being shown in the msg view window
2711 do_headers_action (ModestWindow *win,
2715 TnyList *headers_list;
2719 headers_list = get_selected_headers (win);
2723 /* Call the function for each header */
2724 iter = tny_list_create_iterator (headers_list);
2725 while (!tny_iterator_is_done (iter)) {
2728 header = TNY_HEADER (tny_iterator_get_current (iter));
2729 func (header, win, user_data);
2730 g_object_unref (header);
2731 tny_iterator_next (iter);
2733 g_object_unref (iter);
2734 g_object_unref (headers_list);
2738 modest_ui_actions_view_attachment (GtkAction *action,
2739 ModestWindow *window)
2741 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2742 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
2744 /* not supported window for this action */
2745 g_return_if_reached ();
2750 modest_ui_actions_save_attachments (GtkAction *action,
2751 ModestWindow *window)
2753 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2754 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2756 /* not supported window for this action */
2757 g_return_if_reached ();
2762 modest_ui_actions_remove_attachments (GtkAction *action,
2763 ModestWindow *window)
2765 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2766 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2768 /* not supported window for this action */
2769 g_return_if_reached ();
2774 modest_ui_actions_on_settings (GtkAction *action,
2779 dialog = modest_platform_get_global_settings_dialog ();
2780 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
2781 gtk_widget_show (dialog);
2783 gtk_dialog_run (GTK_DIALOG (dialog));
2785 gtk_widget_destroy (dialog);
2789 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
2790 ModestWindow *window)
2792 ModestMailOperation *mail_op;
2796 headers = get_selected_headers (window);
2800 /* Create mail operation */
2801 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT (window));
2802 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2803 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
2806 g_object_unref (headers);
2807 g_object_unref (mail_op);