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>
35 #include <glib/gprintf.h>
37 #include <modest-runtime.h>
38 #include <modest-tny-folder.h>
39 #include <modest-tny-msg.h>
40 #include <modest-tny-account.h>
41 #include <modest-address-book.h>
42 #include "modest-error.h"
43 #include "modest-ui-actions.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
48 #ifdef MODEST_PLATFORM_MAEMO
49 #include "maemo/modest-osso-state-saving.h"
50 #endif /* MODEST_PLATFORM_MAEMO */
52 #include "widgets/modest-ui-constants.h"
53 #include <widgets/modest-main-window.h>
54 #include <widgets/modest-msg-view-window.h>
55 #include <widgets/modest-account-view-window.h>
56 #include <widgets/modest-details-dialog.h>
57 #include <widgets/modest-attachments-view.h>
58 #include "widgets/modest-folder-view.h"
59 #include "widgets/modest-global-settings-dialog.h"
60 #include "modest-connection-specific-smtp-window.h"
61 #include "modest-account-mgr-helpers.h"
62 #include "modest-mail-operation.h"
63 #include "modest-text-utils.h"
65 #ifdef MODEST_HAVE_EASYSETUP
66 #include "easysetup/modest-easysetup-wizard.h"
67 #endif /* MODEST_HAVE_EASYSETUP */
69 #include <modest-widget-memory.h>
70 #include <tny-error.h>
71 #include <tny-simple-list.h>
72 #include <tny-msg-view.h>
73 #include <tny-device.h>
74 #include <tny-merge-folder.h>
76 #include <gtkhtml/gtkhtml.h>
78 typedef struct _GetMsgAsyncHelper {
80 ModestMailOperation *mail_op;
87 typedef enum _ReplyForwardAction {
93 typedef struct _ReplyForwardHelper {
94 guint reply_forward_type;
95 ReplyForwardAction action;
97 GtkWidget *parent_window;
102 * The do_headers_action uses this kind of functions to perform some
103 * action to each member of a list of headers
105 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
108 do_headers_action (ModestWindow *win,
113 static void open_msg_cb (ModestMailOperation *mail_op,
118 static void reply_forward_cb (ModestMailOperation *mail_op,
123 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
126 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
127 ModestMailOperationState *state,
133 run_account_setup_wizard (ModestWindow *win)
135 ModestEasysetupWizardDialog *wizard;
137 g_return_if_fail (MODEST_IS_WINDOW(win));
139 wizard = modest_easysetup_wizard_dialog_new ();
140 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
141 gtk_dialog_run (GTK_DIALOG (wizard));
142 gtk_widget_destroy (GTK_WIDGET (wizard));
147 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
150 const gchar *authors[] = {
151 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
154 about = gtk_about_dialog_new ();
155 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
156 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
157 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
158 _("Copyright (c) 2006, Nokia Corporation\n"
159 "All rights reserved."));
160 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
161 _("a modest e-mail client\n\n"
162 "design and implementation: Dirk-Jan C. Binnema\n"
163 "contributions from the fine people at KC and Ig\n"
164 "uses the tinymail email framework written by Philip van Hoof"));
165 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
166 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
168 gtk_dialog_run (GTK_DIALOG (about));
169 gtk_widget_destroy(about);
173 * Gets the list of currently selected messages. If the win is the
174 * main window, then it returns a newly allocated list of the headers
175 * selected in the header view. If win is the msg view window, then
176 * the value returned is a list with just a single header.
178 * The caller of this funcion must free the list.
181 get_selected_headers (ModestWindow *win)
183 if (MODEST_IS_MAIN_WINDOW(win)) {
184 GtkWidget *header_view;
186 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
187 MODEST_WIDGET_TYPE_HEADER_VIEW);
188 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
190 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
191 /* for MsgViewWindows, we simply return a list with one element */
193 TnyList *list = NULL;
195 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
196 if (header != NULL) {
197 list = tny_simple_list_new ();
198 tny_list_prepend (list, G_OBJECT(header));
199 g_object_unref (G_OBJECT(header));
209 headers_action_mark_as_read (TnyHeader *header,
213 TnyHeaderFlags flags;
215 g_return_if_fail (TNY_IS_HEADER(header));
217 flags = tny_header_get_flags (header);
218 if (flags & TNY_HEADER_FLAG_SEEN) return;
219 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
223 headers_action_mark_as_unread (TnyHeader *header,
227 TnyHeaderFlags flags;
229 g_return_if_fail (TNY_IS_HEADER(header));
231 flags = tny_header_get_flags (header);
232 if (flags & TNY_HEADER_FLAG_SEEN) {
233 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
239 headers_action_delete (TnyHeader *header,
243 ModestMailOperation *mail_op = NULL;
245 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
246 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
249 /* Always delete. TODO: Move to trash still not supported */
250 modest_mail_operation_remove_msg (mail_op, header, FALSE);
251 g_object_unref (G_OBJECT (mail_op));
255 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
257 TnyList *header_list = NULL;
258 TnyIterator *iter = NULL;
259 TnyHeader *header = NULL;
260 gchar *message = NULL;
264 ModestWindowMgr *mgr;
265 GtkWidget *header_view;
267 g_return_if_fail (MODEST_IS_WINDOW(win));
269 /* Check first if the header view has the focus */
270 if (MODEST_IS_MAIN_WINDOW (win)) {
271 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
272 MODEST_WIDGET_TYPE_HEADER_VIEW);
273 if (!gtk_widget_is_focus (header_view))
277 header_list = get_selected_headers (win);
278 if (!header_list) return;
280 /* Check if any of the headers is already opened */
281 iter = tny_list_create_iterator (header_list);
283 mgr = modest_runtime_get_window_mgr ();
284 while (!tny_iterator_is_done (iter) && !found) {
285 header = TNY_HEADER (tny_iterator_get_current (iter));
286 if (modest_window_mgr_find_window_by_header (mgr, header))
288 g_object_unref (header);
289 tny_iterator_next (iter);
291 g_object_unref (iter);
296 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
297 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
299 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
303 g_object_unref (header_list);
308 if (tny_list_get_length(header_list) == 1) {
309 iter = tny_list_create_iterator (header_list);
310 header = TNY_HEADER (tny_iterator_get_current (iter));
311 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
312 g_object_unref (header);
313 g_object_unref (iter);
315 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
316 tny_list_get_length(header_list)), desc);
318 /* Confirmation dialog */
319 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
323 if (response == GTK_RESPONSE_OK) {
324 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
326 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
330 /* Remove each header */
331 do_headers_action (win, headers_action_delete, NULL);
333 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
334 gtk_widget_destroy (GTK_WIDGET(win));
341 g_object_unref (header_list);
346 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
348 #ifdef MODEST_PLATFORM_MAEMO
349 modest_osso_save_state();
350 #endif /* MODEST_PLATFORM_MAEMO */
352 /* FIXME: we need to cancel all actions/threads here,
359 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
361 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
362 gtk_widget_destroy (GTK_WIDGET (win));
363 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
365 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
366 } else if (MODEST_IS_WINDOW (win)) {
367 gtk_widget_destroy (GTK_WIDGET (win));
369 g_return_if_reached ();
374 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
376 GtkClipboard *clipboard = NULL;
377 gchar *selection = NULL;
379 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
380 selection = gtk_clipboard_wait_for_text (clipboard);
382 /* Question: why is the clipboard being used here?
383 * It doesn't really make a lot of sense. */
387 modest_address_book_add_address (selection);
393 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
395 /* This is currently only implemented for Maemo */
396 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
397 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
398 run_account_setup_wizard (win);
401 /* Show the list of accounts: */
402 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
403 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
404 gtk_dialog_run (account_win);
405 gtk_widget_destroy (GTK_WIDGET(account_win));
408 GtkWidget *dialog, *label;
410 /* Create the widgets */
412 dialog = gtk_dialog_new_with_buttons ("Message",
414 GTK_DIALOG_DESTROY_WITH_PARENT,
418 label = gtk_label_new ("Hello World!");
420 /* Ensure that the dialog box is destroyed when the user responds. */
422 g_signal_connect_swapped (dialog, "response",
423 G_CALLBACK (gtk_widget_destroy),
426 /* Add the label, and show everything we've added to the dialog. */
428 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
430 gtk_widget_show_all (dialog);
431 #endif /* MODEST_PLATFORM_MAEMO */
435 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
437 ModestWindow *main_window = MODEST_WINDOW (user_data);
439 /* Save any changes. */
440 modest_connection_specific_smtp_window_save_server_accounts (
441 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
442 modest_window_get_active_account (main_window));
443 gtk_widget_destroy (GTK_WIDGET (window));
449 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
451 /* This is currently only implemented for Maemo,
452 * because it requires an API (libconic) to detect different connection
455 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
457 /* Create the window if necessary: */
458 const gchar *active_account_name = modest_window_get_active_account (win);
460 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
461 * or show the default account?
462 * If we show the default account then the account name should be shown in
463 * the window when we show it. */
464 if (!active_account_name) {
465 g_warning ("%s: No account is active.", __FUNCTION__);
469 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
470 modest_connection_specific_smtp_window_fill_with_connections (
471 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
472 modest_runtime_get_account_mgr(),
473 active_account_name);
475 /* Show the window: */
476 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
477 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
478 gtk_widget_show (specific_window);
480 /* Save changes when the window is hidden: */
481 g_signal_connect (specific_window, "hide",
482 G_CALLBACK (on_smtp_servers_window_hide), win);
483 #endif /* MODEST_PLATFORM_MAEMO */
487 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
489 ModestWindow *msg_win = NULL;
491 TnyFolder *folder = NULL;
492 gchar *account_name = NULL;
493 gchar *from_str = NULL;
494 /* GError *err = NULL; */
495 TnyAccount *account = NULL;
496 ModestWindowMgr *mgr;
497 gchar *signature = NULL, *blank_and_signature = NULL;
499 /* if there are no accounts yet, just show the wizard */
500 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
501 run_account_setup_wizard (win);
505 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
507 account_name = g_strdup (modest_window_get_active_account (win));
509 g_printerr ("modest: no account found\n");
513 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
515 TNY_ACCOUNT_TYPE_STORE);
517 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
521 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
523 g_printerr ("modest: failed get from string for '%s'\n", account_name);
527 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
528 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
529 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
530 MODEST_ACCOUNT_SIGNATURE, FALSE);
531 blank_and_signature = g_strconcat ("\n", signature, NULL);
534 blank_and_signature = g_strdup ("");
537 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
539 g_printerr ("modest: failed to create new msg\n");
543 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
545 g_printerr ("modest: failed to find Drafts folder\n");
550 /* Create and register edit window */
551 /* This is destroyed by TOOD. */
552 msg_win = modest_msg_edit_window_new (msg, account_name);
553 mgr = modest_runtime_get_window_mgr ();
554 modest_window_mgr_register_window (mgr, msg_win);
557 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
559 gtk_widget_show_all (GTK_WIDGET (msg_win));
562 g_free (account_name);
564 g_free (blank_and_signature);
566 g_object_unref (msg_win);
568 g_object_unref (G_OBJECT(account));
570 g_object_unref (G_OBJECT(msg));
572 g_object_unref (G_OBJECT(folder));
576 open_msg_cb (ModestMailOperation *mail_op,
581 ModestWindowMgr *mgr = NULL;
582 ModestWindow *parent_win = NULL;
583 ModestWindow *win = NULL;
584 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
585 gchar *account = NULL;
588 /* TODO: Show an error? (review the specs) */
592 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
593 folder = tny_header_get_folder (header);
595 /* Mark header as read */
596 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
599 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
601 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
603 /* Gets folder type (OUTBOX headers will be opened in edit window */
604 if (modest_tny_folder_is_local_folder (folder))
605 folder_type = modest_tny_folder_get_local_folder_type (folder);
607 /* If the header is in the drafts folder then open the editor,
608 else the message view window */
609 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
610 /* we cannot edit without a valid account... */
611 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
612 run_account_setup_wizard(parent_win);
615 win = modest_msg_edit_window_new (msg, account);
617 gchar *uid = modest_tny_folder_get_header_unique_id (header);
619 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
620 GtkWidget *header_view;
621 GtkTreeSelection *sel;
622 GList *sel_list = NULL;
625 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
626 MODEST_WIDGET_TYPE_HEADER_VIEW);
628 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
629 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
631 if (sel_list != NULL) {
632 GtkTreeRowReference *row_reference;
634 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
635 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
636 g_list_free (sel_list);
638 win = modest_msg_view_window_new_with_header_model (msg,
643 gtk_tree_row_reference_free (row_reference);
645 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
648 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
653 /* Register and show new window */
655 mgr = modest_runtime_get_window_mgr ();
656 modest_window_mgr_register_window (mgr, win);
657 g_object_unref (win);
658 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
659 gtk_widget_show_all (GTK_WIDGET(win));
665 g_object_unref (parent_win);
666 g_object_unref (msg);
667 g_object_unref (folder);
671 * This function is the error handler of the
672 * modest_mail_operation_get_msgs_full operation
675 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
680 error = modest_mail_operation_get_error (mail_op);
681 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
682 GObject *win = modest_mail_operation_get_source (mail_op);
684 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
686 g_object_unref (win);
691 * This function is used by both modest_ui_actions_on_open and
692 * modest_ui_actions_on_header_activated. This way we always do the
693 * same when trying to open messages.
696 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
698 ModestWindowMgr *mgr;
700 ModestMailOperation *mail_op;
701 TnyList *not_opened_headers;
703 /* Look if we already have a message view for each header. If
704 true, then remove the header from the list of headers to
706 mgr = modest_runtime_get_window_mgr ();
707 iter = tny_list_create_iterator (headers);
708 not_opened_headers = tny_simple_list_new ();
709 while (!tny_iterator_is_done (iter)) {
710 ModestWindow *window;
713 header = TNY_HEADER (tny_iterator_get_current (iter));
714 window = modest_window_mgr_find_window_by_header (mgr, header);
715 /* Do not open again the message and present the
716 window to the user */
718 gtk_window_present (GTK_WINDOW (window));
720 tny_list_append (not_opened_headers, G_OBJECT (header));
722 g_object_unref (header);
723 tny_iterator_next (iter);
726 /* Open each message */
727 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
729 modest_ui_actions_get_msgs_full_error_handler,
731 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
732 if (tny_list_get_length (not_opened_headers) > 1) {
733 modest_mail_operation_get_msgs_full (mail_op,
739 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
740 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
741 modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
742 g_object_unref (header);
743 g_object_unref (iter);
747 g_object_unref (not_opened_headers);
748 g_object_unref (iter);
749 g_object_unref (mail_op);
753 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
758 headers = get_selected_headers (win);
763 _modest_ui_actions_open (headers, win);
765 g_object_unref(headers);
770 free_reply_forward_helper (gpointer data)
772 ReplyForwardHelper *helper;
774 helper = (ReplyForwardHelper *) data;
775 g_free (helper->account_name);
776 g_slice_free (ReplyForwardHelper, helper);
780 reply_forward_cb (ModestMailOperation *mail_op,
786 ReplyForwardHelper *rf_helper;
787 ModestWindow *msg_win = NULL;
788 ModestEditType edit_type;
790 TnyAccount *account = NULL;
791 ModestWindowMgr *mgr = NULL;
792 gchar *signature = NULL;
794 g_return_if_fail (user_data != NULL);
795 rf_helper = (ReplyForwardHelper *) user_data;
797 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
798 rf_helper->account_name);
799 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
800 rf_helper->account_name,
801 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
802 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
803 rf_helper->account_name,
804 MODEST_ACCOUNT_SIGNATURE, FALSE);
807 /* Create reply mail */
808 switch (rf_helper->action) {
811 modest_tny_msg_create_reply_msg (msg, from, signature,
812 rf_helper->reply_forward_type,
813 MODEST_TNY_MSG_REPLY_MODE_SENDER);
815 case ACTION_REPLY_TO_ALL:
817 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
818 MODEST_TNY_MSG_REPLY_MODE_ALL);
819 edit_type = MODEST_EDIT_TYPE_REPLY;
823 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
824 edit_type = MODEST_EDIT_TYPE_FORWARD;
827 g_return_if_reached ();
834 g_printerr ("modest: failed to create message\n");
838 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
839 rf_helper->account_name,
840 TNY_ACCOUNT_TYPE_STORE);
842 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
846 /* Create and register the windows */
847 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
848 mgr = modest_runtime_get_window_mgr ();
849 modest_window_mgr_register_window (mgr, msg_win);
851 if (rf_helper->parent_window != NULL) {
854 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
855 modest_window_set_zoom (msg_win, parent_zoom);
858 /* Show edit window */
859 gtk_widget_show_all (GTK_WIDGET (msg_win));
863 g_object_unref (msg_win);
865 g_object_unref (G_OBJECT (new_msg));
867 g_object_unref (G_OBJECT (account));
868 g_object_unref (msg);
869 g_object_unref (header);
873 * Checks a list of headers. If any of them are not currently
874 * downloaded (CACHED) then it asks the user for permission to
877 * Returns FALSE if the user does not want to download the
878 * messages. Returns TRUE if the user allowed the download or if all
879 * of them are currently downloaded
882 download_uncached_messages (TnyList *header_list, GtkWindow *win)
886 gint uncached_messages = 0;
888 iter = tny_list_create_iterator (header_list);
889 while (!tny_iterator_is_done (iter)) {
891 TnyHeaderFlags flags;
893 header = TNY_HEADER (tny_iterator_get_current (iter));
894 flags = tny_header_get_flags (header);
895 /* TODO: is this the right flag?, it seems that some
896 headers that have been previously downloaded do not
898 if (! (flags & TNY_HEADER_FLAG_CACHED))
899 uncached_messages ++;
900 g_object_unref (header);
901 tny_iterator_next (iter);
903 g_object_unref (iter);
905 /* Ask for user permission to download the messages */
907 if (uncached_messages > 0) {
908 GtkResponseType response;
910 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
911 ngettext("mcen_nc_get_msg",
914 if (response == GTK_RESPONSE_CANCEL)
922 * Common code for the reply and forward actions
925 reply_forward (ReplyForwardAction action, ModestWindow *win)
927 ModestMailOperation *mail_op = NULL;
928 TnyList *header_list = NULL;
929 ReplyForwardHelper *rf_helper = NULL;
930 guint reply_forward_type;
931 gboolean continue_download;
933 g_return_if_fail (MODEST_IS_WINDOW(win));
935 /* we need an account when editing */
936 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
937 run_account_setup_wizard (win);
941 header_list = get_selected_headers (win);
945 /* Check that the messages have been previously downloaded */
946 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
947 if (!continue_download) {
948 g_object_unref (header_list);
953 modest_conf_get_int (modest_runtime_get_conf (),
954 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
956 /* We assume that we can only select messages of the
957 same folder and that we reply all of them from the
958 same account. In fact the interface currently only
959 allows single selection */
962 rf_helper = g_slice_new0 (ReplyForwardHelper);
963 rf_helper->reply_forward_type = reply_forward_type;
964 rf_helper->action = action;
965 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
966 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
967 rf_helper->parent_window = GTK_WIDGET (win);
968 if (!rf_helper->account_name)
969 rf_helper->account_name =
970 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
972 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
975 /* Get header and message. Do not free them here, the
976 reply_forward_cb must do it */
977 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
978 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
979 if (!msg || !header) {
981 g_object_unref (msg);
983 g_object_unref (header);
984 g_printerr ("modest: no message found\n");
987 reply_forward_cb (NULL, header, msg, rf_helper);
989 /* Retrieve messages */
990 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
992 modest_ui_actions_get_msgs_full_error_handler,
994 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
995 modest_mail_operation_get_msgs_full (mail_op,
999 free_reply_forward_helper);
1002 g_object_unref(mail_op);
1006 g_object_unref (header_list);
1010 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1012 g_return_if_fail (MODEST_IS_WINDOW(win));
1014 reply_forward (ACTION_REPLY, win);
1018 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1020 g_return_if_fail (MODEST_IS_WINDOW(win));
1022 reply_forward (ACTION_FORWARD, win);
1026 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1028 g_return_if_fail (MODEST_IS_WINDOW(win));
1030 reply_forward (ACTION_REPLY_TO_ALL, win);
1034 modest_ui_actions_on_next (GtkAction *action,
1035 ModestWindow *window)
1037 if (MODEST_IS_MAIN_WINDOW (window)) {
1038 GtkWidget *header_view;
1040 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1041 MODEST_WIDGET_TYPE_HEADER_VIEW);
1045 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1046 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1047 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1049 g_return_if_reached ();
1054 modest_ui_actions_on_prev (GtkAction *action,
1055 ModestWindow *window)
1057 g_return_if_fail (MODEST_IS_WINDOW(window));
1059 if (MODEST_IS_MAIN_WINDOW (window)) {
1060 GtkWidget *header_view;
1061 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1062 MODEST_WIDGET_TYPE_HEADER_VIEW);
1066 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1067 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1068 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1070 g_return_if_reached ();
1075 modest_ui_actions_on_sort (GtkAction *action,
1076 ModestWindow *window)
1078 g_return_if_fail (MODEST_IS_WINDOW(window));
1080 if (MODEST_IS_MAIN_WINDOW (window)) {
1081 GtkWidget *header_view;
1082 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1083 MODEST_WIDGET_TYPE_HEADER_VIEW);
1087 /* Show sorting dialog */
1088 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1093 new_messages_arrived (ModestMailOperation *self,
1097 if (new_messages == 0)
1100 modest_platform_on_new_msg ();
1104 * This function performs the send & receive required actions. The
1105 * window is used to create the mail operation. Typically it should
1106 * always be the main window, but we pass it as argument in order to
1110 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1112 gchar *acc_name = NULL;
1113 ModestMailOperation *mail_op;
1115 /* If no account name was provided then get the current account, and if
1116 there is no current account then pick the default one: */
1117 if (!account_name) {
1118 acc_name = g_strdup (modest_window_get_active_account(win));
1120 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1122 g_printerr ("modest: cannot get default account\n");
1126 acc_name = g_strdup (account_name);
1129 /* Set send/receive operation in progress */
1130 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1132 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
1133 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1134 G_CALLBACK (_on_send_receive_progress_changed),
1137 /* Send & receive. */
1138 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1139 /* Receive and then send. The operation is tagged initially as
1140 a receive operation because the account update performs a
1141 receive and then a send. The operation changes its type
1142 internally, so the progress objects will receive the proper
1143 progress information */
1144 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1145 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1146 g_object_unref (G_OBJECT (mail_op));
1153 * Refreshes all accounts. This function will be used by automatic
1157 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1159 GSList *account_names, *iter;
1161 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1164 iter = account_names;
1166 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1167 iter = g_slist_next (iter);
1170 modest_account_mgr_free_account_names (account_names);
1171 account_names = NULL;
1175 * Handler of the click on Send&Receive button in the main toolbar
1178 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1180 /* Check if accounts exist */
1181 gboolean accounts_exist =
1182 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1184 /* If not, allow the user to create an account before trying to send/receive. */
1185 if (!accounts_exist)
1186 modest_ui_actions_on_accounts (NULL, win);
1188 /* Refresh the active account */
1189 modest_ui_actions_do_send_receive (NULL, win);
1194 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1197 GtkWidget *header_view;
1199 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1201 header_view = modest_main_window_get_child_widget (main_window,
1202 MODEST_WIDGET_TYPE_HEADER_VIEW);
1206 conf = modest_runtime_get_conf ();
1208 /* what is saved/restored is depending on the style; thus; we save with
1209 * old style, then update the style, and restore for this new style
1211 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1213 if (modest_header_view_get_style
1214 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1215 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1216 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1218 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1219 MODEST_HEADER_VIEW_STYLE_DETAILS);
1221 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1222 MODEST_CONF_HEADER_VIEW_KEY);
1227 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1229 ModestMainWindow *main_window)
1231 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1232 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1234 /* If no header has been selected then exit */
1239 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1240 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1242 /* Update Main window title */
1243 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1244 const gchar *subject = tny_header_get_subject (header);
1245 if (subject && strlen(subject) > 0)
1246 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1248 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1251 /* Update toolbar dimming state */
1252 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1256 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1258 ModestMainWindow *main_window)
1262 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1267 headers = tny_simple_list_new ();
1268 tny_list_prepend (headers, G_OBJECT (header));
1270 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1272 g_object_unref (headers);
1276 set_active_account_from_tny_account (TnyAccount *account,
1277 ModestWindow *window)
1279 const gchar *server_acc_name = tny_account_get_id (account);
1281 /* We need the TnyAccount provided by the
1282 account store because that is the one that
1283 knows the name of the Modest account */
1284 TnyAccount *modest_server_account = modest_server_account =
1285 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1286 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1289 const gchar *modest_acc_name =
1290 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1291 modest_window_set_active_account (window, modest_acc_name);
1292 g_object_unref (modest_server_account);
1297 folder_refreshed_cb (const GObject *obj,
1301 ModestMainWindow *win = NULL;
1302 GtkWidget *header_view;
1304 g_return_if_fail (TNY_IS_FOLDER (folder));
1306 win = MODEST_MAIN_WINDOW (user_data);
1308 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1310 /* Check if folder is empty and set headers view contents style */
1311 if (tny_folder_get_all_count (folder) == 0) {
1312 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1313 modest_main_window_set_contents_style (win,
1314 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1316 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1321 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1322 TnyFolderStore *folder_store,
1324 ModestMainWindow *main_window)
1327 GtkWidget *header_view;
1329 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1331 header_view = modest_main_window_get_child_widget(main_window,
1332 MODEST_WIDGET_TYPE_HEADER_VIEW);
1336 conf = modest_runtime_get_conf ();
1338 if (TNY_IS_ACCOUNT (folder_store)) {
1340 /* Update active account */
1341 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1342 /* Show account details */
1343 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1346 if (TNY_IS_FOLDER (folder_store) && selected) {
1348 /* Update the active account */
1349 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1351 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1352 g_object_unref (account);
1356 /* Set the header style by default, it could
1357 be changed later by the refresh callback to
1359 modest_main_window_set_contents_style (main_window,
1360 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1362 /* Set folder on header view. This function
1363 will call tny_folder_refresh_async so we
1364 pass a callback that will be called when
1365 finished. We use that callback to set the
1366 empty view if there are no messages */
1367 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1368 TNY_FOLDER (folder_store),
1369 folder_refreshed_cb,
1372 /* Restore configuration. We need to do this
1373 *after* the set_folder because the widget
1374 memory asks the header view about its
1376 modest_widget_memory_restore (modest_runtime_get_conf (),
1377 G_OBJECT(header_view),
1378 MODEST_CONF_HEADER_VIEW_KEY);
1380 /* Update the active account */
1381 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1382 /* Save only if we're seeing headers */
1383 if (modest_main_window_get_contents_style (main_window) ==
1384 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1385 modest_widget_memory_save (conf, G_OBJECT (header_view),
1386 MODEST_CONF_HEADER_VIEW_KEY);
1387 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1391 /* Update toolbar dimming state */
1392 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1396 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1403 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1405 if (g_main_depth > 0)
1406 gdk_threads_enter ();
1407 online = tny_device_is_online (modest_runtime_get_device());
1410 /* already online -- the item is simply not there... */
1411 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1413 GTK_MESSAGE_WARNING,
1415 _("The %s you selected cannot be found"),
1417 gtk_dialog_run (GTK_DIALOG(dialog));
1419 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1423 GTK_RESPONSE_REJECT,
1425 GTK_RESPONSE_ACCEPT,
1427 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1428 "Do you want to get online?"), item);
1429 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1430 gtk_label_new (txt), FALSE, FALSE, 0);
1431 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1434 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1435 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1436 // modest_platform_connect_and_wait ();
1439 gtk_widget_destroy (dialog);
1440 if (g_main_depth > 0)
1441 gdk_threads_leave ();
1445 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1448 /* g_message ("%s %s", __FUNCTION__, link); */
1453 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1456 modest_platform_activate_uri (link);
1460 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1463 modest_platform_show_uri_popup (link);
1467 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1470 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1474 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1475 const gchar *address,
1478 /* g_message ("%s %s", __FUNCTION__, address); */
1482 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1484 TnyTransportAccount *transport_account;
1485 ModestMailOperation *mail_operation;
1487 gchar *account_name, *from;
1488 ModestAccountMgr *account_mgr;
1489 gchar *info_text = NULL;
1491 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1493 data = modest_msg_edit_window_get_msg_data (edit_window);
1495 account_mgr = modest_runtime_get_account_mgr();
1496 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1498 account_name = modest_account_mgr_get_default_account (account_mgr);
1499 if (!account_name) {
1500 g_printerr ("modest: no account found\n");
1501 modest_msg_edit_window_free_msg_data (edit_window, data);
1505 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1506 account_name = g_strdup (data->account_name);
1510 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1511 (modest_runtime_get_account_store(),
1513 TNY_ACCOUNT_TYPE_TRANSPORT));
1514 if (!transport_account) {
1515 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1516 g_free (account_name);
1517 modest_msg_edit_window_free_msg_data (edit_window, data);
1520 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1522 /* Create the mail operation */
1523 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1524 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1526 modest_mail_operation_save_to_drafts (mail_operation,
1537 data->priority_flags);
1540 g_free (account_name);
1541 g_object_unref (G_OBJECT (transport_account));
1542 g_object_unref (G_OBJECT (mail_operation));
1544 modest_msg_edit_window_free_msg_data (edit_window, data);
1546 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1547 modest_platform_information_banner (NULL, NULL, info_text);
1551 /* For instance, when clicking the Send toolbar button when editing a message: */
1553 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1555 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1557 if (!modest_msg_edit_window_check_names (edit_window))
1560 /* FIXME: Code added just for testing. The final version will
1561 use the send queue provided by tinymail and some
1563 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1564 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1566 account_name = modest_account_mgr_get_default_account (account_mgr);
1568 if (!account_name) {
1569 g_printerr ("modest: no account found\n");
1573 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1575 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1576 account_name = g_strdup (data->account_name);
1579 /* Get the currently-active transport account for this modest account: */
1580 TnyTransportAccount *transport_account =
1581 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1582 (modest_runtime_get_account_store(),
1584 if (!transport_account) {
1585 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1586 g_free (account_name);
1587 modest_msg_edit_window_free_msg_data (edit_window, data);
1591 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1593 /* mail content checks and dialogs */
1594 if (data->subject == NULL || data->subject[0] == '\0') {
1595 GtkResponseType response;
1596 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1597 _("mcen_nc_subject_is_empty_send"));
1598 if (response == GTK_RESPONSE_CANCEL) {
1599 g_free (account_name);
1604 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1605 GtkResponseType response;
1606 gchar *note_message;
1607 gchar *note_subject = data->subject;
1608 if (note_subject == NULL || note_subject[0] == '\0')
1609 note_subject = _("mail_va_no_subject");
1610 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1611 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1613 g_free (note_message);
1614 if (response == GTK_RESPONSE_CANCEL) {
1615 g_free (account_name);
1620 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
1622 /* Create the mail operation */
1623 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1624 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1626 modest_mail_operation_send_new_mail (mail_operation,
1637 data->priority_flags);
1641 g_free (account_name);
1642 g_object_unref (G_OBJECT (transport_account));
1643 g_object_unref (G_OBJECT (mail_operation));
1645 modest_msg_edit_window_free_msg_data (edit_window, data);
1646 modest_msg_edit_window_set_sent (edit_window, TRUE);
1648 /* Save settings and close the window: */
1649 gtk_widget_destroy (GTK_WIDGET (edit_window));
1653 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1654 ModestMsgEditWindow *window)
1656 ModestMsgEditFormatState *format_state = NULL;
1658 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1659 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1661 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1664 format_state = modest_msg_edit_window_get_format_state (window);
1665 g_return_if_fail (format_state != NULL);
1667 format_state->bold = gtk_toggle_action_get_active (action);
1668 modest_msg_edit_window_set_format_state (window, format_state);
1669 g_free (format_state);
1674 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1675 ModestMsgEditWindow *window)
1677 ModestMsgEditFormatState *format_state = NULL;
1679 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1680 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1682 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1685 format_state = modest_msg_edit_window_get_format_state (window);
1686 g_return_if_fail (format_state != NULL);
1688 format_state->italics = gtk_toggle_action_get_active (action);
1689 modest_msg_edit_window_set_format_state (window, format_state);
1690 g_free (format_state);
1695 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1696 ModestMsgEditWindow *window)
1698 ModestMsgEditFormatState *format_state = NULL;
1700 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1701 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1703 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1706 format_state = modest_msg_edit_window_get_format_state (window);
1707 g_return_if_fail (format_state != NULL);
1709 format_state->bullet = gtk_toggle_action_get_active (action);
1710 modest_msg_edit_window_set_format_state (window, format_state);
1711 g_free (format_state);
1716 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1717 GtkRadioAction *selected,
1718 ModestMsgEditWindow *window)
1720 ModestMsgEditFormatState *format_state = NULL;
1721 GtkJustification value;
1723 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1725 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1728 value = gtk_radio_action_get_current_value (selected);
1730 format_state = modest_msg_edit_window_get_format_state (window);
1731 g_return_if_fail (format_state != NULL);
1733 format_state->justification = value;
1734 modest_msg_edit_window_set_format_state (window, format_state);
1735 g_free (format_state);
1739 modest_ui_actions_on_select_editor_color (GtkAction *action,
1740 ModestMsgEditWindow *window)
1742 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1743 g_return_if_fail (GTK_IS_ACTION (action));
1745 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1748 modest_msg_edit_window_select_color (window);
1752 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1753 ModestMsgEditWindow *window)
1755 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1756 g_return_if_fail (GTK_IS_ACTION (action));
1758 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1761 modest_msg_edit_window_select_background_color (window);
1765 modest_ui_actions_on_insert_image (GtkAction *action,
1766 ModestMsgEditWindow *window)
1768 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1769 g_return_if_fail (GTK_IS_ACTION (action));
1771 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1774 modest_msg_edit_window_insert_image (window);
1778 modest_ui_actions_on_attach_file (GtkAction *action,
1779 ModestMsgEditWindow *window)
1781 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1782 g_return_if_fail (GTK_IS_ACTION (action));
1784 modest_msg_edit_window_attach_file (window);
1788 modest_ui_actions_on_remove_attachments (GtkAction *action,
1789 ModestMsgEditWindow *window)
1791 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1792 g_return_if_fail (GTK_IS_ACTION (action));
1794 modest_msg_edit_window_remove_attachments (window, NULL);
1798 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1800 TnyFolderStore *parent_folder;
1801 GtkWidget *folder_view;
1803 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1805 folder_view = modest_main_window_get_child_widget (main_window,
1806 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1810 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1812 if (parent_folder) {
1813 gboolean finished = FALSE;
1815 gchar *folder_name = NULL, *suggested_name = NULL;
1817 /* Run the new folder dialog */
1819 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1824 if (result == GTK_RESPONSE_REJECT) {
1827 ModestMailOperation *mail_op;
1828 TnyFolder *new_folder = NULL;
1830 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO,
1831 G_OBJECT(main_window));
1832 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1834 new_folder = modest_mail_operation_create_folder (mail_op,
1836 (const gchar *) folder_name);
1838 g_object_unref (new_folder);
1841 g_object_unref (mail_op);
1843 g_free (folder_name);
1847 g_object_unref (parent_folder);
1852 modest_ui_actions_on_rename_folder (GtkAction *action,
1853 ModestMainWindow *main_window)
1855 TnyFolderStore *folder;
1856 GtkWidget *folder_view;
1857 GtkWidget *header_view;
1859 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1861 folder_view = modest_main_window_get_child_widget (main_window,
1862 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1866 header_view = modest_main_window_get_child_widget (main_window,
1867 MODEST_WIDGET_TYPE_HEADER_VIEW);
1872 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1874 if (folder && TNY_IS_FOLDER (folder)) {
1877 const gchar *current_name;
1879 current_name = tny_folder_get_name (TNY_FOLDER (folder));
1880 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
1881 current_name, &folder_name);
1883 if (response == GTK_RESPONSE_OK && strlen (folder_name) > 0) {
1884 ModestMailOperation *mail_op;
1886 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1887 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1890 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
1892 modest_mail_operation_rename_folder (mail_op,
1893 TNY_FOLDER (folder),
1894 (const gchar *) folder_name);
1896 g_object_unref (mail_op);
1897 g_free (folder_name);
1899 g_object_unref (folder);
1904 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
1907 GObject *win = modest_mail_operation_get_source (mail_op);
1909 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1910 _("mail_in_ui_folder_delete_error"));
1911 g_object_unref (win);
1915 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1917 TnyFolderStore *folder;
1918 GtkWidget *folder_view;
1922 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1924 folder_view = modest_main_window_get_child_widget (main_window,
1925 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1929 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1931 /* Show an error if it's an account */
1932 if (!TNY_IS_FOLDER (folder)) {
1933 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1934 _("mail_in_ui_folder_delete_error"));
1939 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1940 tny_folder_get_name (TNY_FOLDER (folder)));
1941 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1942 (const gchar *) message);
1945 if (response == GTK_RESPONSE_OK) {
1946 ModestMailOperation *mail_op =
1947 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
1948 G_OBJECT(main_window),
1949 modest_ui_actions_delete_folder_error_handler,
1952 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1954 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1955 g_object_unref (G_OBJECT (mail_op));
1958 g_object_unref (G_OBJECT (folder));
1962 modest_ui_actions_on_delete_folder (GtkAction *action,
1963 ModestMainWindow *main_window)
1965 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1967 delete_folder (main_window, FALSE);
1971 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1973 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1975 delete_folder (main_window, TRUE);
1979 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1980 const gchar* server_account_name,
1985 ModestMainWindow *main_window)
1987 g_return_if_fail(server_account_name);
1988 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1990 /* Initalize output parameters: */
1997 #ifdef MODEST_PLATFORM_MAEMO
1998 /* Maemo uses a different (awkward) button order,
1999 * It should probably just use gtk_alternative_dialog_button_order ().
2001 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2005 GTK_RESPONSE_ACCEPT,
2007 GTK_RESPONSE_REJECT,
2010 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2014 GTK_RESPONSE_REJECT,
2016 GTK_RESPONSE_ACCEPT,
2018 #endif /* MODEST_PLATFORM_MAEMO */
2020 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2022 gchar *server_name = modest_server_account_get_hostname (
2023 modest_runtime_get_account_mgr(), server_account_name);
2024 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2025 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2030 /* This causes a warning because the logical ID has no %s in it,
2031 * though the translation does, but there is not much we can do about that: */
2032 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2033 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2036 g_free (server_name);
2040 gchar *initial_username = modest_server_account_get_username (
2041 modest_runtime_get_account_mgr(), server_account_name);
2043 GtkWidget *entry_username = gtk_entry_new ();
2044 if (initial_username)
2045 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2046 /* Dim this if a connection has ever succeeded with this username,
2047 * as per the UI spec: */
2048 const gboolean username_known =
2049 modest_server_account_get_username_has_succeeded(
2050 modest_runtime_get_account_mgr(), server_account_name);
2051 gtk_widget_set_sensitive (entry_username, !username_known);
2053 #ifdef MODEST_PLATFORM_MAEMO
2054 /* Auto-capitalization is the default, so let's turn it off: */
2055 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2057 /* Create a size group to be used by all captions.
2058 * Note that HildonCaption does not create a default size group if we do not specify one.
2059 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2060 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2062 GtkWidget *caption = hildon_caption_new (sizegroup,
2063 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2064 gtk_widget_show (entry_username);
2065 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2066 FALSE, FALSE, MODEST_MARGIN_HALF);
2067 gtk_widget_show (caption);
2069 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2071 #endif /* MODEST_PLATFORM_MAEMO */
2074 GtkWidget *entry_password = gtk_entry_new ();
2075 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2076 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2078 #ifdef MODEST_PLATFORM_MAEMO
2079 /* Auto-capitalization is the default, so let's turn it off: */
2080 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2081 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2083 caption = hildon_caption_new (sizegroup,
2084 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2085 gtk_widget_show (entry_password);
2086 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2087 FALSE, FALSE, MODEST_MARGIN_HALF);
2088 gtk_widget_show (caption);
2089 g_object_unref (sizegroup);
2091 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2093 #endif /* MODEST_PLATFORM_MAEMO */
2095 /* This is not in the Maemo UI spec:
2096 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2097 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2101 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2103 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2105 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2107 modest_server_account_set_username (
2108 modest_runtime_get_account_mgr(), server_account_name,
2111 const gboolean username_was_changed =
2112 (strcmp (*username, initial_username) != 0);
2113 if (username_was_changed) {
2114 g_warning ("%s: tinymail does not yet support changing the "
2115 "username in the get_password() callback.\n", __FUNCTION__);
2120 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2122 /* We do not save the password in the configuration,
2123 * because this function is only called for passwords that should
2124 * not be remembered:
2125 modest_server_account_set_password (
2126 modest_runtime_get_account_mgr(), server_account_name,
2145 /* This is not in the Maemo UI spec:
2146 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2152 gtk_widget_destroy (dialog);
2154 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2158 modest_ui_actions_on_cut (GtkAction *action,
2159 ModestWindow *window)
2161 GtkWidget *focused_widget;
2163 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2164 if (GTK_IS_EDITABLE (focused_widget)) {
2165 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2166 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2167 GtkTextBuffer *buffer;
2168 GtkClipboard *clipboard;
2170 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2171 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2172 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2173 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2174 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2175 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2176 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2181 modest_ui_actions_on_copy (GtkAction *action,
2182 ModestWindow *window)
2184 GtkClipboard *clipboard;
2185 GtkWidget *focused_widget;
2187 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2188 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2190 if (GTK_IS_LABEL (focused_widget)) {
2191 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2192 } else if (GTK_IS_EDITABLE (focused_widget)) {
2193 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2194 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2195 GtkTextBuffer *buffer;
2196 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2197 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2198 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2199 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2200 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2201 TnyIterator *iter = tny_list_create_iterator (header_list);
2202 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2203 TnyFolder *folder = tny_header_get_folder (header);
2204 TnyAccount *account = tny_folder_get_account (folder);
2205 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2206 /* If it's POP then ask */
2207 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2208 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2209 g_object_unref (account);
2210 g_object_unref (folder);
2211 g_object_unref (header);
2212 g_object_unref (iter);
2214 /* Check that the messages have been previously downloaded */
2215 gboolean continue_download = TRUE;
2217 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window));
2218 if (continue_download)
2219 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2220 g_object_unref (header_list);
2221 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2222 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2225 /* Show information banner */
2226 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2231 modest_ui_actions_on_undo (GtkAction *action,
2232 ModestWindow *window)
2234 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2235 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2237 g_return_if_reached ();
2242 modest_ui_actions_on_paste (GtkAction *action,
2243 ModestWindow *window)
2245 GtkWidget *focused_widget;
2246 ModestMailOperation *mail_op = NULL;
2248 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2249 if (GTK_IS_EDITABLE (focused_widget)) {
2250 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2251 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2252 GtkTextBuffer *buffer;
2253 GtkClipboard *clipboard;
2255 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2256 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2257 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2258 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2259 ModestEmailClipboard *clipboard = NULL;
2260 TnyFolder *src_folder = NULL;
2261 TnyFolderStore *folder_store = NULL;
2262 TnyList *data = NULL;
2263 gboolean delete = FALSE;
2265 /* Check clipboard source */
2266 clipboard = modest_runtime_get_email_clipboard ();
2267 if (modest_email_clipboard_cleared (clipboard))
2270 /* Get elements to paste */
2271 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2273 /* Create a new mail operation */
2274 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2275 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2278 /* Get destination folder */
2279 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2281 /* transfer messages */
2283 modest_mail_operation_xfer_msgs (mail_op,
2285 TNY_FOLDER (folder_store),
2290 } else if (src_folder != NULL) {
2291 modest_mail_operation_xfer_folder (mail_op,
2299 g_object_unref (data);
2300 if (src_folder != NULL)
2301 g_object_unref (src_folder);
2302 if (folder_store != NULL)
2303 g_object_unref (folder_store);
2308 modest_ui_actions_on_select_all (GtkAction *action,
2309 ModestWindow *window)
2311 GtkWidget *focused_widget;
2313 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2314 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2315 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2316 } else if (GTK_IS_LABEL (focused_widget)) {
2317 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2318 } else if (GTK_IS_EDITABLE (focused_widget)) {
2319 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2320 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2321 GtkTextBuffer *buffer;
2322 GtkTextIter start, end;
2324 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2325 gtk_text_buffer_get_start_iter (buffer, &start);
2326 gtk_text_buffer_get_end_iter (buffer, &end);
2327 gtk_text_buffer_select_range (buffer, &start, &end);
2329 else if ((MODEST_IS_FOLDER_VIEW (focused_widget)) ||
2330 (MODEST_IS_HEADER_VIEW (focused_widget))) {
2332 GtkTreeSelection *selection = NULL;
2334 /* Get header view */
2335 GtkWidget *header_view = focused_widget;
2336 if (MODEST_IS_FOLDER_VIEW (focused_widget))
2337 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2338 MODEST_WIDGET_TYPE_HEADER_VIEW);
2340 /* Select all messages */
2341 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2342 gtk_tree_selection_select_all (selection);
2344 /* Set focuse on header view */
2345 gtk_widget_grab_focus (header_view);
2347 } else if (GTK_IS_HTML (focused_widget)) {
2348 gtk_html_select_all (GTK_HTML (focused_widget));
2353 modest_ui_actions_on_mark_as_read (GtkAction *action,
2354 ModestWindow *window)
2356 g_return_if_fail (MODEST_IS_WINDOW(window));
2358 /* Mark each header as read */
2359 do_headers_action (window, headers_action_mark_as_read, NULL);
2363 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2364 ModestWindow *window)
2366 g_return_if_fail (MODEST_IS_WINDOW(window));
2368 /* Mark each header as read */
2369 do_headers_action (window, headers_action_mark_as_unread, NULL);
2373 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2374 GtkRadioAction *selected,
2375 ModestWindow *window)
2379 value = gtk_radio_action_get_current_value (selected);
2380 if (MODEST_IS_WINDOW (window)) {
2381 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2385 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2386 GtkRadioAction *selected,
2387 ModestWindow *window)
2389 TnyHeaderFlags flags;
2390 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2392 flags = gtk_radio_action_get_current_value (selected);
2393 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2396 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2397 GtkRadioAction *selected,
2398 ModestWindow *window)
2402 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2404 file_format = gtk_radio_action_get_current_value (selected);
2405 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2410 modest_ui_actions_on_zoom_plus (GtkAction *action,
2411 ModestWindow *window)
2413 g_return_if_fail (MODEST_IS_WINDOW (window));
2415 modest_window_zoom_plus (MODEST_WINDOW (window));
2419 modest_ui_actions_on_zoom_minus (GtkAction *action,
2420 ModestWindow *window)
2422 g_return_if_fail (MODEST_IS_WINDOW (window));
2424 modest_window_zoom_minus (MODEST_WINDOW (window));
2428 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2429 ModestWindow *window)
2431 ModestWindowMgr *mgr;
2432 gboolean fullscreen, active;
2433 g_return_if_fail (MODEST_IS_WINDOW (window));
2435 mgr = modest_runtime_get_window_mgr ();
2437 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2438 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2440 if (active != fullscreen) {
2441 modest_window_mgr_set_fullscreen_mode (mgr, active);
2442 gtk_window_present (GTK_WINDOW (window));
2447 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2448 ModestWindow *window)
2450 ModestWindowMgr *mgr;
2451 gboolean fullscreen;
2453 g_return_if_fail (MODEST_IS_WINDOW (window));
2455 mgr = modest_runtime_get_window_mgr ();
2456 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2457 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2459 gtk_window_present (GTK_WINDOW (window));
2463 * Used by modest_ui_actions_on_details to call do_headers_action
2466 headers_action_show_details (TnyHeader *header,
2467 ModestWindow *window,
2474 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2477 gtk_widget_show_all (dialog);
2478 gtk_dialog_run (GTK_DIALOG (dialog));
2480 gtk_widget_destroy (dialog);
2484 * Show the folder details in a ModestDetailsDialog widget
2487 show_folder_details (TnyFolder *folder,
2493 dialog = modest_details_dialog_new_with_folder (window, folder);
2496 gtk_widget_show_all (dialog);
2497 gtk_dialog_run (GTK_DIALOG (dialog));
2499 gtk_widget_destroy (dialog);
2503 * Show the header details in a ModestDetailsDialog widget
2506 modest_ui_actions_on_details (GtkAction *action,
2509 TnyList * headers_list;
2513 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2516 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2519 g_object_unref (msg);
2521 headers_list = get_selected_headers (win);
2525 iter = tny_list_create_iterator (headers_list);
2527 header = TNY_HEADER (tny_iterator_get_current (iter));
2528 headers_action_show_details (header, win, NULL);
2529 g_object_unref (header);
2531 g_object_unref (iter);
2532 g_object_unref (headers_list);
2534 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2535 GtkWidget *folder_view, *header_view;
2537 /* Check which widget has the focus */
2538 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2539 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2540 if (gtk_widget_is_focus (folder_view)) {
2541 TnyFolderStore *folder_store
2542 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2543 if (!folder_store) {
2544 g_warning ("%s: No item was selected.\n", __FUNCTION__);
2547 /* Show only when it's a folder */
2548 /* This function should not be called for account items,
2549 * because we dim the menu item for them. */
2550 if (TNY_IS_FOLDER (folder_store)) {
2551 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
2554 g_object_unref (folder_store);
2557 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2558 MODEST_WIDGET_TYPE_HEADER_VIEW);
2559 /* Show details of each header */
2560 do_headers_action (win, headers_action_show_details, header_view);
2566 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2567 ModestMsgEditWindow *window)
2569 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2571 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2575 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2576 ModestMsgEditWindow *window)
2578 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2580 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2584 modest_ui_actions_toggle_folders_view (GtkAction *action,
2585 ModestMainWindow *main_window)
2589 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2591 conf = modest_runtime_get_conf ();
2593 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2594 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2596 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2600 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2601 ModestWindow *window)
2603 gboolean active, fullscreen = FALSE;
2604 ModestWindowMgr *mgr;
2606 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2608 /* Check if we want to toggle the toolbar vuew in fullscreen
2610 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2611 "ViewShowToolbarFullScreen")) {
2615 /* Toggle toolbar */
2616 mgr = modest_runtime_get_window_mgr ();
2617 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2621 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2622 ModestMsgEditWindow *window)
2624 modest_msg_edit_window_select_font (window);
2628 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2629 const gchar *display_name,
2632 /* Do not change the application name if the widget has not
2633 the focus. This callback could be called even if the folder
2634 view has not the focus, because the handled signal could be
2635 emitted when the folder view is redrawn */
2636 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2638 gtk_window_set_title (window, display_name);
2640 gtk_window_set_title (window, " ");
2645 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2647 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2648 modest_msg_edit_window_select_contacts (window);
2652 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2654 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2655 modest_msg_edit_window_check_names (window);
2660 create_move_to_dialog (ModestWindow *win,
2661 GtkWidget *folder_view,
2662 GtkWidget **tree_view)
2664 GtkWidget *dialog, *scroll;
2666 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2668 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2670 GTK_RESPONSE_ACCEPT,
2672 GTK_RESPONSE_REJECT,
2675 /* Create scrolled window */
2676 scroll = gtk_scrolled_window_new (NULL, NULL);
2677 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2678 GTK_POLICY_AUTOMATIC,
2679 GTK_POLICY_AUTOMATIC);
2681 /* Create folder view */
2682 *tree_view = modest_platform_create_folder_view (NULL);
2684 /* It could happen that we're trying to move a message from a
2685 window (msg window for example) after the main window was
2686 closed, so we can not just get the model of the folder
2688 if (MODEST_IS_FOLDER_VIEW (folder_view))
2689 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2690 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2692 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
2693 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
2695 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2697 /* Add scroll to dialog */
2698 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2699 scroll, FALSE, FALSE, 0);
2701 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2703 /* Select INBOX or local account */
2704 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (*tree_view));
2710 * Returns TRUE if at least one of the headers of the list belongs to
2711 * a message that has been fully retrieved.
2714 has_retrieved_msgs (TnyList *list)
2717 gboolean found = FALSE;
2719 iter = tny_list_create_iterator (list);
2720 while (tny_iterator_is_done (iter) && !found) {
2722 TnyHeaderFlags flags;
2724 header = TNY_HEADER (tny_iterator_get_current (iter));
2725 flags = tny_header_get_flags (header);
2726 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2730 tny_iterator_next (iter);
2732 g_object_unref (iter);
2738 * Shows a confirmation dialog to the user when we're moving messages
2739 * from a remote server to the local storage. Returns the dialog
2740 * response. If it's other kind of movement the it always returns
2744 msgs_move_to_confirmation (GtkWindow *win,
2745 TnyFolder *dest_folder,
2748 gint response = GTK_RESPONSE_OK;
2750 /* If the destination is a local folder */
2751 if (modest_tny_folder_is_local_folder (dest_folder)) {
2752 TnyFolder *src_folder;
2756 /* Get source folder */
2757 iter = tny_list_create_iterator (headers);
2758 header = TNY_HEADER (tny_iterator_get_current (iter));
2759 src_folder = tny_header_get_folder (header);
2760 g_object_unref (header);
2761 g_object_unref (iter);
2763 /* if no src_folder, message may be an attahcment */
2764 if (src_folder == NULL)
2765 return GTK_RESPONSE_CANCEL;
2767 /* If the source is a remote folder */
2768 if (!modest_tny_folder_is_local_folder (src_folder)) {
2769 const gchar *message;
2771 if (has_retrieved_msgs (headers))
2772 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
2773 tny_list_get_length (headers));
2775 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
2776 tny_list_get_length (headers));
2778 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2779 (const gchar *) message);
2781 g_object_unref (src_folder);
2788 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2790 ModestMsgViewWindow *self = NULL;
2792 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2793 self = MODEST_MSG_VIEW_WINDOW (object);
2795 /* If there are not more messages don't do anything. The
2796 viewer will show the same message */
2797 if (!modest_msg_view_window_select_first_message (self))
2802 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
2805 GObject *win = modest_mail_operation_get_source (mail_op);
2807 /* TODO: show error message */
2808 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2809 _("mail_in_ui_folder_move_target_error"));
2810 g_object_unref (win);
2814 * UI handler for the "Move to" action when invoked from the
2818 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2819 ModestMainWindow *win)
2821 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2822 GtkWidget *header_view = NULL;
2824 TnyFolderStore *folder_store = NULL;
2825 ModestMailOperation *mail_op = NULL;
2827 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2829 /* Get the folder view */
2830 folder_view = modest_main_window_get_child_widget (win,
2831 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2833 /* Get header view */
2834 header_view = modest_main_window_get_child_widget (win,
2835 MODEST_WIDGET_TYPE_HEADER_VIEW);
2837 /* Create and run the dialog */
2838 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2839 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
2840 result = gtk_dialog_run (GTK_DIALOG(dialog));
2841 g_object_ref (tree_view);
2843 /* We do this to save an indentation level ;-) */
2844 if (result != GTK_RESPONSE_ACCEPT)
2847 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2849 if (TNY_IS_ACCOUNT (folder_store))
2852 /* Get folder or messages to transfer */
2853 if (gtk_widget_is_focus (folder_view)) {
2854 TnyFolderStore *src_folder;
2855 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2857 /* Clean folder on header view before moving it */
2858 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2860 if (TNY_IS_FOLDER (src_folder)) {
2862 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2864 modest_ui_actions_move_folder_error_handler,
2866 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2868 modest_mail_operation_xfer_folder (mail_op,
2869 TNY_FOLDER (src_folder),
2872 /* Unref mail operation */
2873 g_object_unref (G_OBJECT (mail_op));
2877 g_object_unref (G_OBJECT (src_folder));
2879 if (gtk_widget_is_focus (header_view)) {
2883 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2885 /* Ask for user confirmation */
2886 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2887 TNY_FOLDER (folder_store),
2890 /* Transfer messages */
2891 if (response == GTK_RESPONSE_OK) {
2892 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2893 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2896 modest_mail_operation_xfer_msgs (mail_op,
2898 TNY_FOLDER (folder_store),
2903 g_object_unref (G_OBJECT (mail_op));
2905 g_object_unref (headers);
2909 if (folder_store != NULL)
2910 g_object_unref (folder_store);
2911 gtk_widget_destroy (dialog);
2916 * UI handler for the "Move to" action when invoked from the
2917 * ModestMsgViewWindow
2920 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2921 ModestMsgViewWindow *win)
2923 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2925 ModestMainWindow *main_window;
2929 /* Get the folder view */
2930 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2932 folder_view = modest_main_window_get_child_widget (main_window,
2933 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2937 /* Create and run the dialog */
2938 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2939 result = gtk_dialog_run (GTK_DIALOG(dialog));
2940 g_object_ref (tree_view);
2942 if (result == GTK_RESPONSE_ACCEPT) {
2943 TnyFolderStore *folder_store;
2946 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2948 /* Create header list */
2949 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2951 headers = tny_simple_list_new ();
2952 tny_list_prepend (headers, G_OBJECT (header));
2953 g_object_unref (header);
2955 /* Ask user for confirmation. MSG-NOT404 */
2956 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2957 TNY_FOLDER (folder_store),
2960 /* Transfer current msg */
2961 if (response == GTK_RESPONSE_OK) {
2962 ModestMailOperation *mail_op;
2964 /* Create mail op */
2965 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2966 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2969 /* Transfer messages */
2970 modest_mail_operation_xfer_msgs (mail_op,
2972 TNY_FOLDER (folder_store),
2974 transfer_msgs_from_viewer_cb,
2976 g_object_unref (G_OBJECT (mail_op));
2978 g_object_unref (headers);
2979 g_object_unref (folder_store);
2981 gtk_widget_destroy (dialog);
2985 modest_ui_actions_on_move_to (GtkAction *action,
2988 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2989 MODEST_IS_MSG_VIEW_WINDOW (win));
2991 if (MODEST_IS_MAIN_WINDOW (win))
2992 modest_ui_actions_on_main_window_move_to (action,
2993 MODEST_MAIN_WINDOW (win));
2995 modest_ui_actions_on_msg_view_window_move_to (action,
2996 MODEST_MSG_VIEW_WINDOW (win));
3000 * Calls #HeadersFunc for each header already selected in the main
3001 * window or the message currently being shown in the msg view window
3004 do_headers_action (ModestWindow *win,
3008 TnyList *headers_list;
3014 headers_list = get_selected_headers (win);
3018 /* Get the folder */
3019 iter = tny_list_create_iterator (headers_list);
3020 header = TNY_HEADER (tny_iterator_get_current (iter));
3021 folder = tny_header_get_folder (header);
3022 g_object_unref (header);
3024 /* Call the function for each header */
3025 while (!tny_iterator_is_done (iter)) {
3026 header = TNY_HEADER (tny_iterator_get_current (iter));
3027 func (header, win, user_data);
3028 g_object_unref (header);
3029 tny_iterator_next (iter);
3032 /* Trick: do a poke status in order to speed up the signaling
3034 tny_folder_poke_status (folder);
3037 g_object_unref (folder);
3038 g_object_unref (iter);
3039 g_object_unref (headers_list);
3043 modest_ui_actions_view_attachment (GtkAction *action,
3044 ModestWindow *window)
3046 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3047 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3049 /* not supported window for this action */
3050 g_return_if_reached ();
3055 modest_ui_actions_save_attachments (GtkAction *action,
3056 ModestWindow *window)
3058 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3059 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3061 /* not supported window for this action */
3062 g_return_if_reached ();
3067 modest_ui_actions_remove_attachments (GtkAction *action,
3068 ModestWindow *window)
3070 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3071 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window));
3073 /* not supported window for this action */
3074 g_return_if_reached ();
3079 modest_ui_actions_on_settings (GtkAction *action,
3084 dialog = modest_platform_get_global_settings_dialog ();
3085 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3086 gtk_widget_show_all (dialog);
3088 gtk_dialog_run (GTK_DIALOG (dialog));
3090 gtk_widget_destroy (dialog);
3094 modest_ui_actions_on_help (GtkAction *action,
3097 const gchar *help_id = NULL;
3099 if (MODEST_IS_MAIN_WINDOW (win)) {
3100 const gchar *action_name;
3101 action_name = gtk_action_get_name (action);
3103 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3104 !strcmp (action_name, "HeaderViewCSMHelp")) {
3105 GtkWidget *folder_view;
3106 TnyFolderStore *folder_store;
3107 /* Get selected folder */
3108 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3109 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3110 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3112 /* Switch help_id */
3113 if (TNY_IS_FOLDER (folder_store)) {
3114 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
3115 case TNY_FOLDER_TYPE_NORMAL:
3116 help_id = "applications_email_userfolder";
3118 case TNY_FOLDER_TYPE_INBOX:
3119 help_id = "applications_email_inbox";
3121 case TNY_FOLDER_TYPE_OUTBOX:
3122 help_id = "applications_email_outbox";
3124 case TNY_FOLDER_TYPE_SENT:
3125 help_id = "applications_email_sent";
3127 case TNY_FOLDER_TYPE_DRAFTS:
3128 help_id = "applications_email_drafts";
3130 case TNY_FOLDER_TYPE_ARCHIVE:
3131 help_id = "applications_email_archive";
3137 g_object_unref (folder_store);
3139 help_id = "applications_email_mainview";
3141 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3142 help_id = "applications_email_viewer";
3143 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3144 help_id = "applications_email_editor";
3146 modest_platform_show_help (GTK_WINDOW (win), help_id);
3150 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3151 ModestWindow *window)
3153 ModestMailOperation *mail_op;
3157 headers = get_selected_headers (window);
3161 /* Create mail operation */
3162 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3164 modest_ui_actions_get_msgs_full_error_handler,
3166 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3167 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3170 g_object_unref (headers);
3171 g_object_unref (mail_op);
3175 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3176 ModestWindow *window)
3178 g_return_if_fail (MODEST_IS_WINDOW (window));
3181 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3185 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3186 ModestWindow *window)
3188 g_return_if_fail (MODEST_IS_WINDOW (window));
3191 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3195 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3196 ModestWindow *window)
3198 g_return_if_fail (MODEST_IS_WINDOW (window));
3201 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3205 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3206 ModestWindow *window)
3208 g_return_if_fail (MODEST_IS_WINDOW (window));
3211 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3215 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3216 ModestWindow *window)
3218 g_return_if_fail (MODEST_IS_WINDOW (window));
3221 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3225 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3226 ModestWindow *window)
3228 g_return_if_fail (MODEST_IS_WINDOW (window));
3231 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3235 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3236 ModestWindow *window)
3238 g_return_if_fail (MODEST_IS_WINDOW (window));
3241 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3245 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3246 ModestWindow *window)
3248 g_return_if_fail (MODEST_IS_WINDOW (window));
3251 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3255 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3257 g_return_if_fail (MODEST_IS_WINDOW (window));
3260 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3264 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3266 g_return_if_fail (MODEST_IS_WINDOW (window));
3268 modest_platform_show_search_messages (GTK_WINDOW (window));
3272 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3274 g_return_if_fail (MODEST_IS_WINDOW (win));
3275 modest_platform_show_addressbook (GTK_WINDOW (win));
3280 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3281 ModestWindow *window)
3283 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3285 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3289 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3290 ModestMailOperationState *state,
3293 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3295 /* Set send/receive operation finished */
3296 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3297 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));