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"
47 #include <tny-mime-part.h>
49 #ifdef MODEST_PLATFORM_MAEMO
50 #include "maemo/modest-osso-state-saving.h"
51 #include "maemo/modest-maemo-utils.h"
52 #include "maemo/modest-hildon-includes.h"
53 #endif /* MODEST_PLATFORM_MAEMO */
55 #include "widgets/modest-ui-constants.h"
56 #include <widgets/modest-main-window.h>
57 #include <widgets/modest-msg-view-window.h>
58 #include <widgets/modest-account-view-window.h>
59 #include <widgets/modest-details-dialog.h>
60 #include <widgets/modest-attachments-view.h>
61 #include "widgets/modest-folder-view.h"
62 #include "widgets/modest-global-settings-dialog.h"
63 #include "modest-connection-specific-smtp-window.h"
64 #include "modest-account-mgr-helpers.h"
65 #include "modest-mail-operation.h"
66 #include "modest-text-utils.h"
68 #ifdef MODEST_HAVE_EASYSETUP
69 #include "easysetup/modest-easysetup-wizard.h"
70 #endif /* MODEST_HAVE_EASYSETUP */
72 #include <modest-widget-memory.h>
73 #include <tny-error.h>
74 #include <tny-simple-list.h>
75 #include <tny-msg-view.h>
76 #include <tny-device.h>
77 #include <tny-merge-folder.h>
79 #include <gtkhtml/gtkhtml.h>
81 typedef struct _GetMsgAsyncHelper {
83 ModestMailOperation *mail_op;
90 typedef enum _ReplyForwardAction {
96 typedef struct _ReplyForwardHelper {
97 guint reply_forward_type;
98 ReplyForwardAction action;
100 GtkWidget *parent_window;
101 } ReplyForwardHelper;
103 typedef struct _PasteAsAttachmentHelper {
104 ModestMsgEditWindow *window;
106 } PasteAsAttachmentHelper;
110 * The do_headers_action uses this kind of functions to perform some
111 * action to each member of a list of headers
113 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
115 static void do_headers_action (ModestWindow *win,
119 static void open_msg_cb (ModestMailOperation *mail_op,
124 static void reply_forward_cb (ModestMailOperation *mail_op,
129 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
131 static void folder_refreshed_cb (ModestMailOperation *mail_op,
135 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
136 ModestMailOperationState *state,
140 download_uncached_messages (TnyList *header_list, GtkWindow *win,
145 run_account_setup_wizard (ModestWindow *win)
147 ModestEasysetupWizardDialog *wizard;
149 g_return_if_fail (MODEST_IS_WINDOW(win));
151 wizard = modest_easysetup_wizard_dialog_new ();
152 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
154 /* Don't make this a modal window, because secondary windows will then
155 * be unusable, freezing the UI: */
156 /* gtk_window_set_modal (GTK_WINDOW (wizard), TRUE); */
158 gtk_dialog_run (GTK_DIALOG (wizard));
159 gtk_widget_destroy (GTK_WIDGET (wizard));
164 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
167 const gchar *authors[] = {
168 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
171 about = gtk_about_dialog_new ();
172 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
173 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
174 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
175 _("Copyright (c) 2006, Nokia Corporation\n"
176 "All rights reserved."));
177 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
178 _("a modest e-mail client\n\n"
179 "design and implementation: Dirk-Jan C. Binnema\n"
180 "contributions from the fine people at KC and Ig\n"
181 "uses the tinymail email framework written by Philip van Hoof"));
182 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
183 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
184 gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
185 gtk_window_set_modal (GTK_WINDOW (about), TRUE);
187 gtk_dialog_run (GTK_DIALOG (about));
188 gtk_widget_destroy(about);
192 * Gets the list of currently selected messages. If the win is the
193 * main window, then it returns a newly allocated list of the headers
194 * selected in the header view. If win is the msg view window, then
195 * the value returned is a list with just a single header.
197 * The caller of this funcion must free the list.
200 get_selected_headers (ModestWindow *win)
202 if (MODEST_IS_MAIN_WINDOW(win)) {
203 GtkWidget *header_view;
205 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
206 MODEST_WIDGET_TYPE_HEADER_VIEW);
207 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
209 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
210 /* for MsgViewWindows, we simply return a list with one element */
212 TnyList *list = NULL;
214 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
215 if (header != NULL) {
216 list = tny_simple_list_new ();
217 tny_list_prepend (list, G_OBJECT(header));
218 g_object_unref (G_OBJECT(header));
228 headers_action_mark_as_read (TnyHeader *header,
232 TnyHeaderFlags flags;
234 g_return_if_fail (TNY_IS_HEADER(header));
236 flags = tny_header_get_flags (header);
237 if (flags & TNY_HEADER_FLAG_SEEN) return;
238 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
242 headers_action_mark_as_unread (TnyHeader *header,
246 TnyHeaderFlags flags;
248 g_return_if_fail (TNY_IS_HEADER(header));
250 flags = tny_header_get_flags (header);
251 if (flags & TNY_HEADER_FLAG_SEEN) {
252 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
256 /** A convenience method, because deleting a message is
257 * otherwise complicated, and it's best to change it in one place
260 void modest_do_message_delete (TnyHeader *header, ModestWindow *win)
262 ModestMailOperation *mail_op = NULL;
263 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
264 win ? G_OBJECT(win) : NULL);
265 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
268 /* Always delete. TODO: Move to trash still not supported */
269 modest_mail_operation_remove_msg (mail_op, header, FALSE);
270 g_object_unref (G_OBJECT (mail_op));
274 headers_action_delete (TnyHeader *header,
278 modest_do_message_delete (header, win);
281 /** After deleing a message that is currently visible in a window,
282 * show the next message from the list, or close the window if there are no more messages.
284 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
286 /* Close msg view window or select next */
287 if (modest_msg_view_window_last_message_selected (win) &&
288 modest_msg_view_window_first_message_selected (win)) {
289 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
291 modest_msg_view_window_select_next_message (win);
296 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
298 TnyList *header_list = NULL;
299 TnyIterator *iter = NULL;
300 TnyHeader *header = NULL;
301 gchar *message = NULL;
304 ModestWindowMgr *mgr;
305 GtkWidget *header_view = NULL;
307 g_return_if_fail (MODEST_IS_WINDOW(win));
309 /* Check first if the header view has the focus */
310 if (MODEST_IS_MAIN_WINDOW (win)) {
312 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
313 MODEST_WIDGET_TYPE_HEADER_VIEW);
314 if (!gtk_widget_is_focus (header_view))
318 header_list = get_selected_headers (win);
319 if (!header_list) return;
321 /* Check if any of the headers are already opened, or in the process of being opened */
322 if (MODEST_IS_MAIN_WINDOW (win)) {
324 iter = tny_list_create_iterator (header_list);
326 mgr = modest_runtime_get_window_mgr ();
327 while (!tny_iterator_is_done (iter) && !found) {
328 header = TNY_HEADER (tny_iterator_get_current (iter));
330 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
331 g_object_unref (header);
334 tny_iterator_next (iter);
336 g_object_unref (iter);
341 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
342 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
344 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
348 g_object_unref (header_list);
354 if (tny_list_get_length(header_list) == 1) {
355 iter = tny_list_create_iterator (header_list);
356 header = TNY_HEADER (tny_iterator_get_current (iter));
358 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
359 g_object_unref (header);
362 g_object_unref (iter);
364 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
365 tny_list_get_length(header_list)), desc);
367 /* Confirmation dialog */
368 printf("DEBUG: %s\n", __FUNCTION__);
369 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
373 if (response == GTK_RESPONSE_OK) {
374 ModestWindow *main_window = NULL;
375 ModestWindowMgr *mgr = NULL;
376 GtkTreeModel *model = NULL;
377 GtkTreeSelection *sel = NULL;
378 GList *sel_list = NULL, *tmp = NULL;
379 GtkTreeRowReference *row_reference = NULL;
380 GtkTreePath *next_path = NULL;
382 /* Find last selected row */
383 if (MODEST_IS_MAIN_WINDOW (win)) {
384 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
385 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
386 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
387 for (tmp=sel_list; tmp; tmp=tmp->next) {
388 if (tmp->next == NULL) {
389 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
390 gtk_tree_path_next (next_path);
391 row_reference = gtk_tree_row_reference_new (model, next_path);
392 gtk_tree_path_free (next_path);
397 /* Remove each header. If it's a view window header_view == NULL */
398 do_headers_action (win, headers_action_delete, header_view);
400 /* refresh the header view (removing marked-as-deleted)*/
401 modest_header_view_refilter (MODEST_HEADER_VIEW(header_view));
403 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
404 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
406 /* Get main window */
407 mgr = modest_runtime_get_window_mgr ();
408 main_window = modest_window_mgr_get_main_window (mgr);
411 /* Move cursor to next row */
414 /* Select next row */
415 if (gtk_tree_row_reference_valid (row_reference)) {
416 next_path = gtk_tree_row_reference_get_path (row_reference);
417 gtk_tree_selection_select_path (sel, next_path);
418 gtk_tree_path_free (next_path);
420 if (row_reference != NULL)
421 gtk_tree_row_reference_free (row_reference);
424 /* Update toolbar dimming state */
425 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
428 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
429 g_list_free (sel_list);
435 g_object_unref (header_list);
441 /* delete either message or folder, based on where we are */
443 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
445 g_return_if_fail (MODEST_IS_WINDOW(win));
447 /* Check first if the header view has the focus */
448 if (MODEST_IS_MAIN_WINDOW (win)) {
450 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
451 MODEST_WIDGET_TYPE_FOLDER_VIEW);
452 if (gtk_widget_is_focus (w)) {
453 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
457 modest_ui_actions_on_delete_message (action, win);
463 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
465 #ifdef MODEST_PLATFORM_MAEMO
466 modest_osso_save_state();
467 #endif /* MODEST_PLATFORM_MAEMO */
469 g_debug ("closing down, clearing %d item(s) from operation queue",
470 modest_mail_operation_queue_num_elements
471 (modest_runtime_get_mail_operation_queue()));
473 /* cancel all outstanding operations */
474 modest_mail_operation_queue_cancel_all
475 (modest_runtime_get_mail_operation_queue());
477 g_debug ("queue has been cleared");
479 /* note: when modest-tny-account-store is finalized,
480 it will automatically set all network connections
487 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
491 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
493 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
494 /* gtk_widget_destroy (GTK_WIDGET (win)); */
495 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
496 /* gboolean ret_value; */
497 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
498 /* } else if (MODEST_IS_WINDOW (win)) { */
499 /* gtk_widget_destroy (GTK_WIDGET (win)); */
501 /* g_return_if_reached (); */
506 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
508 GtkClipboard *clipboard = NULL;
509 gchar *selection = NULL;
511 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
512 selection = gtk_clipboard_wait_for_text (clipboard);
514 /* Question: why is the clipboard being used here?
515 * It doesn't really make a lot of sense. */
519 modest_address_book_add_address (selection);
525 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
527 /* This is currently only implemented for Maemo */
528 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
529 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
530 run_account_setup_wizard (win);
533 /* Show the list of accounts: */
534 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
535 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW (win));
537 /* Don't make this a modal window, because secondary windows will then
538 * be unusable, freezing the UI: */
539 /* gtk_window_set_modal (GTK_WINDOW (account_win), TRUE); */
540 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
543 GtkWidget *dialog, *label;
545 /* Create the widgets */
547 dialog = gtk_dialog_new_with_buttons ("Message",
549 GTK_DIALOG_DESTROY_WITH_PARENT,
553 label = gtk_label_new ("Hello World!");
555 /* Ensure that the dialog box is destroyed when the user responds. */
557 g_signal_connect_swapped (dialog, "response",
558 G_CALLBACK (gtk_widget_destroy),
561 /* Add the label, and show everything we've added to the dialog. */
563 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
565 gtk_widget_show_all (dialog);
566 #endif /* MODEST_PLATFORM_MAEMO */
570 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
572 ModestWindow *main_window = MODEST_WINDOW (user_data);
574 /* Save any changes. */
575 modest_connection_specific_smtp_window_save_server_accounts (
576 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
577 modest_window_get_active_account (main_window));
578 gtk_widget_destroy (GTK_WIDGET (window));
584 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
586 /* This is currently only implemented for Maemo,
587 * because it requires an API (libconic) to detect different connection
590 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
592 /* Create the window if necessary: */
593 const gchar *active_account_name = modest_window_get_active_account (win);
595 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
596 * or show the default account?
597 * If we show the default account then the account name should be shown in
598 * the window when we show it. */
599 if (!active_account_name) {
600 g_warning ("%s: No account is active.", __FUNCTION__);
604 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
605 modest_connection_specific_smtp_window_fill_with_connections (
606 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
607 modest_runtime_get_account_mgr(),
608 active_account_name);
610 /* Show the window: */
611 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
612 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
613 gtk_widget_show (specific_window);
615 /* Save changes when the window is hidden: */
616 g_signal_connect (specific_window, "hide",
617 G_CALLBACK (on_smtp_servers_window_hide), win);
618 #endif /* MODEST_PLATFORM_MAEMO */
622 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
624 ModestWindow *msg_win = NULL;
626 TnyFolder *folder = NULL;
627 gchar *account_name = NULL;
628 gchar *from_str = NULL;
629 /* GError *err = NULL; */
630 TnyAccount *account = NULL;
631 ModestWindowMgr *mgr;
632 gchar *signature = NULL, *blank_and_signature = NULL;
634 /* if there are no accounts yet, just show the wizard */
635 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
636 run_account_setup_wizard (win);
640 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
642 account_name = g_strdup (modest_window_get_active_account (win));
644 g_printerr ("modest: no account found\n");
648 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
650 TNY_ACCOUNT_TYPE_STORE);
652 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
656 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
658 g_printerr ("modest: failed get from string for '%s'\n", account_name);
662 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
663 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
664 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
665 MODEST_ACCOUNT_SIGNATURE, FALSE);
666 blank_and_signature = g_strconcat ("\n", signature, NULL);
669 blank_and_signature = g_strdup ("");
672 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
674 g_printerr ("modest: failed to create new msg\n");
678 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
680 g_printerr ("modest: failed to find Drafts folder\n");
685 /* Create and register edit window */
686 /* This is destroyed by TOOD. */
687 msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
688 mgr = modest_runtime_get_window_mgr ();
689 modest_window_mgr_register_window (mgr, msg_win);
692 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
694 gtk_widget_show_all (GTK_WIDGET (msg_win));
697 g_free (account_name);
699 g_free (blank_and_signature);
701 g_object_unref (msg_win);
703 g_object_unref (G_OBJECT(account));
705 g_object_unref (G_OBJECT(msg));
707 g_object_unref (G_OBJECT(folder));
711 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
715 ModestMailOperationStatus status;
717 /* If there is no message or the operation was not successful */
718 status = modest_mail_operation_get_status (mail_op);
719 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
721 /* Remove the header from the preregistered uids */
722 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
732 open_msg_cb (ModestMailOperation *mail_op,
737 ModestWindowMgr *mgr = NULL;
738 ModestWindow *parent_win = NULL;
739 ModestWindow *win = NULL;
740 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
741 gchar *account = NULL;
744 /* Do nothing if there was any problem with the mail
745 operation. The error will be shown by the error_handler of
746 the mail operation */
747 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
751 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
752 folder = tny_header_get_folder (header);
754 /* Mark header as read */
755 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
758 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
760 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
762 /* Gets folder type (OUTBOX headers will be opened in edit window */
763 if (modest_tny_folder_is_local_folder (folder))
764 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
766 /* If the header is in the drafts folder then open the editor,
767 else the message view window */
768 if ((folder_type == TNY_FOLDER_TYPE_DRAFTS) ||
769 (folder_type == TNY_FOLDER_TYPE_OUTBOX)) {
770 /* we cannot edit without a valid account... */
771 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
772 run_account_setup_wizard(parent_win);
775 win = modest_msg_edit_window_new (msg, account, TRUE);
778 gchar *uid = modest_tny_folder_get_header_unique_id (header);
780 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
781 GtkWidget *header_view;
782 GtkTreeSelection *sel;
783 GList *sel_list = NULL;
786 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
787 MODEST_WIDGET_TYPE_HEADER_VIEW);
789 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
790 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
792 if (sel_list != NULL) {
793 GtkTreeRowReference *row_reference;
795 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
796 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
797 g_list_free (sel_list);
799 win = modest_msg_view_window_new_with_header_model (msg,
804 gtk_tree_row_reference_free (row_reference);
806 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
809 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
814 /* Register and show new window */
816 mgr = modest_runtime_get_window_mgr ();
817 modest_window_mgr_register_window (mgr, win);
818 g_object_unref (win);
819 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
820 gtk_widget_show_all (GTK_WIDGET(win));
823 /* Update toolbar dimming state */
824 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
825 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
831 g_object_unref (parent_win);
832 g_object_unref (folder);
836 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
840 GObject *win = modest_mail_operation_get_source (mail_op);
842 error = modest_mail_operation_get_error (mail_op);
843 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
845 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
847 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
850 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
851 _("mail_ni_ui_folder_get_msg_folder_error"));
855 g_object_unref (win);
859 * This function is used by both modest_ui_actions_on_open and
860 * modest_ui_actions_on_header_activated. This way we always do the
861 * same when trying to open messages.
864 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
866 ModestWindowMgr *mgr = NULL;
867 TnyIterator *iter = NULL;
868 ModestMailOperation *mail_op = NULL;
869 TnyList *not_opened_headers = NULL;
870 TnyHeaderFlags flags = 0;
872 /* Look if we already have a message view for each header. If
873 true, then remove the header from the list of headers to
875 mgr = modest_runtime_get_window_mgr ();
876 iter = tny_list_create_iterator (headers);
877 not_opened_headers = tny_simple_list_new ();
879 while (!tny_iterator_is_done (iter)) {
881 ModestWindow *window = NULL;
882 TnyHeader *header = NULL;
883 gboolean found = FALSE;
885 header = TNY_HEADER (tny_iterator_get_current (iter));
887 flags = tny_header_get_flags (header);
890 found = modest_window_mgr_find_registered_header (mgr, header, &window);
892 /* Do not open again the message and present the
893 window to the user */
896 gtk_window_present (GTK_WINDOW (window));
898 /* the header has been registered already, we don't do
899 * anything but wait for the window to come up*/
900 g_debug ("header %p already registered, waiting for window", header);
902 tny_list_append (not_opened_headers, G_OBJECT (header));
906 g_object_unref (header);
908 tny_iterator_next (iter);
910 g_object_unref (iter);
913 /* If some messages would have to be downloaded, ask the user to
914 * make a connection. It's generally easier to do this here (in the mainloop)
915 * than later in a thread:
917 if (tny_list_get_length (not_opened_headers) > 0) {
919 gboolean found = FALSE;
921 iter = tny_list_create_iterator (not_opened_headers);
922 while (!tny_iterator_is_done (iter) && !found) {
923 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
924 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
927 tny_iterator_next (iter);
929 g_object_unref (header);
931 g_object_unref (iter);
933 if (found && !modest_platform_connect_and_wait (GTK_WINDOW (win), NULL)) {
934 g_object_unref (not_opened_headers);
939 /* Register the headers before actually creating the windows: */
940 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
941 while (!tny_iterator_is_done (iter_not_opened)) {
942 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
944 modest_window_mgr_register_header (mgr, header);
945 g_object_unref (header);
948 tny_iterator_next (iter_not_opened);
950 g_object_unref (iter_not_opened);
951 iter_not_opened = NULL;
953 /* Open each message */
954 if (tny_list_get_length (not_opened_headers) > 0) {
955 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
957 modest_ui_actions_get_msgs_full_error_handler,
959 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
960 if (tny_list_get_length (not_opened_headers) > 1) {
961 modest_mail_operation_get_msgs_full (mail_op,
967 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
968 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
969 modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
970 g_object_unref (header);
971 g_object_unref (iter);
973 g_object_unref (mail_op);
977 if (not_opened_headers != NULL)
978 g_object_unref (not_opened_headers);
982 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
987 headers = get_selected_headers (win);
992 _modest_ui_actions_open (headers, win);
994 g_object_unref(headers);
999 free_reply_forward_helper (gpointer data)
1001 ReplyForwardHelper *helper;
1003 helper = (ReplyForwardHelper *) data;
1004 g_free (helper->account_name);
1005 g_slice_free (ReplyForwardHelper, helper);
1009 reply_forward_cb (ModestMailOperation *mail_op,
1015 ReplyForwardHelper *rf_helper;
1016 ModestWindow *msg_win = NULL;
1017 ModestEditType edit_type;
1019 TnyAccount *account = NULL;
1020 ModestWindowMgr *mgr = NULL;
1021 gchar *signature = NULL;
1023 /* If there was any error. The mail operation could be NULL,
1024 this means that we already have the message downloaded and
1025 that we didn't do a mail operation to retrieve it */
1026 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1029 g_return_if_fail (user_data != NULL);
1030 rf_helper = (ReplyForwardHelper *) user_data;
1032 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1033 rf_helper->account_name);
1034 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1035 rf_helper->account_name,
1036 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1037 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1038 rf_helper->account_name,
1039 MODEST_ACCOUNT_SIGNATURE, FALSE);
1042 /* Create reply mail */
1043 switch (rf_helper->action) {
1046 modest_tny_msg_create_reply_msg (msg, header, from, signature,
1047 rf_helper->reply_forward_type,
1048 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1050 case ACTION_REPLY_TO_ALL:
1052 modest_tny_msg_create_reply_msg (msg, header, from, signature, rf_helper->reply_forward_type,
1053 MODEST_TNY_MSG_REPLY_MODE_ALL);
1054 edit_type = MODEST_EDIT_TYPE_REPLY;
1056 case ACTION_FORWARD:
1058 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1059 edit_type = MODEST_EDIT_TYPE_FORWARD;
1062 g_return_if_reached ();
1069 g_printerr ("modest: failed to create message\n");
1073 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1074 rf_helper->account_name,
1075 TNY_ACCOUNT_TYPE_STORE);
1077 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1081 /* Create and register the windows */
1082 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
1083 mgr = modest_runtime_get_window_mgr ();
1084 modest_window_mgr_register_window (mgr, msg_win);
1086 if (rf_helper->parent_window != NULL) {
1087 gdouble parent_zoom;
1089 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1090 modest_window_set_zoom (msg_win, parent_zoom);
1093 /* Show edit window */
1094 gtk_widget_show_all (GTK_WIDGET (msg_win));
1098 g_object_unref (msg_win);
1100 g_object_unref (G_OBJECT (new_msg));
1102 g_object_unref (G_OBJECT (account));
1103 /* g_object_unref (msg); */
1104 free_reply_forward_helper (rf_helper);
1108 * Checks a list of headers. If any of them are not currently
1109 * downloaded (CACHED) then it asks the user for permission to
1112 * Returns FALSE if the user does not want to download the
1113 * messages. Returns TRUE if the user allowed the download or if all
1114 * of them are currently downloaded
1117 download_uncached_messages (TnyList *header_list,
1123 gint uncached_messages = 0;
1125 iter = tny_list_create_iterator (header_list);
1126 while (!tny_iterator_is_done (iter)) {
1129 header = TNY_HEADER (tny_iterator_get_current (iter));
1131 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1132 uncached_messages ++;
1133 g_object_unref (header);
1136 tny_iterator_next (iter);
1138 g_object_unref (iter);
1140 /* Ask for user permission to download the messages */
1142 if (uncached_messages > 0) {
1143 GtkResponseType response;
1145 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1146 _("emev_nc_include_original"));
1149 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1150 ngettext("mcen_nc_get_msg",
1152 uncached_messages));
1153 if (response == GTK_RESPONSE_CANCEL)
1156 /* If a download will be necessary, make sure that we have a connection: */
1157 retval = modest_platform_connect_and_wait(win, NULL);
1165 * Common code for the reply and forward actions
1168 reply_forward (ReplyForwardAction action, ModestWindow *win)
1170 ModestMailOperation *mail_op = NULL;
1171 TnyList *header_list = NULL;
1172 ReplyForwardHelper *rf_helper = NULL;
1173 guint reply_forward_type;
1174 gboolean continue_download = TRUE;
1175 gboolean do_retrieve = TRUE;
1177 g_return_if_fail (MODEST_IS_WINDOW(win));
1179 /* we need an account when editing */
1180 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1181 run_account_setup_wizard (win);
1185 header_list = get_selected_headers (win);
1189 reply_forward_type =
1190 modest_conf_get_int (modest_runtime_get_conf (),
1191 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1194 /* Check that the messages have been previously downloaded */
1195 do_retrieve = (action == ACTION_FORWARD) || (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1197 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win), TRUE);
1198 if (!continue_download) {
1199 g_object_unref (header_list);
1203 /* We assume that we can only select messages of the
1204 same folder and that we reply all of them from the
1205 same account. In fact the interface currently only
1206 allows single selection */
1209 rf_helper = g_slice_new0 (ReplyForwardHelper);
1210 rf_helper->reply_forward_type = reply_forward_type;
1211 rf_helper->action = action;
1212 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1214 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1215 rf_helper->parent_window = GTK_WIDGET (win);
1216 if (!rf_helper->account_name)
1217 rf_helper->account_name =
1218 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1220 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1223 /* Get header and message. Do not free them here, the
1224 reply_forward_cb must do it */
1225 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1226 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1227 if (!msg || !header) {
1229 g_object_unref (msg);
1230 g_printerr ("modest: no message found\n");
1233 reply_forward_cb (NULL, header, msg, rf_helper);
1236 g_object_unref (header);
1241 /* Only reply/forward to one message */
1242 iter = tny_list_create_iterator (header_list);
1243 header = TNY_HEADER (tny_iterator_get_current (iter));
1244 g_object_unref (iter);
1247 /* Retrieve messages */
1249 mail_op = modest_mail_operation_new_with_error_handling (
1250 MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1252 modest_ui_actions_get_msgs_full_error_handler,
1254 modest_mail_operation_queue_add (
1255 modest_runtime_get_mail_operation_queue (), mail_op);
1257 modest_mail_operation_get_msg (mail_op,
1262 g_object_unref(mail_op);
1264 /* we put a ref here to prevent double unref as the reply
1265 * forward callback unrefs the header at its end */
1266 reply_forward_cb (NULL, header, NULL, rf_helper);
1270 g_object_unref (header);
1276 g_object_unref (header_list);
1280 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1282 g_return_if_fail (MODEST_IS_WINDOW(win));
1284 reply_forward (ACTION_REPLY, win);
1288 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1290 g_return_if_fail (MODEST_IS_WINDOW(win));
1292 reply_forward (ACTION_FORWARD, win);
1296 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1298 g_return_if_fail (MODEST_IS_WINDOW(win));
1300 reply_forward (ACTION_REPLY_TO_ALL, win);
1304 modest_ui_actions_on_next (GtkAction *action,
1305 ModestWindow *window)
1307 if (MODEST_IS_MAIN_WINDOW (window)) {
1308 GtkWidget *header_view;
1310 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1311 MODEST_WIDGET_TYPE_HEADER_VIEW);
1315 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1316 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1317 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1319 g_return_if_reached ();
1324 modest_ui_actions_on_prev (GtkAction *action,
1325 ModestWindow *window)
1327 g_return_if_fail (MODEST_IS_WINDOW(window));
1329 if (MODEST_IS_MAIN_WINDOW (window)) {
1330 GtkWidget *header_view;
1331 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1332 MODEST_WIDGET_TYPE_HEADER_VIEW);
1336 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1337 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1338 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1340 g_return_if_reached ();
1345 modest_ui_actions_on_sort (GtkAction *action,
1346 ModestWindow *window)
1348 g_return_if_fail (MODEST_IS_WINDOW(window));
1350 if (MODEST_IS_MAIN_WINDOW (window)) {
1351 GtkWidget *header_view;
1352 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1353 MODEST_WIDGET_TYPE_HEADER_VIEW);
1355 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1360 /* Show sorting dialog */
1361 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1366 new_messages_arrived (ModestMailOperation *self,
1370 if (new_messages == 0)
1373 modest_platform_on_new_msg ();
1377 * This function performs the send & receive required actions. The
1378 * window is used to create the mail operation. Typically it should
1379 * always be the main window, but we pass it as argument in order to
1383 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1385 gchar *acc_name = NULL;
1386 ModestMailOperation *mail_op;
1388 /* If no account name was provided then get the current account, and if
1389 there is no current account then pick the default one: */
1390 if (!account_name) {
1391 acc_name = g_strdup (modest_window_get_active_account(win));
1393 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1395 g_printerr ("modest: cannot get default account\n");
1399 acc_name = g_strdup (account_name);
1402 /* Set send/receive operation in progress */
1403 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1405 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1407 modest_ui_actions_send_receive_error_handler,
1410 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1411 G_CALLBACK (_on_send_receive_progress_changed),
1414 /* Send & receive. */
1415 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1416 /* Receive and then send. The operation is tagged initially as
1417 a receive operation because the account update performs a
1418 receive and then a send. The operation changes its type
1419 internally, so the progress objects will receive the proper
1420 progress information */
1421 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1422 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1423 g_object_unref (G_OBJECT (mail_op));
1431 modest_ui_actions_do_cancel_send (const gchar *account_name,
1434 TnyTransportAccount *transport_account;
1435 TnySendQueue *send_queue = NULL;
1436 GError *error = NULL;
1438 /* Get transport account */
1440 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1441 (modest_runtime_get_account_store(),
1443 TNY_ACCOUNT_TYPE_TRANSPORT));
1444 if (!transport_account) {
1445 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1450 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1451 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1452 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1453 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1454 "modest: could not find send queue for account\n");
1456 /* Keeep messages in outbox folder */
1457 tny_send_queue_cancel (send_queue, FALSE, &error);
1461 if (transport_account != NULL)
1462 g_object_unref (G_OBJECT (transport_account));
1466 modest_ui_actions_cancel_send_all (ModestWindow *win)
1468 GSList *account_names, *iter;
1470 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1473 iter = account_names;
1475 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1476 iter = g_slist_next (iter);
1479 modest_account_mgr_free_account_names (account_names);
1480 account_names = NULL;
1484 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1487 /* Check if accounts exist */
1488 gboolean accounts_exist =
1489 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1491 /* If not, allow the user to create an account before trying to send/receive. */
1492 if (!accounts_exist)
1493 modest_ui_actions_on_accounts (NULL, win);
1495 /* Cancel all sending operaitons */
1496 modest_ui_actions_cancel_send_all (win);
1500 * Refreshes all accounts. This function will be used by automatic
1504 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1506 GSList *account_names, *iter;
1508 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1511 iter = account_names;
1513 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1514 iter = g_slist_next (iter);
1517 modest_account_mgr_free_account_names (account_names);
1518 account_names = NULL;
1522 modest_do_refresh_current_folder(ModestWindow *win)
1524 /* Refresh currently selected folder. Note that if we only
1525 want to retreive the headers, then the refresh only will
1526 invoke a poke_status over all folders, i.e., only the
1527 total/unread count will be updated */
1528 if (MODEST_IS_MAIN_WINDOW (win)) {
1529 GtkWidget *header_view, *folder_view;
1530 TnyFolderStore *folder_store;
1532 /* Get folder and header view */
1534 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1535 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1537 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1539 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1541 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1542 MODEST_WIDGET_TYPE_HEADER_VIEW);
1544 /* We do not need to set the contents style
1545 because it hasn't changed. We also do not
1546 need to save the widget status. Just force
1548 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1549 TNY_FOLDER (folder_store),
1550 folder_refreshed_cb,
1551 MODEST_MAIN_WINDOW (win));
1555 g_object_unref (folder_store);
1561 * Handler of the click on Send&Receive button in the main toolbar
1564 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1566 /* Check if accounts exist */
1567 gboolean accounts_exist =
1568 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1570 /* If not, allow the user to create an account before trying to send/receive. */
1571 if (!accounts_exist)
1572 modest_ui_actions_on_accounts (NULL, win);
1574 modest_do_refresh_current_folder (win);
1576 /* Refresh the active account */
1577 modest_ui_actions_do_send_receive (NULL, win);
1582 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1585 GtkWidget *header_view;
1587 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1589 header_view = modest_main_window_get_child_widget (main_window,
1590 MODEST_WIDGET_TYPE_HEADER_VIEW);
1594 conf = modest_runtime_get_conf ();
1596 /* what is saved/restored is depending on the style; thus; we save with
1597 * old style, then update the style, and restore for this new style
1599 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1601 if (modest_header_view_get_style
1602 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1603 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1604 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1606 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1607 MODEST_HEADER_VIEW_STYLE_DETAILS);
1609 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1610 MODEST_CONF_HEADER_VIEW_KEY);
1615 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1617 ModestMainWindow *main_window)
1619 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1620 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1622 /* in the case the folder is empty, show the empty folder message and focus
1624 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
1625 if (modest_header_view_is_empty (header_view)) {
1626 TnyFolder *folder = modest_header_view_get_folder (header_view);
1627 GtkWidget *folder_view =
1628 modest_main_window_get_child_widget (main_window,
1629 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1631 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
1632 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
1636 /* If no header has been selected then exit */
1641 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1642 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1644 /* Update Main window title */
1645 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1646 const gchar *subject = tny_header_get_subject (header);
1647 if (subject && strlen(subject) > 0)
1648 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1650 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1653 /* Update toolbar dimming state */
1654 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1658 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1660 ModestMainWindow *main_window)
1664 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1669 headers = tny_simple_list_new ();
1670 tny_list_prepend (headers, G_OBJECT (header));
1672 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1674 g_object_unref (headers);
1678 set_active_account_from_tny_account (TnyAccount *account,
1679 ModestWindow *window)
1681 const gchar *server_acc_name = tny_account_get_id (account);
1683 /* We need the TnyAccount provided by the
1684 account store because that is the one that
1685 knows the name of the Modest account */
1686 TnyAccount *modest_server_account = modest_server_account =
1687 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1688 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1691 const gchar *modest_acc_name =
1692 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1693 modest_window_set_active_account (window, modest_acc_name);
1694 g_object_unref (modest_server_account);
1699 folder_refreshed_cb (ModestMailOperation *mail_op,
1703 ModestMainWindow *win = NULL;
1704 GtkWidget *header_view;
1705 TnyFolder *current_folder;
1707 g_return_if_fail (TNY_IS_FOLDER (folder));
1709 win = MODEST_MAIN_WINDOW (user_data);
1711 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1714 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
1715 if (current_folder != NULL && folder != current_folder) {
1720 /* Check if folder is empty and set headers view contents style */
1721 if (tny_folder_get_all_count (folder) == 0) {
1722 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1723 modest_main_window_set_contents_style (win,
1724 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1726 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1731 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1732 TnyFolderStore *folder_store,
1734 ModestMainWindow *main_window)
1737 GtkWidget *header_view;
1739 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1741 header_view = modest_main_window_get_child_widget(main_window,
1742 MODEST_WIDGET_TYPE_HEADER_VIEW);
1746 conf = modest_runtime_get_conf ();
1748 if (TNY_IS_ACCOUNT (folder_store)) {
1750 /* Update active account */
1751 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1752 /* Show account details */
1753 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1756 if (TNY_IS_FOLDER (folder_store) && selected) {
1758 /* Update the active account */
1759 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1761 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1762 g_object_unref (account);
1766 /* Set the header style by default, it could
1767 be changed later by the refresh callback to
1769 modest_main_window_set_contents_style (main_window,
1770 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1772 /* Set folder on header view. This function
1773 will call tny_folder_refresh_async so we
1774 pass a callback that will be called when
1775 finished. We use that callback to set the
1776 empty view if there are no messages */
1777 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1778 TNY_FOLDER (folder_store),
1779 folder_refreshed_cb,
1782 /* Restore configuration. We need to do this
1783 *after* the set_folder because the widget
1784 memory asks the header view about its
1786 modest_widget_memory_restore (modest_runtime_get_conf (),
1787 G_OBJECT(header_view),
1788 MODEST_CONF_HEADER_VIEW_KEY);
1790 /* Update the active account */
1791 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1792 /* Save only if we're seeing headers */
1793 if (modest_main_window_get_contents_style (main_window) ==
1794 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1795 modest_widget_memory_save (conf, G_OBJECT (header_view),
1796 MODEST_CONF_HEADER_VIEW_KEY);
1797 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1801 /* Update toolbar dimming state */
1802 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1806 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1813 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1815 online = tny_device_is_online (modest_runtime_get_device());
1818 /* already online -- the item is simply not there... */
1819 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1821 GTK_MESSAGE_WARNING,
1823 _("The %s you selected cannot be found"),
1825 gtk_dialog_run (GTK_DIALOG(dialog));
1827 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1831 GTK_RESPONSE_REJECT,
1833 GTK_RESPONSE_ACCEPT,
1835 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1836 "Do you want to get online?"), item);
1837 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1838 gtk_label_new (txt), FALSE, FALSE, 0);
1839 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1842 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1843 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1844 /* TODO: Comment about why is this commented out: */
1845 /* modest_platform_connect_and_wait (); */
1848 gtk_widget_destroy (dialog);
1852 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1855 /* g_message ("%s %s", __FUNCTION__, link); */
1860 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1863 modest_platform_activate_uri (link);
1867 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1870 modest_platform_show_uri_popup (link);
1874 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1877 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1881 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1882 const gchar *address,
1885 /* g_message ("%s %s", __FUNCTION__, address); */
1889 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1891 TnyTransportAccount *transport_account;
1892 ModestMailOperation *mail_operation;
1894 gchar *account_name, *from;
1895 ModestAccountMgr *account_mgr;
1896 gchar *info_text = NULL;
1898 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1900 data = modest_msg_edit_window_get_msg_data (edit_window);
1902 account_mgr = modest_runtime_get_account_mgr();
1903 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1905 account_name = modest_account_mgr_get_default_account (account_mgr);
1906 if (!account_name) {
1907 g_printerr ("modest: no account found\n");
1908 modest_msg_edit_window_free_msg_data (edit_window, data);
1912 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1913 account_name = g_strdup (data->account_name);
1917 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1918 (modest_runtime_get_account_store(),
1920 TNY_ACCOUNT_TYPE_TRANSPORT));
1921 if (!transport_account) {
1922 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1923 g_free (account_name);
1924 modest_msg_edit_window_free_msg_data (edit_window, data);
1927 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1929 /* Create the mail operation */
1930 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1931 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1933 modest_mail_operation_save_to_drafts (mail_operation,
1945 data->priority_flags);
1948 g_free (account_name);
1949 g_object_unref (G_OBJECT (transport_account));
1950 g_object_unref (G_OBJECT (mail_operation));
1952 modest_msg_edit_window_free_msg_data (edit_window, data);
1954 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1955 modest_platform_information_banner (NULL, NULL, info_text);
1959 /* For instance, when clicking the Send toolbar button when editing a message: */
1961 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1963 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1965 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
1968 /* Offer the connection dialog, if necessary: */
1969 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window), NULL))
1972 /* FIXME: Code added just for testing. The final version will
1973 use the send queue provided by tinymail and some
1975 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1976 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1978 account_name = modest_account_mgr_get_default_account (account_mgr);
1980 if (!account_name) {
1981 /* Run account setup wizard */
1982 run_account_setup_wizard(MODEST_WINDOW(edit_window));
1986 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1988 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1989 account_name = g_strdup (data->account_name);
1992 /* Get the currently-active transport account for this modest account: */
1993 TnyTransportAccount *transport_account =
1994 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1995 (modest_runtime_get_account_store(),
1997 if (!transport_account) {
1998 /* Run account setup wizard */
1999 run_account_setup_wizard(MODEST_WINDOW(edit_window));
2003 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
2005 /* mail content checks and dialogs */
2006 if (data->subject == NULL || data->subject[0] == '\0') {
2007 GtkResponseType response;
2008 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
2009 _("mcen_nc_subject_is_empty_send"));
2010 if (response == GTK_RESPONSE_CANCEL) {
2011 g_free (account_name);
2016 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
2017 GtkResponseType response;
2018 gchar *note_message;
2019 gchar *note_subject = data->subject;
2020 if (note_subject == NULL || note_subject[0] == '\0')
2021 note_subject = _("mail_va_no_subject");
2022 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
2023 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
2025 g_free (note_message);
2026 if (response == GTK_RESPONSE_CANCEL) {
2027 g_free (account_name);
2032 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
2034 /* Create the mail operation */
2035 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
2036 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2038 modest_mail_operation_send_new_mail (mail_operation,
2049 data->priority_flags);
2053 g_free (account_name);
2054 g_object_unref (G_OBJECT (transport_account));
2055 g_object_unref (G_OBJECT (mail_operation));
2057 modest_msg_edit_window_free_msg_data (edit_window, data);
2058 modest_msg_edit_window_set_sent (edit_window, TRUE);
2060 /* Save settings and close the window: */
2061 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2065 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2066 ModestMsgEditWindow *window)
2068 ModestMsgEditFormatState *format_state = NULL;
2070 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2071 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2073 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2076 format_state = modest_msg_edit_window_get_format_state (window);
2077 g_return_if_fail (format_state != NULL);
2079 format_state->bold = gtk_toggle_action_get_active (action);
2080 modest_msg_edit_window_set_format_state (window, format_state);
2081 g_free (format_state);
2086 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2087 ModestMsgEditWindow *window)
2089 ModestMsgEditFormatState *format_state = NULL;
2091 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2092 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2094 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2097 format_state = modest_msg_edit_window_get_format_state (window);
2098 g_return_if_fail (format_state != NULL);
2100 format_state->italics = gtk_toggle_action_get_active (action);
2101 modest_msg_edit_window_set_format_state (window, format_state);
2102 g_free (format_state);
2107 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2108 ModestMsgEditWindow *window)
2110 ModestMsgEditFormatState *format_state = NULL;
2112 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2113 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2115 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2118 format_state = modest_msg_edit_window_get_format_state (window);
2119 g_return_if_fail (format_state != NULL);
2121 format_state->bullet = gtk_toggle_action_get_active (action);
2122 modest_msg_edit_window_set_format_state (window, format_state);
2123 g_free (format_state);
2128 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2129 GtkRadioAction *selected,
2130 ModestMsgEditWindow *window)
2132 ModestMsgEditFormatState *format_state = NULL;
2133 GtkJustification value;
2135 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2137 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2140 value = gtk_radio_action_get_current_value (selected);
2142 format_state = modest_msg_edit_window_get_format_state (window);
2143 g_return_if_fail (format_state != NULL);
2145 format_state->justification = value;
2146 modest_msg_edit_window_set_format_state (window, format_state);
2147 g_free (format_state);
2151 modest_ui_actions_on_select_editor_color (GtkAction *action,
2152 ModestMsgEditWindow *window)
2154 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2155 g_return_if_fail (GTK_IS_ACTION (action));
2157 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2160 modest_msg_edit_window_select_color (window);
2164 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2165 ModestMsgEditWindow *window)
2167 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2168 g_return_if_fail (GTK_IS_ACTION (action));
2170 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2173 modest_msg_edit_window_select_background_color (window);
2177 modest_ui_actions_on_insert_image (GtkAction *action,
2178 ModestMsgEditWindow *window)
2180 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2181 g_return_if_fail (GTK_IS_ACTION (action));
2183 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2186 modest_msg_edit_window_insert_image (window);
2190 modest_ui_actions_on_attach_file (GtkAction *action,
2191 ModestMsgEditWindow *window)
2193 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2194 g_return_if_fail (GTK_IS_ACTION (action));
2196 modest_msg_edit_window_offer_attach_file (window);
2200 modest_ui_actions_on_remove_attachments (GtkAction *action,
2201 ModestMsgEditWindow *window)
2203 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2204 g_return_if_fail (GTK_IS_ACTION (action));
2206 modest_msg_edit_window_remove_attachments (window, NULL);
2210 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2213 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2214 const GError *error = modest_mail_operation_get_error (mail_op);
2218 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2219 modest_mail_operation_get_error (mail_op)->message);
2224 modest_ui_actions_create_folder(GtkWidget *parent_window,
2225 GtkWidget *folder_view)
2227 TnyFolderStore *parent_folder;
2229 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2231 if (parent_folder) {
2232 gboolean finished = FALSE;
2234 gchar *folder_name = NULL, *suggested_name = NULL;
2236 /* Run the new folder dialog */
2238 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2243 g_free (suggested_name);
2244 suggested_name = NULL;
2246 if (result == GTK_RESPONSE_REJECT) {
2249 ModestMailOperation *mail_op;
2250 TnyFolder *new_folder = NULL;
2252 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2253 G_OBJECT(parent_window),
2254 modest_ui_actions_new_folder_error_handler,
2257 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2259 new_folder = modest_mail_operation_create_folder (mail_op,
2261 (const gchar *) folder_name);
2263 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2266 g_object_unref (new_folder);
2269 g_object_unref (mail_op);
2272 suggested_name = folder_name;
2276 g_object_unref (parent_folder);
2281 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2283 GtkWidget *folder_view;
2285 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2287 folder_view = modest_main_window_get_child_widget (main_window,
2288 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2292 modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2296 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2299 GObject *win = modest_mail_operation_get_source (mail_op);
2300 const GError *error = NULL;
2301 const gchar *message = NULL;
2303 /* Get error message */
2304 error = modest_mail_operation_get_error (mail_op);
2305 if (error != NULL && error->message != NULL) {
2306 message = error->message;
2308 message = _("!!! FIXME: Unable to rename");
2311 /* Show notification dialog */
2312 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
2313 g_object_unref (win);
2317 modest_ui_actions_on_rename_folder (GtkAction *action,
2318 ModestMainWindow *main_window)
2320 TnyFolderStore *folder;
2321 GtkWidget *folder_view;
2322 GtkWidget *header_view;
2324 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2326 folder_view = modest_main_window_get_child_widget (main_window,
2327 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2331 header_view = modest_main_window_get_child_widget (main_window,
2332 MODEST_WIDGET_TYPE_HEADER_VIEW);
2337 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2341 /* Offer the connection dialog if necessary: */
2342 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2343 g_object_unref (G_OBJECT (folder));
2348 if (TNY_IS_FOLDER (folder)) {
2351 const gchar *current_name;
2353 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2354 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2355 current_name, &folder_name);
2357 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2358 ModestMailOperation *mail_op;
2361 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2362 G_OBJECT(main_window),
2363 modest_ui_actions_rename_folder_error_handler,
2367 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2370 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2372 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2373 TNY_FOLDER(folder), TRUE);
2376 modest_header_view_clear ((ModestHeaderView *) header_view);
2378 modest_mail_operation_rename_folder (mail_op,
2379 TNY_FOLDER (folder),
2380 (const gchar *) folder_name);
2382 g_object_unref (mail_op);
2383 g_free (folder_name);
2386 g_object_unref (folder);
2390 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2393 GObject *win = modest_mail_operation_get_source (mail_op);
2395 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2396 _("mail_in_ui_folder_delete_error"));
2397 g_object_unref (win);
2401 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2403 TnyFolderStore *folder;
2404 GtkWidget *folder_view;
2408 g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2410 folder_view = modest_main_window_get_child_widget (main_window,
2411 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2415 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2417 /* Show an error if it's an account */
2418 if (!TNY_IS_FOLDER (folder)) {
2419 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2420 _("mail_in_ui_folder_delete_error"));
2421 g_object_unref (G_OBJECT (folder));
2425 /* Offer the connection dialog if necessary: */
2426 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2427 g_object_unref (G_OBJECT (folder));
2432 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2433 tny_folder_get_name (TNY_FOLDER (folder)));
2434 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2435 (const gchar *) message);
2438 if (response == GTK_RESPONSE_OK) {
2439 ModestMailOperation *mail_op =
2440 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2441 G_OBJECT(main_window),
2442 modest_ui_actions_delete_folder_error_handler,
2445 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2447 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2448 g_object_unref (G_OBJECT (mail_op));
2451 g_object_unref (G_OBJECT (folder));
2455 modest_ui_actions_on_delete_folder (GtkAction *action,
2456 ModestMainWindow *main_window)
2458 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2460 delete_folder (main_window, FALSE);
2464 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2466 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2468 delete_folder (main_window, TRUE);
2473 show_error (GtkWidget *parent_widget, const gchar* text)
2475 hildon_banner_show_information(parent_widget, NULL, text);
2478 GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); */
2480 GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
2487 gtk_dialog_run (dialog);
2488 gtk_widget_destroy (GTK_WIDGET (dialog));
2493 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2494 const gchar* server_account_name,
2499 ModestMainWindow *main_window)
2501 g_return_if_fail(server_account_name);
2502 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2504 /* Initalize output parameters: */
2511 #ifdef MODEST_PLATFORM_MAEMO
2512 /* Maemo uses a different (awkward) button order,
2513 * It should probably just use gtk_alternative_dialog_button_order ().
2515 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2519 GTK_RESPONSE_ACCEPT,
2521 GTK_RESPONSE_REJECT,
2524 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2528 GTK_RESPONSE_REJECT,
2530 GTK_RESPONSE_ACCEPT,
2532 #endif /* MODEST_PLATFORM_MAEMO */
2534 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2536 gchar *server_name = modest_server_account_get_hostname (
2537 modest_runtime_get_account_mgr(), server_account_name);
2538 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2539 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2544 /* This causes a warning because the logical ID has no %s in it,
2545 * though the translation does, but there is not much we can do about that: */
2546 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2547 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2550 g_free (server_name);
2554 gchar *initial_username = modest_server_account_get_username (
2555 modest_runtime_get_account_mgr(), server_account_name);
2557 GtkWidget *entry_username = gtk_entry_new ();
2558 if (initial_username)
2559 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2560 /* Dim this if a connection has ever succeeded with this username,
2561 * as per the UI spec: */
2562 const gboolean username_known =
2563 modest_server_account_get_username_has_succeeded(
2564 modest_runtime_get_account_mgr(), server_account_name);
2565 gtk_widget_set_sensitive (entry_username, !username_known);
2567 #ifdef MODEST_PLATFORM_MAEMO
2568 /* Auto-capitalization is the default, so let's turn it off: */
2569 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2571 /* Create a size group to be used by all captions.
2572 * Note that HildonCaption does not create a default size group if we do not specify one.
2573 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2574 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2576 GtkWidget *caption = hildon_caption_new (sizegroup,
2577 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2578 gtk_widget_show (entry_username);
2579 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2580 FALSE, FALSE, MODEST_MARGIN_HALF);
2581 gtk_widget_show (caption);
2583 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2585 #endif /* MODEST_PLATFORM_MAEMO */
2588 GtkWidget *entry_password = gtk_entry_new ();
2589 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2590 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2592 #ifdef MODEST_PLATFORM_MAEMO
2593 /* Auto-capitalization is the default, so let's turn it off: */
2594 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2595 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2597 caption = hildon_caption_new (sizegroup,
2598 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2599 gtk_widget_show (entry_password);
2600 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2601 FALSE, FALSE, MODEST_MARGIN_HALF);
2602 gtk_widget_show (caption);
2603 g_object_unref (sizegroup);
2605 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2607 #endif /* MODEST_PLATFORM_MAEMO */
2609 /* This is not in the Maemo UI spec:
2610 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2611 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2615 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2617 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2619 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2621 modest_server_account_set_username (
2622 modest_runtime_get_account_mgr(), server_account_name,
2625 const gboolean username_was_changed =
2626 (strcmp (*username, initial_username) != 0);
2627 if (username_was_changed) {
2628 g_warning ("%s: tinymail does not yet support changing the "
2629 "username in the get_password() callback.\n", __FUNCTION__);
2634 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2636 /* We do not save the password in the configuration,
2637 * because this function is only called for passwords that should
2638 * not be remembered:
2639 modest_server_account_set_password (
2640 modest_runtime_get_account_mgr(), server_account_name,
2649 show_error(GTK_WIDGET (main_window), _("mail_ib_login_cancelled"));
2661 /* This is not in the Maemo UI spec:
2662 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2668 gtk_widget_destroy (dialog);
2670 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2674 modest_ui_actions_on_cut (GtkAction *action,
2675 ModestWindow *window)
2677 GtkWidget *focused_widget;
2678 GtkClipboard *clipboard;
2680 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2681 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2682 if (GTK_IS_EDITABLE (focused_widget)) {
2683 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2684 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2685 gtk_clipboard_store (clipboard);
2686 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2687 GtkTextBuffer *buffer;
2689 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2690 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2691 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2692 gtk_clipboard_store (clipboard);
2693 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2694 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2695 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2696 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2701 modest_ui_actions_on_copy (GtkAction *action,
2702 ModestWindow *window)
2704 GtkClipboard *clipboard;
2705 GtkWidget *focused_widget;
2707 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2708 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2710 if (GTK_IS_LABEL (focused_widget)) {
2711 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2712 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2713 gtk_clipboard_store (clipboard);
2714 } else if (GTK_IS_EDITABLE (focused_widget)) {
2715 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2716 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2717 gtk_clipboard_store (clipboard);
2718 } else if (GTK_IS_HTML (focused_widget)) {
2719 gtk_html_copy (GTK_HTML (focused_widget));
2720 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2721 gtk_clipboard_store (clipboard);
2722 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2723 GtkTextBuffer *buffer;
2724 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2725 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2726 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2727 gtk_clipboard_store (clipboard);
2728 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2729 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2730 TnyIterator *iter = tny_list_create_iterator (header_list);
2731 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2733 gboolean ask = FALSE;
2735 TnyFolder *folder = tny_header_get_folder (header);
2736 TnyAccount *account = tny_folder_get_account (folder);
2737 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2738 /* If it's POP then ask */
2739 ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2740 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2741 g_object_unref (account);
2742 g_object_unref (folder);
2743 g_object_unref (header);
2746 g_object_unref (iter);
2748 /* Check that the messages have been previously downloaded */
2749 gboolean continue_download = TRUE;
2751 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window), FALSE);
2752 if (continue_download)
2753 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2754 g_object_unref (header_list);
2755 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2756 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2759 /* Show information banner */
2760 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2765 modest_ui_actions_on_undo (GtkAction *action,
2766 ModestWindow *window)
2768 ModestEmailClipboard *clipboard = NULL;
2770 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2771 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2772 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2773 /* Clear clipboard source */
2774 clipboard = modest_runtime_get_email_clipboard ();
2775 modest_email_clipboard_clear (clipboard);
2778 g_return_if_reached ();
2783 modest_ui_actions_on_redo (GtkAction *action,
2784 ModestWindow *window)
2786 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2787 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2790 g_return_if_reached ();
2796 paste_msgs_cb (const GObject *object, gpointer user_data)
2798 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2799 g_return_if_fail (GTK_IS_WIDGET (user_data));
2801 /* destroy information note */
2802 gtk_widget_destroy (GTK_WIDGET(user_data));
2806 paste_as_attachment_free (gpointer data)
2808 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
2810 gtk_widget_destroy (helper->banner);
2811 g_object_unref (helper->banner);
2816 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
2821 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
2822 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
2827 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
2832 modest_ui_actions_on_paste (GtkAction *action,
2833 ModestWindow *window)
2835 GtkWidget *focused_widget = NULL;
2836 GtkWidget *inf_note = NULL;
2837 ModestMailOperation *mail_op = NULL;
2839 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2840 if (GTK_IS_EDITABLE (focused_widget)) {
2841 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2842 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2843 ModestEmailClipboard *e_clipboard = NULL;
2844 e_clipboard = modest_runtime_get_email_clipboard ();
2845 if (modest_email_clipboard_cleared (e_clipboard)) {
2846 GtkTextBuffer *buffer;
2847 GtkClipboard *clipboard;
2849 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2850 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2851 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2852 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2853 ModestMailOperation *mail_op;
2854 TnyFolder *src_folder;
2857 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
2858 helper->window = MODEST_MSG_EDIT_WINDOW (window);
2859 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2860 _CS("ckct_nw_pasting"));
2861 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
2862 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2864 if (helper->banner != NULL) {
2865 g_object_ref (G_OBJECT (helper->banner));
2866 gtk_window_set_modal (GTK_WINDOW (helper->banner), FALSE);
2867 gtk_widget_show (GTK_WIDGET (helper->banner));
2871 modest_mail_operation_get_msgs_full (mail_op,
2873 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
2875 paste_as_attachment_free);
2878 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2879 ModestEmailClipboard *clipboard = NULL;
2880 TnyFolder *src_folder = NULL;
2881 TnyFolderStore *folder_store = NULL;
2882 TnyList *data = NULL;
2883 gboolean delete = FALSE;
2885 /* Check clipboard source */
2886 clipboard = modest_runtime_get_email_clipboard ();
2887 if (modest_email_clipboard_cleared (clipboard))
2890 /* Get elements to paste */
2891 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2893 /* Create a new mail operation */
2894 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2895 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2898 /* Get destination folder */
2899 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2901 /* Launch notification */
2902 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2903 _CS("ckct_nw_pasting"));
2904 if (inf_note != NULL) {
2905 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
2906 gtk_widget_show (GTK_WIDGET(inf_note));
2909 /* transfer messages */
2911 modest_mail_operation_xfer_msgs (mail_op,
2913 TNY_FOLDER (folder_store),
2918 } else if (src_folder != NULL) {
2919 modest_mail_operation_xfer_folder (mail_op,
2929 g_object_unref (data);
2930 if (src_folder != NULL)
2931 g_object_unref (src_folder);
2932 if (folder_store != NULL)
2933 g_object_unref (folder_store);
2939 modest_ui_actions_on_select_all (GtkAction *action,
2940 ModestWindow *window)
2942 GtkWidget *focused_widget;
2944 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2945 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2946 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2947 } else if (GTK_IS_LABEL (focused_widget)) {
2948 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2949 } else if (GTK_IS_EDITABLE (focused_widget)) {
2950 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2951 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2952 GtkTextBuffer *buffer;
2953 GtkTextIter start, end;
2955 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2956 gtk_text_buffer_get_start_iter (buffer, &start);
2957 gtk_text_buffer_get_end_iter (buffer, &end);
2958 gtk_text_buffer_select_range (buffer, &start, &end);
2959 } else if (GTK_IS_HTML (focused_widget)) {
2960 gtk_html_select_all (GTK_HTML (focused_widget));
2961 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2962 GtkWidget *header_view = focused_widget;
2963 GtkTreeSelection *selection = NULL;
2965 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2966 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2967 MODEST_WIDGET_TYPE_HEADER_VIEW);
2969 /* Select all messages */
2970 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2971 gtk_tree_selection_select_all (selection);
2973 /* Set focuse on header view */
2974 gtk_widget_grab_focus (header_view);
2980 modest_ui_actions_on_mark_as_read (GtkAction *action,
2981 ModestWindow *window)
2983 g_return_if_fail (MODEST_IS_WINDOW(window));
2985 /* Mark each header as read */
2986 do_headers_action (window, headers_action_mark_as_read, NULL);
2990 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2991 ModestWindow *window)
2993 g_return_if_fail (MODEST_IS_WINDOW(window));
2995 /* Mark each header as read */
2996 do_headers_action (window, headers_action_mark_as_unread, NULL);
3000 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
3001 GtkRadioAction *selected,
3002 ModestWindow *window)
3006 value = gtk_radio_action_get_current_value (selected);
3007 if (MODEST_IS_WINDOW (window)) {
3008 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
3012 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
3013 GtkRadioAction *selected,
3014 ModestWindow *window)
3016 TnyHeaderFlags flags;
3017 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3019 flags = gtk_radio_action_get_current_value (selected);
3020 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
3023 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
3024 GtkRadioAction *selected,
3025 ModestWindow *window)
3029 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3031 file_format = gtk_radio_action_get_current_value (selected);
3032 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
3037 modest_ui_actions_on_zoom_plus (GtkAction *action,
3038 ModestWindow *window)
3040 g_return_if_fail (MODEST_IS_WINDOW (window));
3042 modest_window_zoom_plus (MODEST_WINDOW (window));
3046 modest_ui_actions_on_zoom_minus (GtkAction *action,
3047 ModestWindow *window)
3049 g_return_if_fail (MODEST_IS_WINDOW (window));
3051 modest_window_zoom_minus (MODEST_WINDOW (window));
3055 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
3056 ModestWindow *window)
3058 ModestWindowMgr *mgr;
3059 gboolean fullscreen, active;
3060 g_return_if_fail (MODEST_IS_WINDOW (window));
3062 mgr = modest_runtime_get_window_mgr ();
3064 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
3065 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3067 if (active != fullscreen) {
3068 modest_window_mgr_set_fullscreen_mode (mgr, active);
3069 gtk_window_present (GTK_WINDOW (window));
3074 modest_ui_actions_on_change_fullscreen (GtkAction *action,
3075 ModestWindow *window)
3077 ModestWindowMgr *mgr;
3078 gboolean fullscreen;
3080 g_return_if_fail (MODEST_IS_WINDOW (window));
3082 mgr = modest_runtime_get_window_mgr ();
3083 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3084 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
3086 gtk_window_present (GTK_WINDOW (window));
3090 * Used by modest_ui_actions_on_details to call do_headers_action
3093 headers_action_show_details (TnyHeader *header,
3094 ModestWindow *window,
3101 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
3104 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3105 gtk_widget_show_all (dialog);
3106 gtk_dialog_run (GTK_DIALOG (dialog));
3108 gtk_widget_destroy (dialog);
3112 * Show the folder details in a ModestDetailsDialog widget
3115 show_folder_details (TnyFolder *folder,
3121 dialog = modest_details_dialog_new_with_folder (window, folder);
3124 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3125 gtk_widget_show_all (dialog);
3126 gtk_dialog_run (GTK_DIALOG (dialog));
3128 gtk_widget_destroy (dialog);
3132 * Show the header details in a ModestDetailsDialog widget
3135 modest_ui_actions_on_details (GtkAction *action,
3138 TnyList * headers_list;
3142 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3145 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3148 g_object_unref (msg);
3150 headers_list = get_selected_headers (win);
3154 iter = tny_list_create_iterator (headers_list);
3156 header = TNY_HEADER (tny_iterator_get_current (iter));
3158 headers_action_show_details (header, win, NULL);
3159 g_object_unref (header);
3162 g_object_unref (iter);
3163 g_object_unref (headers_list);
3165 } else if (MODEST_IS_MAIN_WINDOW (win)) {
3166 GtkWidget *folder_view, *header_view;
3168 /* Check which widget has the focus */
3169 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3170 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3171 if (gtk_widget_is_focus (folder_view)) {
3172 TnyFolderStore *folder_store
3173 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3174 if (!folder_store) {
3175 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3178 /* Show only when it's a folder */
3179 /* This function should not be called for account items,
3180 * because we dim the menu item for them. */
3181 if (TNY_IS_FOLDER (folder_store)) {
3182 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3185 g_object_unref (folder_store);
3188 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3189 MODEST_WIDGET_TYPE_HEADER_VIEW);
3190 /* Show details of each header */
3191 do_headers_action (win, headers_action_show_details, header_view);
3197 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3198 ModestMsgEditWindow *window)
3200 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3202 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3206 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3207 ModestMsgEditWindow *window)
3209 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3211 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3215 modest_ui_actions_toggle_folders_view (GtkAction *action,
3216 ModestMainWindow *main_window)
3218 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3220 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3221 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3223 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3227 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3228 ModestWindow *window)
3230 gboolean active, fullscreen = FALSE;
3231 ModestWindowMgr *mgr;
3233 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3235 /* Check if we want to toggle the toolbar vuew in fullscreen
3237 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3238 "ViewShowToolbarFullScreen")) {
3242 /* Toggle toolbar */
3243 mgr = modest_runtime_get_window_mgr ();
3244 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3248 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3249 ModestMsgEditWindow *window)
3251 modest_msg_edit_window_select_font (window);
3255 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3256 const gchar *display_name,
3259 /* Do not change the application name if the widget has not
3260 the focus. This callback could be called even if the folder
3261 view has not the focus, because the handled signal could be
3262 emitted when the folder view is redrawn */
3263 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3265 gtk_window_set_title (window, display_name);
3267 gtk_window_set_title (window, " ");
3272 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3274 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3275 modest_msg_edit_window_select_contacts (window);
3279 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3281 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3282 modest_msg_edit_window_check_names (window, FALSE);
3286 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3288 modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3289 GTK_WIDGET (user_data));
3293 create_move_to_dialog (GtkWindow *win,
3294 GtkWidget *folder_view,
3295 GtkWidget **tree_view)
3297 GtkWidget *dialog, *scroll;
3298 GtkWidget *new_button;
3300 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3302 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3305 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
3306 /* We do this manually so GTK+ does not associate a response ID for
3308 new_button = gtk_button_new_from_stock (GTK_STOCK_NEW);
3309 gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3310 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
3312 /* Create scrolled window */
3313 scroll = gtk_scrolled_window_new (NULL, NULL);
3314 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3315 GTK_POLICY_AUTOMATIC,
3316 GTK_POLICY_AUTOMATIC);
3318 /* Create folder view */
3319 *tree_view = modest_platform_create_folder_view (NULL);
3321 g_signal_connect (G_OBJECT (new_button), "clicked", G_CALLBACK(create_move_to_dialog_on_new_folder), *tree_view);
3323 /* It could happen that we're trying to move a message from a
3324 window (msg window for example) after the main window was
3325 closed, so we can not just get the model of the folder
3327 if (MODEST_IS_FOLDER_VIEW (folder_view))
3328 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3329 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3331 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3332 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3334 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3336 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3338 /* Add scroll to dialog */
3339 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3340 scroll, TRUE, TRUE, 0);
3342 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3343 gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3349 * Returns TRUE if at least one of the headers of the list belongs to
3350 * a message that has been fully retrieved.
3353 has_retrieved_msgs (TnyList *list)
3356 gboolean found = FALSE;
3358 iter = tny_list_create_iterator (list);
3359 while (tny_iterator_is_done (iter) && !found) {
3361 TnyHeaderFlags flags = 0;
3363 header = TNY_HEADER (tny_iterator_get_current (iter));
3365 flags = tny_header_get_flags (header);
3366 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
3369 g_object_unref (header);
3373 tny_iterator_next (iter);
3375 g_object_unref (iter);
3381 * Shows a confirmation dialog to the user when we're moving messages
3382 * from a remote server to the local storage. Returns the dialog
3383 * response. If it's other kind of movement the it always returns
3387 msgs_move_to_confirmation (GtkWindow *win,
3388 TnyFolder *dest_folder,
3391 gint response = GTK_RESPONSE_OK;
3393 /* If the destination is a local folder */
3394 if (modest_tny_folder_is_local_folder (dest_folder)) {
3395 TnyFolder *src_folder = NULL;
3396 TnyIterator *iter = NULL;
3397 TnyHeader *header = NULL;
3399 /* Get source folder */
3400 iter = tny_list_create_iterator (headers);
3401 header = TNY_HEADER (tny_iterator_get_current (iter));
3403 src_folder = tny_header_get_folder (header);
3404 g_object_unref (header);
3407 g_object_unref (iter);
3409 /* if no src_folder, message may be an attahcment */
3410 if (src_folder == NULL)
3411 return GTK_RESPONSE_CANCEL;
3413 /* If the source is a remote folder */
3414 if (!modest_tny_folder_is_local_folder (src_folder)) {
3415 const gchar *message;
3417 if (has_retrieved_msgs (headers))
3418 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3419 tny_list_get_length (headers));
3421 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3422 tny_list_get_length (headers));
3424 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3425 (const gchar *) message);
3428 g_object_unref (src_folder);
3437 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3439 ModestMsgViewWindow *self = NULL;
3441 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3442 self = MODEST_MSG_VIEW_WINDOW (object);
3444 if (!modest_msg_view_window_select_next_message (self))
3445 if (!modest_msg_view_window_select_previous_message (self))
3446 /* No more messages to view, so close this window */
3447 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3451 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3454 GObject *win = modest_mail_operation_get_source (mail_op);
3455 const GError *error = NULL;
3456 const gchar *message = NULL;
3458 /* Get error message */
3459 error = modest_mail_operation_get_error (mail_op);
3460 if (error != NULL && error->message != NULL) {
3461 message = error->message;
3463 message = _("mail_in_ui_folder_move_target_error");
3466 /* Show notification dialog */
3467 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3468 g_object_unref (win);
3472 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3475 GObject *win = modest_mail_operation_get_source (mail_op);
3476 const GError *error = modest_mail_operation_get_error (mail_op);
3478 g_return_if_fail (error != NULL);
3479 if (error->message != NULL)
3480 g_printerr ("modest: %s\n", error->message);
3482 g_printerr ("modest: unkonw error on send&receive operation");
3484 /* Show error message */
3485 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3486 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3487 /* _CS("sfil_ib_unable_to_receive")); */
3489 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3490 /* _CS("sfil_ib_unable_to_send")); */
3491 g_object_unref (win);
3495 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3502 gint pending_purges = 0;
3503 gboolean some_purged = FALSE;
3504 ModestWindow *win = MODEST_WINDOW (user_data);
3505 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
3507 /* If there was any error */
3508 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
3509 modest_window_mgr_unregister_header (mgr, header);
3513 /* Once the message has been retrieved for purging, we check if
3514 * it's all ok for purging */
3516 parts = tny_simple_list_new ();
3517 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3518 iter = tny_list_create_iterator (parts);
3520 while (!tny_iterator_is_done (iter)) {
3522 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3523 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
3524 if (tny_mime_part_is_purged (part))
3531 g_object_unref (part);
3533 tny_iterator_next (iter);
3536 if (pending_purges>0) {
3538 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3540 if (response == GTK_RESPONSE_OK) {
3541 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3542 tny_iterator_first (iter);
3543 while (!tny_iterator_is_done (iter)) {
3546 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3547 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
3548 tny_mime_part_set_purged (part);
3551 g_object_unref (part);
3553 tny_iterator_next (iter);
3556 tny_msg_rewrite_cache (msg);
3559 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3562 /* remove attachments */
3563 tny_iterator_first (iter);
3564 while (!tny_iterator_is_done (iter)) {
3567 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3569 /* One for the reference given by tny_iterator_get_current(): */
3570 g_object_unref (part);
3572 /* TODO: Is this meant to remove the attachment by doing another unref()?
3573 * Otherwise, this seems useless. */
3576 tny_iterator_next (iter);
3578 modest_window_mgr_unregister_header (mgr, header);
3580 g_object_unref (iter);
3581 g_object_unref (parts);
3585 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3586 ModestMainWindow *win)
3588 GtkWidget *header_view;
3589 TnyList *header_list;
3592 TnyHeaderFlags flags;
3593 ModestWindow *msg_view_window = NULL;
3596 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3598 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3599 MODEST_WIDGET_TYPE_HEADER_VIEW);
3601 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3603 if (tny_list_get_length (header_list) == 1) {
3604 iter = tny_list_create_iterator (header_list);
3605 header = TNY_HEADER (tny_iterator_get_current (iter));
3606 g_object_unref (iter);
3611 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3612 header, &msg_view_window);
3613 flags = tny_header_get_flags (header);
3614 if (!(flags & TNY_HEADER_FLAG_CACHED))
3617 if (msg_view_window != NULL)
3618 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3620 /* do nothing; uid was registered before, so window is probably on it's way */
3621 g_warning ("debug: header %p has already been registered", header);
3624 ModestMailOperation *mail_op = NULL;
3625 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3626 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3628 modest_ui_actions_get_msgs_full_error_handler,
3630 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3631 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3633 g_object_unref (mail_op);
3636 g_object_unref (header);
3638 g_object_unref (header_list);
3642 * Utility function that transfer messages from both the main window
3643 * and the msg view window when using the "Move to" dialog
3646 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
3649 TnyList *headers = NULL;
3652 if (!TNY_IS_FOLDER (dst_folder)) {
3653 modest_platform_information_banner (GTK_WIDGET (win),
3655 _CS("ckdg_ib_unable_to_move_to_current_location"));
3659 /* Get selected headers */
3660 headers = get_selected_headers (MODEST_WINDOW (win));
3662 /* Ask for user confirmation */
3663 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3664 TNY_FOLDER (dst_folder),
3667 /* Transfer messages */
3668 if (response == GTK_RESPONSE_OK) {
3669 ModestMailOperation *mail_op =
3670 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3672 modest_ui_actions_move_folder_error_handler,
3674 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3677 modest_mail_operation_xfer_msgs (mail_op,
3679 TNY_FOLDER (dst_folder),
3681 (MODEST_IS_MSG_VIEW_WINDOW (win)) ? transfer_msgs_from_viewer_cb : NULL,
3684 g_object_unref (G_OBJECT (mail_op));
3686 g_object_unref (headers);
3691 * UI handler for the "Move to" action when invoked from the
3695 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3696 GtkWidget *folder_view,
3697 TnyFolderStore *dst_folder,
3698 ModestMainWindow *win)
3700 GtkWidget *header_view = NULL;
3701 ModestMailOperation *mail_op = NULL;
3702 TnyFolderStore *src_folder;
3704 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3706 /* Get the source folder */
3707 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3709 /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3710 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3714 /* Get header view */
3716 modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW);
3718 /* Get folder or messages to transfer */
3719 if (gtk_widget_is_focus (folder_view)) {
3721 /* Allow only to transfer folders to the local root folder */
3722 if (TNY_IS_ACCOUNT (dst_folder) &&
3723 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder))
3726 /* Clean folder on header view before moving it */
3727 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3729 if (TNY_IS_FOLDER (src_folder)) {
3731 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3733 modest_ui_actions_move_folder_error_handler,
3735 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3738 modest_mail_operation_xfer_folder (mail_op,
3739 TNY_FOLDER (src_folder),
3742 /* Unref mail operation */
3743 g_object_unref (G_OBJECT (mail_op));
3745 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3747 } else if (gtk_widget_is_focus (header_view)) {
3748 /* Transfer messages */
3749 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3754 g_object_unref (src_folder);
3759 * UI handler for the "Move to" action when invoked from the
3760 * ModestMsgViewWindow
3763 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3764 TnyFolderStore *dst_folder,
3765 ModestMsgViewWindow *win)
3767 TnyHeader *header = NULL;
3768 TnyFolder *src_folder;
3770 /* Create header list */
3771 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3772 src_folder = tny_header_get_folder(header);
3773 g_object_unref (header);
3775 /* Transfer the message */
3776 if (modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (src_folder)))
3777 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3779 g_object_unref (src_folder);
3783 modest_ui_actions_on_move_to (GtkAction *action,
3786 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3788 TnyFolderStore *dst_folder = NULL;
3789 ModestMainWindow *main_window;
3791 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3792 MODEST_IS_MSG_VIEW_WINDOW (win));
3794 /* Get the main window if exists */
3795 if (MODEST_IS_MAIN_WINDOW (win))
3796 main_window = MODEST_MAIN_WINDOW (win);
3799 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3801 /* Get the folder view widget if exists */
3803 folder_view = modest_main_window_get_child_widget (main_window,
3804 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3808 /* Create and run the dialog */
3809 dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
3810 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3811 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3812 result = gtk_dialog_run (GTK_DIALOG(dialog));
3813 g_object_ref (tree_view);
3814 gtk_widget_destroy (dialog);
3816 if (result != GTK_RESPONSE_ACCEPT)
3819 dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3820 /* Offer the connection dialog if necessary: */
3821 if (modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3824 /* Do window specific stuff */
3825 if (MODEST_IS_MAIN_WINDOW (win))
3826 modest_ui_actions_on_main_window_move_to (action,
3829 MODEST_MAIN_WINDOW (win));
3831 modest_ui_actions_on_msg_view_window_move_to (action,
3833 MODEST_MSG_VIEW_WINDOW (win));
3836 g_object_unref (dst_folder);
3840 * Calls #HeadersFunc for each header already selected in the main
3841 * window or the message currently being shown in the msg view window
3844 do_headers_action (ModestWindow *win,
3848 TnyList *headers_list = NULL;
3849 TnyIterator *iter = NULL;
3850 TnyHeader *header = NULL;
3851 TnyFolder *folder = NULL;
3854 headers_list = get_selected_headers (win);
3858 /* Get the folder */
3859 iter = tny_list_create_iterator (headers_list);
3860 header = TNY_HEADER (tny_iterator_get_current (iter));
3862 folder = tny_header_get_folder (header);
3863 g_object_unref (header);
3866 /* Call the function for each header */
3867 while (!tny_iterator_is_done (iter)) {
3868 header = TNY_HEADER (tny_iterator_get_current (iter));
3869 func (header, win, user_data);
3870 g_object_unref (header);
3871 tny_iterator_next (iter);
3874 /* Trick: do a poke status in order to speed up the signaling
3876 tny_folder_poke_status (folder);
3879 g_object_unref (folder);
3880 g_object_unref (iter);
3881 g_object_unref (headers_list);
3885 modest_ui_actions_view_attachment (GtkAction *action,
3886 ModestWindow *window)
3888 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3889 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3891 /* not supported window for this action */
3892 g_return_if_reached ();
3897 modest_ui_actions_save_attachments (GtkAction *action,
3898 ModestWindow *window)
3900 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3901 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3903 /* not supported window for this action */
3904 g_return_if_reached ();
3909 modest_ui_actions_remove_attachments (GtkAction *action,
3910 ModestWindow *window)
3912 if (MODEST_IS_MAIN_WINDOW (window)) {
3913 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
3914 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3915 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
3917 /* not supported window for this action */
3918 g_return_if_reached ();
3923 modest_ui_actions_on_settings (GtkAction *action,
3928 dialog = modest_platform_get_global_settings_dialog ();
3929 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3930 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3931 gtk_widget_show_all (dialog);
3933 gtk_dialog_run (GTK_DIALOG (dialog));
3935 gtk_widget_destroy (dialog);
3939 modest_ui_actions_on_help (GtkAction *action,
3942 const gchar *help_id = NULL;
3944 if (MODEST_IS_MAIN_WINDOW (win)) {
3945 const gchar *action_name;
3946 action_name = gtk_action_get_name (action);
3948 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3949 !strcmp (action_name, "HeaderViewCSMHelp")) {
3950 GtkWidget *folder_view;
3951 TnyFolderStore *folder_store;
3952 /* Get selected folder */
3953 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3954 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3955 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3957 /* Switch help_id */
3958 if (TNY_IS_FOLDER (folder_store)) {
3959 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
3960 case TNY_FOLDER_TYPE_NORMAL:
3961 help_id = "applications_email_managefolders";
3963 case TNY_FOLDER_TYPE_INBOX:
3964 help_id = "applications_email_inbox";
3966 case TNY_FOLDER_TYPE_OUTBOX:
3967 help_id = "applications_email_outbox";
3969 case TNY_FOLDER_TYPE_SENT:
3970 help_id = "applications_email_sent";
3972 case TNY_FOLDER_TYPE_DRAFTS:
3973 help_id = "applications_email_drafts";
3975 case TNY_FOLDER_TYPE_ARCHIVE:
3976 help_id = "applications_email_managefolders";
3979 help_id = "applications_email_managefolders";
3982 help_id = "applications_email_mainview";
3984 g_object_unref (folder_store);
3986 help_id = "applications_email_mainview";
3988 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3989 help_id = "applications_email_viewer";
3990 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3991 help_id = "applications_email_editor";
3993 modest_platform_show_help (GTK_WINDOW (win), help_id);
3997 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3998 ModestWindow *window)
4000 ModestMailOperation *mail_op;
4004 headers = get_selected_headers (window);
4008 /* Create mail operation */
4009 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4011 modest_ui_actions_get_msgs_full_error_handler,
4013 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4014 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
4017 g_object_unref (headers);
4018 g_object_unref (mail_op);
4022 modest_ui_actions_on_email_menu_activated (GtkAction *action,
4023 ModestWindow *window)
4025 g_return_if_fail (MODEST_IS_WINDOW (window));
4028 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4032 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
4033 ModestWindow *window)
4035 g_return_if_fail (MODEST_IS_WINDOW (window));
4038 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4042 modest_ui_actions_on_view_menu_activated (GtkAction *action,
4043 ModestWindow *window)
4045 g_return_if_fail (MODEST_IS_WINDOW (window));
4048 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4052 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
4053 ModestWindow *window)
4055 g_return_if_fail (MODEST_IS_WINDOW (window));
4058 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4062 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
4063 ModestWindow *window)
4065 g_return_if_fail (MODEST_IS_WINDOW (window));
4068 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4072 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
4073 ModestWindow *window)
4075 g_return_if_fail (MODEST_IS_WINDOW (window));
4078 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4082 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
4083 ModestWindow *window)
4085 g_return_if_fail (MODEST_IS_WINDOW (window));
4088 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4092 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
4093 ModestWindow *window)
4095 g_return_if_fail (MODEST_IS_WINDOW (window));
4098 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4102 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
4104 g_return_if_fail (MODEST_IS_WINDOW (window));
4107 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
4111 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
4113 g_return_if_fail (MODEST_IS_WINDOW (window));
4115 modest_platform_show_search_messages (GTK_WINDOW (window));
4119 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
4121 g_return_if_fail (MODEST_IS_WINDOW (win));
4122 modest_platform_show_addressbook (GTK_WINDOW (win));
4127 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
4128 ModestWindow *window)
4130 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4132 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
4136 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
4137 ModestMailOperationState *state,
4140 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
4142 /* Set send/receive operation finished */
4143 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
4144 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));