1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #endif /*HAVE_CONFIG_H*/
34 #include <glib/gi18n.h>
35 #include <glib/gprintf.h>
37 #include <modest-runtime.h>
38 #include <modest-tny-folder.h>
39 #include <modest-tny-msg.h>
40 #include <modest-tny-account.h>
41 #include <modest-address-book.h>
42 #include "modest-error.h"
43 #include "modest-ui-actions.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
48 #ifdef MODEST_PLATFORM_MAEMO
49 #include "maemo/modest-osso-state-saving.h"
50 #endif /* MODEST_PLATFORM_MAEMO */
52 #include "widgets/modest-ui-constants.h"
53 #include <widgets/modest-main-window.h>
54 #include <widgets/modest-msg-view-window.h>
55 #include <widgets/modest-account-view-window.h>
56 #include <widgets/modest-details-dialog.h>
57 #include <widgets/modest-attachments-view.h>
58 #include "widgets/modest-folder-view.h"
59 #include "widgets/modest-global-settings-dialog.h"
60 #include "modest-connection-specific-smtp-window.h"
61 #include "modest-account-mgr-helpers.h"
62 #include "modest-mail-operation.h"
63 #include "modest-text-utils.h"
65 #ifdef MODEST_HAVE_EASYSETUP
66 #include "easysetup/modest-easysetup-wizard.h"
67 #endif /* MODEST_HAVE_EASYSETUP */
69 #include <modest-widget-memory.h>
70 #include <tny-error.h>
71 #include <tny-simple-list.h>
72 #include <tny-msg-view.h>
73 #include <tny-device.h>
74 #include <tny-merge-folder.h>
76 #include <gtkhtml/gtkhtml.h>
78 typedef struct _GetMsgAsyncHelper {
80 ModestMailOperation *mail_op;
87 typedef enum _ReplyForwardAction {
93 typedef struct _ReplyForwardHelper {
94 guint reply_forward_type;
95 ReplyForwardAction action;
97 GtkWidget *parent_window;
102 * The do_headers_action uses this kind of functions to perform some
103 * action to each member of a list of headers
105 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
108 do_headers_action (ModestWindow *win,
113 static void open_msg_cb (ModestMailOperation *mail_op,
118 static void reply_forward_cb (ModestMailOperation *mail_op,
123 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
125 static gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
128 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
129 ModestMailOperationState *state,
135 run_account_setup_wizard (ModestWindow *win)
137 ModestEasysetupWizardDialog *wizard;
139 g_return_if_fail (MODEST_IS_WINDOW(win));
141 wizard = modest_easysetup_wizard_dialog_new ();
142 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
143 gtk_dialog_run (GTK_DIALOG (wizard));
144 gtk_widget_destroy (GTK_WIDGET (wizard));
149 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
152 const gchar *authors[] = {
153 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
156 about = gtk_about_dialog_new ();
157 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
158 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
159 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
160 _("Copyright (c) 2006, Nokia Corporation\n"
161 "All rights reserved."));
162 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
163 _("a modest e-mail client\n\n"
164 "design and implementation: Dirk-Jan C. Binnema\n"
165 "contributions from the fine people at KC and Ig\n"
166 "uses the tinymail email framework written by Philip van Hoof"));
167 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
168 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
170 gtk_dialog_run (GTK_DIALOG (about));
171 gtk_widget_destroy(about);
175 * Gets the list of currently selected messages. If the win is the
176 * main window, then it returns a newly allocated list of the headers
177 * selected in the header view. If win is the msg view window, then
178 * the value returned is a list with just a single header.
180 * The caller of this funcion must free the list.
183 get_selected_headers (ModestWindow *win)
185 if (MODEST_IS_MAIN_WINDOW(win)) {
186 GtkWidget *header_view;
188 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
189 MODEST_WIDGET_TYPE_HEADER_VIEW);
190 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
192 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
193 /* for MsgViewWindows, we simply return a list with one element */
195 TnyList *list = NULL;
197 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
198 if (header != NULL) {
199 list = tny_simple_list_new ();
200 tny_list_prepend (list, G_OBJECT(header));
201 g_object_unref (G_OBJECT(header));
211 headers_action_mark_as_read (TnyHeader *header,
215 TnyHeaderFlags flags;
217 g_return_if_fail (TNY_IS_HEADER(header));
219 flags = tny_header_get_flags (header);
220 if (flags & TNY_HEADER_FLAG_SEEN) return;
221 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
225 headers_action_mark_as_unread (TnyHeader *header,
229 TnyHeaderFlags flags;
231 g_return_if_fail (TNY_IS_HEADER(header));
233 flags = tny_header_get_flags (header);
234 if (flags & TNY_HEADER_FLAG_SEEN) {
235 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
241 headers_action_delete (TnyHeader *header,
245 ModestMailOperation *mail_op = NULL;
247 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
248 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
251 /* Always delete. TODO: Move to trash still not supported */
252 modest_mail_operation_remove_msg (mail_op, header, FALSE);
253 g_object_unref (G_OBJECT (mail_op));
257 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
259 TnyList *header_list = NULL;
260 TnyIterator *iter = NULL;
261 TnyHeader *header = NULL;
262 gchar *message = NULL;
266 ModestWindowMgr *mgr;
267 GtkWidget *header_view;
269 g_return_if_fail (MODEST_IS_WINDOW(win));
271 /* Check first if the header view has the focus */
272 if (MODEST_IS_MAIN_WINDOW (win)) {
273 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
274 MODEST_WIDGET_TYPE_HEADER_VIEW);
275 if (!gtk_widget_is_focus (header_view))
279 header_list = get_selected_headers (win);
280 if (!header_list) return;
282 /* Check if any of the headers is already opened */
283 iter = tny_list_create_iterator (header_list);
285 mgr = modest_runtime_get_window_mgr ();
286 while (!tny_iterator_is_done (iter) && !found) {
287 header = TNY_HEADER (tny_iterator_get_current (iter));
288 if (modest_window_mgr_find_window_by_header (mgr, header))
290 g_object_unref (header);
291 tny_iterator_next (iter);
293 g_object_unref (iter);
298 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
299 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
301 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
305 g_object_unref (header_list);
310 if (tny_list_get_length(header_list) == 1) {
311 iter = tny_list_create_iterator (header_list);
312 header = TNY_HEADER (tny_iterator_get_current (iter));
313 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
314 g_object_unref (header);
315 g_object_unref (iter);
317 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
318 tny_list_get_length(header_list)), desc);
320 /* Confirmation dialog */
321 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
325 if (response == GTK_RESPONSE_OK) {
326 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
328 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
332 /* Remove each header */
333 do_headers_action (win, headers_action_delete, NULL);
335 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
336 gtk_widget_destroy (GTK_WIDGET(win));
343 g_object_unref (header_list);
348 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
350 #ifdef MODEST_PLATFORM_MAEMO
351 modest_osso_save_state();
352 #endif /* MODEST_PLATFORM_MAEMO */
358 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
360 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
361 gtk_widget_destroy (GTK_WIDGET (win));
362 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
364 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
365 } else if (MODEST_IS_WINDOW (win)) {
366 gtk_widget_destroy (GTK_WIDGET (win));
368 g_return_if_reached ();
373 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
375 GtkClipboard *clipboard = NULL;
376 gchar *selection = NULL;
378 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
379 selection = gtk_clipboard_wait_for_text (clipboard);
381 /* Question: why is the clipboard being used here?
382 * It doesn't really make a lot of sense. */
386 modest_address_book_add_address (selection);
392 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
394 /* This is currently only implemented for Maemo */
395 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
396 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
397 run_account_setup_wizard (win);
400 /* Show the list of accounts: */
401 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
402 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
403 gtk_dialog_run (account_win);
404 gtk_widget_destroy (GTK_WIDGET(account_win));
407 GtkWidget *dialog, *label;
409 /* Create the widgets */
411 dialog = gtk_dialog_new_with_buttons ("Message",
413 GTK_DIALOG_DESTROY_WITH_PARENT,
417 label = gtk_label_new ("Hello World!");
419 /* Ensure that the dialog box is destroyed when the user responds. */
421 g_signal_connect_swapped (dialog, "response",
422 G_CALLBACK (gtk_widget_destroy),
425 /* Add the label, and show everything we've added to the dialog. */
427 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
429 gtk_widget_show_all (dialog);
430 #endif /* MODEST_PLATFORM_MAEMO */
434 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
436 ModestWindow *main_window = MODEST_WINDOW (user_data);
438 /* Save any changes. */
439 modest_connection_specific_smtp_window_save_server_accounts (
440 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
441 modest_window_get_active_account (main_window));
442 gtk_widget_destroy (GTK_WIDGET (window));
448 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
450 /* This is currently only implemented for Maemo,
451 * because it requires an API (libconic) to detect different connection
454 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
456 /* Create the window if necessary: */
457 const gchar *active_account_name = modest_window_get_active_account (win);
459 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
460 * or show the default account?
461 * If we show the default account then the account name should be shown in
462 * the window when we show it. */
463 if (!active_account_name) {
464 g_warning ("%s: No account is active.", __FUNCTION__);
468 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
469 modest_connection_specific_smtp_window_fill_with_connections (
470 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
471 modest_runtime_get_account_mgr(),
472 active_account_name);
474 /* Show the window: */
475 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
476 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
477 gtk_widget_show (specific_window);
479 /* Save changes when the window is hidden: */
480 g_signal_connect (specific_window, "hide",
481 G_CALLBACK (on_smtp_servers_window_hide), win);
482 #endif /* MODEST_PLATFORM_MAEMO */
486 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
488 ModestWindow *msg_win;
490 TnyFolder *folder = NULL;
491 gchar *account_name = NULL;
492 gchar *from_str = NULL;
493 /* GError *err = NULL; */
494 TnyAccount *account = NULL;
495 ModestWindowMgr *mgr;
496 gchar *signature = NULL, *blank_and_signature = NULL;
498 /* if there are no accounts yet, just show the wizard */
499 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
500 run_account_setup_wizard (win);
504 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
506 account_name = g_strdup (modest_window_get_active_account (win));
508 g_printerr ("modest: no account found\n");
512 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
514 TNY_ACCOUNT_TYPE_STORE);
516 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
520 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
522 g_printerr ("modest: failed get from string for '%s'\n", account_name);
526 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
527 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
528 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
529 MODEST_ACCOUNT_SIGNATURE, FALSE);
530 blank_and_signature = g_strconcat ("\n", signature, NULL);
533 blank_and_signature = g_strdup ("");
536 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
538 g_printerr ("modest: failed to create new msg\n");
542 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
544 g_printerr ("modest: failed to find Drafts folder\n");
549 /* Create and register edit window */
550 /* This is destroyed by TOOD. */
551 msg_win = modest_msg_edit_window_new (msg, account_name);
552 mgr = modest_runtime_get_window_mgr ();
553 modest_window_mgr_register_window (mgr, msg_win);
556 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
558 gtk_widget_show_all (GTK_WIDGET (msg_win));
561 g_free (account_name);
563 g_free (blank_and_signature);
565 g_object_unref (G_OBJECT(account));
567 g_object_unref (G_OBJECT(msg));
569 g_object_unref (G_OBJECT(folder));
573 open_msg_cb (ModestMailOperation *mail_op,
578 ModestWindowMgr *mgr = NULL;
579 ModestWindow *parent_win = NULL;
580 ModestWindow *win = NULL;
581 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
582 gchar *account = NULL;
585 /* TODO: Show an error? (review the specs) */
589 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
590 folder = tny_header_get_folder (header);
592 /* Mark header as read */
593 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
596 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
598 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
600 /* Gets folder type (OUTBOX headers will be opened in edit window */
601 if (modest_tny_folder_is_local_folder (folder))
602 folder_type = modest_tny_folder_get_local_folder_type (folder);
604 /* If the header is in the drafts folder then open the editor,
605 else the message view window */
606 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
607 /* we cannot edit without a valid account... */
608 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
609 run_account_setup_wizard(parent_win);
612 win = modest_msg_edit_window_new (msg, account);
614 gchar *uid = modest_tny_folder_get_header_unique_id (header);
616 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
617 GtkWidget *header_view;
618 GtkTreeSelection *sel;
619 GList *sel_list = NULL;
622 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
623 MODEST_WIDGET_TYPE_HEADER_VIEW);
625 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
626 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
628 if (sel_list != NULL) {
629 GtkTreeRowReference *row_reference;
631 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
632 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
633 g_list_free (sel_list);
635 win = modest_msg_view_window_new_with_header_model (msg,
640 gtk_tree_row_reference_free (row_reference);
642 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
645 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
650 /* Register and show new window */
652 mgr = modest_runtime_get_window_mgr ();
653 modest_window_mgr_register_window (mgr, win);
654 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
655 gtk_widget_show_all (GTK_WIDGET(win));
661 g_object_unref (parent_win);
662 g_object_unref (msg);
663 g_object_unref (folder);
664 g_object_unref (header);
668 * This function is the error handler of the
669 * modest_mail_operation_get_msgs_full operation
672 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
677 error = modest_mail_operation_get_error (mail_op);
678 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
679 GObject *win = modest_mail_operation_get_source (mail_op);
681 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
683 g_object_unref (win);
688 * This function is used by both modest_ui_actions_on_open and
689 * modest_ui_actions_on_header_activated. This way we always do the
690 * same when trying to open messages.
693 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
695 ModestWindowMgr *mgr;
697 ModestMailOperation *mail_op;
698 TnyList *not_opened_headers;
700 /* Look if we already have a message view for each header. If
701 true, then remove the header from the list of headers to
703 mgr = modest_runtime_get_window_mgr ();
704 iter = tny_list_create_iterator (headers);
705 not_opened_headers = tny_simple_list_new ();
706 while (!tny_iterator_is_done (iter)) {
707 ModestWindow *window;
710 header = TNY_HEADER (tny_iterator_get_current (iter));
711 window = modest_window_mgr_find_window_by_header (mgr, header);
712 /* Do not open again the message and present the
713 window to the user */
715 gtk_window_present (GTK_WINDOW (window));
717 tny_list_append (not_opened_headers, G_OBJECT (header));
719 g_object_unref (header);
720 tny_iterator_next (iter);
723 /* Open each message */
724 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
726 modest_ui_actions_get_msgs_full_error_handler,
728 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
729 if (tny_list_get_length (not_opened_headers) > 1) {
730 modest_mail_operation_get_msgs_full (mail_op,
736 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
737 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
738 modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
739 g_object_unref (header);
740 g_object_unref (iter);
744 g_object_unref (not_opened_headers);
745 g_object_unref (iter);
746 g_object_unref (mail_op);
750 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
755 headers = get_selected_headers (win);
760 _modest_ui_actions_open (headers, win);
762 g_object_unref(headers);
767 free_reply_forward_helper (gpointer data)
769 ReplyForwardHelper *helper;
771 helper = (ReplyForwardHelper *) data;
772 g_free (helper->account_name);
773 g_slice_free (ReplyForwardHelper, helper);
777 reply_forward_cb (ModestMailOperation *mail_op,
783 ReplyForwardHelper *rf_helper;
784 ModestWindow *msg_win;
785 ModestEditType edit_type;
787 TnyAccount *account = NULL;
788 ModestWindowMgr *mgr;
789 gchar *signature = NULL;
791 g_return_if_fail (user_data != NULL);
792 rf_helper = (ReplyForwardHelper *) user_data;
794 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
795 rf_helper->account_name);
796 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
797 rf_helper->account_name,
798 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
799 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
800 rf_helper->account_name,
801 MODEST_ACCOUNT_SIGNATURE, FALSE);
804 /* Create reply mail */
805 switch (rf_helper->action) {
808 modest_tny_msg_create_reply_msg (msg, from, signature,
809 rf_helper->reply_forward_type,
810 MODEST_TNY_MSG_REPLY_MODE_SENDER);
812 case ACTION_REPLY_TO_ALL:
814 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
815 MODEST_TNY_MSG_REPLY_MODE_ALL);
816 edit_type = MODEST_EDIT_TYPE_REPLY;
820 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
821 edit_type = MODEST_EDIT_TYPE_FORWARD;
824 g_return_if_reached ();
831 g_printerr ("modest: failed to create message\n");
835 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
836 rf_helper->account_name,
837 TNY_ACCOUNT_TYPE_STORE);
839 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
843 /* Create and register the windows */
844 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
845 mgr = modest_runtime_get_window_mgr ();
846 modest_window_mgr_register_window (mgr, msg_win);
848 if (rf_helper->parent_window != NULL) {
851 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
852 modest_window_set_zoom (msg_win, parent_zoom);
855 /* Show edit window */
856 gtk_widget_show_all (GTK_WIDGET (msg_win));
860 g_object_unref (G_OBJECT (new_msg));
862 g_object_unref (G_OBJECT (account));
863 g_object_unref (msg);
864 g_object_unref (header);
868 * Checks a list of headers. If any of them are not currently
869 * downloaded (CACHED) then it asks the user for permission to
872 * Returns FALSE if the user does not want to download the
873 * messages. Returns TRUE if the user allowed the download or if all
874 * of them are currently downloaded
877 download_uncached_messages (TnyList *header_list, GtkWindow *win)
880 gboolean found, retval;
882 iter = tny_list_create_iterator (header_list);
884 while (!tny_iterator_is_done (iter) && !found) {
886 TnyHeaderFlags flags;
888 header = TNY_HEADER (tny_iterator_get_current (iter));
889 flags = tny_header_get_flags (header);
890 /* TODO: is this the right flag?, it seems that some
891 headers that have been previously downloaded do not
893 found = !(flags & TNY_HEADER_FLAG_CACHED);
894 g_object_unref (header);
895 tny_iterator_next (iter);
897 g_object_unref (iter);
899 /* Ask for user permission to download the messages */
902 GtkResponseType response;
904 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
905 _("mcen_nc_get_multi_msg_txt"));
906 if (response == GTK_RESPONSE_CANCEL)
914 * Common code for the reply and forward actions
917 reply_forward (ReplyForwardAction action, ModestWindow *win)
919 ModestMailOperation *mail_op = NULL;
920 TnyList *header_list = NULL;
921 ReplyForwardHelper *rf_helper = NULL;
922 guint reply_forward_type;
923 gboolean continue_download;
925 g_return_if_fail (MODEST_IS_WINDOW(win));
927 /* we need an account when editing */
928 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
929 run_account_setup_wizard (win);
933 header_list = get_selected_headers (win);
937 /* Check that the messages have been previously downloaded */
938 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
939 if (!continue_download) {
940 g_object_unref (header_list);
945 modest_conf_get_int (modest_runtime_get_conf (),
946 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
948 /* We assume that we can only select messages of the
949 same folder and that we reply all of them from the
950 same account. In fact the interface currently only
951 allows single selection */
954 rf_helper = g_slice_new0 (ReplyForwardHelper);
955 rf_helper->reply_forward_type = reply_forward_type;
956 rf_helper->action = action;
957 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
958 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
959 rf_helper->parent_window = GTK_WIDGET (win);
960 if (!rf_helper->account_name)
961 rf_helper->account_name =
962 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
964 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
967 /* Get header and message. Do not free them here, the
968 reply_forward_cb must do it */
969 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
970 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
971 if (!msg || !header) {
973 g_object_unref (msg);
975 g_object_unref (header);
976 g_printerr ("modest: no message found\n");
979 reply_forward_cb (NULL, header, msg, rf_helper);
981 /* Retrieve messages */
982 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
984 modest_ui_actions_get_msgs_full_error_handler,
986 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
987 modest_mail_operation_get_msgs_full (mail_op,
991 free_reply_forward_helper);
994 g_object_unref(mail_op);
998 g_object_unref (header_list);
1002 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1004 g_return_if_fail (MODEST_IS_WINDOW(win));
1006 reply_forward (ACTION_REPLY, win);
1010 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1012 g_return_if_fail (MODEST_IS_WINDOW(win));
1014 reply_forward (ACTION_FORWARD, win);
1018 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1020 g_return_if_fail (MODEST_IS_WINDOW(win));
1022 reply_forward (ACTION_REPLY_TO_ALL, win);
1026 modest_ui_actions_on_next (GtkAction *action,
1027 ModestWindow *window)
1029 if (MODEST_IS_MAIN_WINDOW (window)) {
1030 GtkWidget *header_view;
1032 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1033 MODEST_WIDGET_TYPE_HEADER_VIEW);
1037 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1038 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1039 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1041 g_return_if_reached ();
1046 modest_ui_actions_on_prev (GtkAction *action,
1047 ModestWindow *window)
1049 g_return_if_fail (MODEST_IS_WINDOW(window));
1051 if (MODEST_IS_MAIN_WINDOW (window)) {
1052 GtkWidget *header_view;
1053 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1054 MODEST_WIDGET_TYPE_HEADER_VIEW);
1058 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1059 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1060 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1062 g_return_if_reached ();
1067 modest_ui_actions_on_sort (GtkAction *action,
1068 ModestWindow *window)
1070 g_return_if_fail (MODEST_IS_WINDOW(window));
1072 if (MODEST_IS_MAIN_WINDOW (window)) {
1073 GtkWidget *header_view;
1074 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1075 MODEST_WIDGET_TYPE_HEADER_VIEW);
1079 /* Show sorting dialog */
1080 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1085 * This function performs the send & receive required actions. The
1086 * window is used to create the mail operation. Typically it should
1087 * always be the main window, but we pass it as argument in order to
1091 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1093 gchar *acc_name = NULL;
1094 ModestMailOperation *mail_op;
1096 /* If no account name was provided then get the current account, and if
1097 there is no current account then pick the default one: */
1098 if (!account_name) {
1099 acc_name = g_strdup (modest_window_get_active_account(win));
1101 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1103 g_printerr ("modest: cannot get default account\n");
1107 acc_name = g_strdup (account_name);
1110 /* Set send/receive operation in progress */
1111 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1113 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
1114 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1115 G_CALLBACK (_on_send_receive_progress_changed),
1118 /* Send & receive. */
1119 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1120 /* Receive and then send. The operation is tagged initially as
1121 a receive operation because the account update performs a
1122 receive and then a send. The operation changes its type
1123 internally, so the progress objects will receive the proper
1124 progress information */
1125 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1126 modest_mail_operation_update_account (mail_op, acc_name);
1127 g_object_unref (G_OBJECT (mail_op));
1134 * Refreshes all accounts. This function will be used by automatic
1138 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1140 GSList *account_names, *iter;
1142 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1145 iter = account_names;
1147 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1148 iter = g_slist_next (iter);
1151 modest_account_mgr_free_account_names (account_names);
1152 account_names = NULL;
1156 * Handler of the click on Send&Receive button in the main toolbar
1159 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1161 /* Check if accounts exist */
1162 gboolean accounts_exist =
1163 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1165 /* If not, allow the user to create an account before trying to send/receive. */
1166 if (!accounts_exist)
1167 modest_ui_actions_on_accounts (NULL, win);
1169 /* Refresh the active account */
1170 modest_ui_actions_do_send_receive (NULL, win);
1175 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1178 GtkWidget *header_view;
1180 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1182 header_view = modest_main_window_get_child_widget (main_window,
1183 MODEST_WIDGET_TYPE_HEADER_VIEW);
1187 conf = modest_runtime_get_conf ();
1189 /* what is saved/restored is depending on the style; thus; we save with
1190 * old style, then update the style, and restore for this new style
1192 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1194 if (modest_header_view_get_style
1195 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1196 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1197 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1199 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1200 MODEST_HEADER_VIEW_STYLE_DETAILS);
1202 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1203 MODEST_CONF_HEADER_VIEW_KEY);
1208 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1210 ModestMainWindow *main_window)
1212 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1213 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1215 /* If no header has been selected then exit */
1219 /* Update Main window title */
1220 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1221 const gchar *subject = tny_header_get_subject (header);
1222 if (subject && strlen(subject) > 0)
1223 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1225 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1228 /* Update toolbar dimming state */
1229 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1233 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1235 ModestMainWindow *main_window)
1239 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1244 headers = tny_simple_list_new ();
1245 tny_list_prepend (headers, G_OBJECT (header));
1247 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1249 g_object_unref (headers);
1253 set_active_account_from_tny_account (TnyAccount *account,
1254 ModestWindow *window)
1256 const gchar *server_acc_name = tny_account_get_id (account);
1258 /* We need the TnyAccount provided by the
1259 account store because that is the one that
1260 knows the name of the Modest account */
1261 TnyAccount *modest_server_account = modest_server_account =
1262 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1263 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1266 const gchar *modest_acc_name =
1267 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1268 modest_window_set_active_account (window, modest_acc_name);
1269 g_object_unref (modest_server_account);
1274 folder_refreshed_cb (const GObject *obj,
1278 /* printf ("DEBUG: %s\n", __FUNCTION__); */
1279 ModestMainWindow *win = NULL;
1280 GtkWidget *header_view;
1282 g_return_if_fail (TNY_IS_FOLDER (folder));
1284 win = MODEST_MAIN_WINDOW (user_data);
1286 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1288 /* Check if folder is empty and set headers view contents style */
1289 if (tny_folder_get_all_count (folder) == 0) {
1290 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1291 modest_main_window_set_contents_style (win,
1292 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1294 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1299 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1300 TnyFolderStore *folder_store,
1302 ModestMainWindow *main_window)
1305 GtkWidget *header_view;
1307 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1309 header_view = modest_main_window_get_child_widget(main_window,
1310 MODEST_WIDGET_TYPE_HEADER_VIEW);
1314 conf = modest_runtime_get_conf ();
1316 if (TNY_IS_ACCOUNT (folder_store)) {
1318 /* Update active account */
1319 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1320 /* Show account details */
1321 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1324 if (TNY_IS_FOLDER (folder_store) && selected) {
1326 /* Update the active account */
1327 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1329 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1330 g_object_unref (account);
1334 /* Set the header style by default, it could
1335 be changed later by the refresh callback to
1337 modest_main_window_set_contents_style (main_window,
1338 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1340 /* Set folder on header view. This function
1341 will call tny_folder_refresh_async so we
1342 pass a callback that will be called when
1343 finished. We use that callback to set the
1344 empty view if there are no messages */
1345 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1346 TNY_FOLDER (folder_store),
1347 folder_refreshed_cb,
1350 /* Restore configuration. We need to do this
1351 *after* the set_folder because the widget
1352 memory asks the header view about its
1354 modest_widget_memory_restore (modest_runtime_get_conf (),
1355 G_OBJECT(header_view),
1356 MODEST_CONF_HEADER_VIEW_KEY);
1358 /* Update the active account */
1359 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1360 /* Do not show folder */
1361 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1362 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1366 /* Update toolbar dimming state */
1367 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1371 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1378 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1380 if (g_main_depth > 0)
1381 gdk_threads_enter ();
1382 online = tny_device_is_online (modest_runtime_get_device());
1385 /* already online -- the item is simply not there... */
1386 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1388 GTK_MESSAGE_WARNING,
1390 _("The %s you selected cannot be found"),
1392 gtk_dialog_run (GTK_DIALOG(dialog));
1394 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1398 GTK_RESPONSE_REJECT,
1400 GTK_RESPONSE_ACCEPT,
1402 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1403 "Do you want to get online?"), item);
1404 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1405 gtk_label_new (txt), FALSE, FALSE, 0);
1406 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1409 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1410 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1411 // modest_platform_connect_and_wait ();
1414 gtk_widget_destroy (dialog);
1415 if (g_main_depth > 0)
1416 gdk_threads_leave ();
1420 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1423 /* g_message ("%s %s", __FUNCTION__, link); */
1428 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1431 modest_platform_activate_uri (link);
1435 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1438 modest_platform_show_uri_popup (link);
1442 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1445 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1449 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1450 const gchar *address,
1453 /* g_message ("%s %s", __FUNCTION__, address); */
1457 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1459 TnyTransportAccount *transport_account;
1460 ModestMailOperation *mail_operation;
1462 gchar *account_name, *from;
1463 ModestAccountMgr *account_mgr;
1465 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1467 data = modest_msg_edit_window_get_msg_data (edit_window);
1469 account_mgr = modest_runtime_get_account_mgr();
1470 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1472 account_name = modest_account_mgr_get_default_account (account_mgr);
1473 if (!account_name) {
1474 g_printerr ("modest: no account found\n");
1475 modest_msg_edit_window_free_msg_data (edit_window, data);
1479 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1480 account_name = g_strdup (data->account_name);
1484 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1485 (modest_runtime_get_account_store(),
1487 TNY_ACCOUNT_TYPE_TRANSPORT));
1488 if (!transport_account) {
1489 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1490 g_free (account_name);
1491 modest_msg_edit_window_free_msg_data (edit_window, data);
1494 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1496 /* Create the mail operation */
1497 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1498 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1500 modest_mail_operation_save_to_drafts (mail_operation,
1511 data->priority_flags);
1514 g_free (account_name);
1515 g_object_unref (G_OBJECT (transport_account));
1516 g_object_unref (G_OBJECT (mail_operation));
1518 modest_msg_edit_window_free_msg_data (edit_window, data);
1520 /* Save settings and close the window */
1521 gtk_widget_destroy (GTK_WIDGET (edit_window));
1524 /* For instance, when clicking the Send toolbar button when editing a message: */
1526 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1528 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1530 if (!modest_msg_edit_window_check_names (edit_window))
1533 /* FIXME: Code added just for testing. The final version will
1534 use the send queue provided by tinymail and some
1536 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1537 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1539 account_name = modest_account_mgr_get_default_account (account_mgr);
1541 if (!account_name) {
1542 g_printerr ("modest: no account found\n");
1546 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1548 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1549 account_name = g_strdup (data->account_name);
1552 /* Get the currently-active transport account for this modest account: */
1553 TnyTransportAccount *transport_account =
1554 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1555 (modest_runtime_get_account_store(),
1557 if (!transport_account) {
1558 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1559 g_free (account_name);
1560 modest_msg_edit_window_free_msg_data (edit_window, data);
1564 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1566 /* mail content checks and dialogs */
1567 if (data->subject == NULL || data->subject[0] == '\0') {
1568 GtkResponseType response;
1569 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1570 _("mcen_nc_subject_is_empty_send"));
1571 if (response == GTK_RESPONSE_CANCEL) {
1572 g_free (account_name);
1577 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1578 GtkResponseType response;
1579 gchar *note_message;
1580 gchar *note_subject = data->subject;
1581 if (note_subject == NULL || note_subject[0] == '\0')
1582 note_subject = _("mail_va_no_subject");
1583 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1584 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1586 g_free (note_message);
1587 if (response == GTK_RESPONSE_CANCEL) {
1588 g_free (account_name);
1593 /* Create the mail operation */
1594 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1595 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1597 modest_mail_operation_send_new_mail (mail_operation,
1608 data->priority_flags);
1612 g_free (account_name);
1613 g_object_unref (G_OBJECT (transport_account));
1614 g_object_unref (G_OBJECT (mail_operation));
1616 modest_msg_edit_window_free_msg_data (edit_window, data);
1618 /* Save settings and close the window: */
1619 gtk_widget_destroy (GTK_WIDGET (edit_window));
1623 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1624 ModestMsgEditWindow *window)
1626 ModestMsgEditFormatState *format_state = NULL;
1628 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1629 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1631 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1634 format_state = modest_msg_edit_window_get_format_state (window);
1635 g_return_if_fail (format_state != NULL);
1637 format_state->bold = gtk_toggle_action_get_active (action);
1638 modest_msg_edit_window_set_format_state (window, format_state);
1639 g_free (format_state);
1644 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1645 ModestMsgEditWindow *window)
1647 ModestMsgEditFormatState *format_state = NULL;
1649 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1650 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1652 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1655 format_state = modest_msg_edit_window_get_format_state (window);
1656 g_return_if_fail (format_state != NULL);
1658 format_state->italics = gtk_toggle_action_get_active (action);
1659 modest_msg_edit_window_set_format_state (window, format_state);
1660 g_free (format_state);
1665 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1666 ModestMsgEditWindow *window)
1668 ModestMsgEditFormatState *format_state = NULL;
1670 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1671 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1673 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1676 format_state = modest_msg_edit_window_get_format_state (window);
1677 g_return_if_fail (format_state != NULL);
1679 format_state->bullet = gtk_toggle_action_get_active (action);
1680 modest_msg_edit_window_set_format_state (window, format_state);
1681 g_free (format_state);
1686 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1687 GtkRadioAction *selected,
1688 ModestMsgEditWindow *window)
1690 ModestMsgEditFormatState *format_state = NULL;
1691 GtkJustification value;
1693 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1695 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1698 value = gtk_radio_action_get_current_value (selected);
1700 format_state = modest_msg_edit_window_get_format_state (window);
1701 g_return_if_fail (format_state != NULL);
1703 format_state->justification = value;
1704 modest_msg_edit_window_set_format_state (window, format_state);
1705 g_free (format_state);
1709 modest_ui_actions_on_select_editor_color (GtkAction *action,
1710 ModestMsgEditWindow *window)
1712 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1713 g_return_if_fail (GTK_IS_ACTION (action));
1715 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1718 modest_msg_edit_window_select_color (window);
1722 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1723 ModestMsgEditWindow *window)
1725 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1726 g_return_if_fail (GTK_IS_ACTION (action));
1728 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1731 modest_msg_edit_window_select_background_color (window);
1735 modest_ui_actions_on_insert_image (GtkAction *action,
1736 ModestMsgEditWindow *window)
1738 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1739 g_return_if_fail (GTK_IS_ACTION (action));
1741 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1744 modest_msg_edit_window_insert_image (window);
1748 modest_ui_actions_on_attach_file (GtkAction *action,
1749 ModestMsgEditWindow *window)
1751 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1752 g_return_if_fail (GTK_IS_ACTION (action));
1754 modest_msg_edit_window_attach_file (window);
1758 modest_ui_actions_on_remove_attachments (GtkAction *action,
1759 ModestMsgEditWindow *window)
1761 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1762 g_return_if_fail (GTK_IS_ACTION (action));
1764 modest_msg_edit_window_remove_attachments (window, NULL);
1768 * Shows a dialog with an entry that asks for some text. The returned
1769 * value must be freed by the caller. The dialog window title will be
1773 ask_for_folder_name (GtkWindow *parent_window,
1776 GtkWidget *dialog, *entry;
1777 gchar *folder_name = NULL;
1779 /* Ask for folder name */
1780 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1784 GTK_RESPONSE_REJECT,
1786 GTK_RESPONSE_ACCEPT,
1788 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1789 gtk_label_new(title),
1792 entry = gtk_entry_new_with_max_length (40);
1793 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1797 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1799 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1800 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1802 gtk_widget_destroy (dialog);
1808 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1810 TnyFolderStore *parent_folder;
1811 GtkWidget *folder_view;
1813 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1815 folder_view = modest_main_window_get_child_widget (main_window,
1816 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1820 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1822 if (parent_folder) {
1823 gboolean finished = FALSE;
1825 gchar *folder_name = NULL, *suggested_name = NULL;
1827 /* Run the new folder dialog */
1829 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1834 if (result == GTK_RESPONSE_REJECT) {
1837 ModestMailOperation *mail_op;
1838 TnyFolder *new_folder = NULL;
1840 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO,
1841 G_OBJECT(main_window));
1842 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1844 new_folder = modest_mail_operation_create_folder (mail_op,
1846 (const gchar *) folder_name);
1848 g_object_unref (new_folder);
1851 g_object_unref (mail_op);
1853 g_free (folder_name);
1857 g_object_unref (parent_folder);
1862 modest_ui_actions_on_rename_folder (GtkAction *action,
1863 ModestMainWindow *main_window)
1865 TnyFolderStore *folder;
1866 GtkWidget *folder_view;
1867 GtkWidget *header_view;
1869 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1871 folder_view = modest_main_window_get_child_widget (main_window,
1872 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1876 header_view = modest_main_window_get_child_widget (main_window,
1877 MODEST_WIDGET_TYPE_HEADER_VIEW);
1882 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1884 if (folder && TNY_IS_FOLDER (folder)) {
1886 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1887 _("Please enter a new name for the folder"));
1889 if (folder_name != NULL && strlen (folder_name) > 0) {
1890 ModestMailOperation *mail_op;
1892 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1893 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1896 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
1898 modest_mail_operation_rename_folder (mail_op,
1899 TNY_FOLDER (folder),
1900 (const gchar *) folder_name);
1902 g_object_unref (mail_op);
1903 g_free (folder_name);
1905 g_object_unref (folder);
1910 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
1913 GObject *win = modest_mail_operation_get_source (mail_op);
1915 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1916 _("mail_in_ui_folder_delete_error"));
1917 g_object_unref (win);
1921 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1923 TnyFolderStore *folder;
1924 GtkWidget *folder_view;
1928 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1930 folder_view = modest_main_window_get_child_widget (main_window,
1931 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1935 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1937 /* Show an error if it's an account */
1938 if (!TNY_IS_FOLDER (folder)) {
1939 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1940 _("mail_in_ui_folder_delete_error"));
1945 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1946 tny_folder_get_name (TNY_FOLDER (folder)));
1947 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1948 (const gchar *) message);
1951 if (response == GTK_RESPONSE_OK) {
1952 ModestMailOperation *mail_op =
1953 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
1954 G_OBJECT(main_window),
1955 modest_ui_actions_delete_folder_error_handler,
1958 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1960 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1961 g_object_unref (G_OBJECT (mail_op));
1964 g_object_unref (G_OBJECT (folder));
1968 modest_ui_actions_on_delete_folder (GtkAction *action,
1969 ModestMainWindow *main_window)
1971 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1973 delete_folder (main_window, FALSE);
1977 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1979 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1981 delete_folder (main_window, TRUE);
1985 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1986 const gchar* server_account_name,
1991 ModestMainWindow *main_window)
1993 g_return_if_fail(server_account_name);
1994 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1996 /* Initalize output parameters: */
2003 #ifdef MODEST_PLATFORM_MAEMO
2004 /* Maemo uses a different (awkward) button order,
2005 * It should probably just use gtk_alternative_dialog_button_order ().
2007 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2011 GTK_RESPONSE_ACCEPT,
2013 GTK_RESPONSE_REJECT,
2016 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2020 GTK_RESPONSE_REJECT,
2022 GTK_RESPONSE_ACCEPT,
2024 #endif /* MODEST_PLATFORM_MAEMO */
2026 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2028 gchar *server_name = modest_server_account_get_hostname (
2029 modest_runtime_get_account_mgr(), server_account_name);
2030 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2031 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2036 /* This causes a warning because the logical ID has no %s in it,
2037 * though the translation does, but there is not much we can do about that: */
2038 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2039 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2042 g_free (server_name);
2046 gchar *initial_username = modest_server_account_get_username (
2047 modest_runtime_get_account_mgr(), server_account_name);
2049 GtkWidget *entry_username = gtk_entry_new ();
2050 if (initial_username)
2051 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2052 /* Dim this if a connection has ever succeeded with this username,
2053 * as per the UI spec: */
2054 const gboolean username_known =
2055 modest_server_account_get_username_has_succeeded(
2056 modest_runtime_get_account_mgr(), server_account_name);
2057 gtk_widget_set_sensitive (entry_username, !username_known);
2059 #ifdef MODEST_PLATFORM_MAEMO
2060 /* Auto-capitalization is the default, so let's turn it off: */
2061 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2063 /* Create a size group to be used by all captions.
2064 * Note that HildonCaption does not create a default size group if we do not specify one.
2065 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2066 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2068 GtkWidget *caption = hildon_caption_new (sizegroup,
2069 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2070 gtk_widget_show (entry_username);
2071 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2072 FALSE, FALSE, MODEST_MARGIN_HALF);
2073 gtk_widget_show (caption);
2075 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2077 #endif /* MODEST_PLATFORM_MAEMO */
2080 GtkWidget *entry_password = gtk_entry_new ();
2081 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2082 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2084 #ifdef MODEST_PLATFORM_MAEMO
2085 /* Auto-capitalization is the default, so let's turn it off: */
2086 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2087 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2089 caption = hildon_caption_new (sizegroup,
2090 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2091 gtk_widget_show (entry_password);
2092 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2093 FALSE, FALSE, MODEST_MARGIN_HALF);
2094 gtk_widget_show (caption);
2095 g_object_unref (sizegroup);
2097 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2099 #endif /* MODEST_PLATFORM_MAEMO */
2101 /* This is not in the Maemo UI spec:
2102 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2103 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2107 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2109 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2111 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2113 modest_server_account_set_username (
2114 modest_runtime_get_account_mgr(), server_account_name,
2117 const gboolean username_was_changed =
2118 (strcmp (*username, initial_username) != 0);
2119 if (username_was_changed) {
2120 /* To actually use a changed username,
2121 * we must reset the connection, according to pvanhoof.
2122 * This _might_ be a sensible way to do that: */
2123 TnyDevice *device = modest_runtime_get_device();
2124 tny_device_force_offline (device);
2125 tny_device_force_online (device);
2130 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2132 /* We do not save the password in the configuration,
2133 * because this function is only called for passwords that should
2134 * not be remembered:
2135 modest_server_account_set_password (
2136 modest_runtime_get_account_mgr(), server_account_name,
2155 /* This is not in the Maemo UI spec:
2156 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2162 gtk_widget_destroy (dialog);
2164 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2168 modest_ui_actions_on_cut (GtkAction *action,
2169 ModestWindow *window)
2171 GtkWidget *focused_widget;
2173 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2174 if (GTK_IS_EDITABLE (focused_widget)) {
2175 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2176 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2177 GtkTextBuffer *buffer;
2178 GtkClipboard *clipboard;
2180 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2181 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2182 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2183 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2184 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2185 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2186 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2191 modest_ui_actions_on_copy (GtkAction *action,
2192 ModestWindow *window)
2194 GtkClipboard *clipboard;
2195 GtkWidget *focused_widget;
2197 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2198 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2200 if (GTK_IS_LABEL (focused_widget)) {
2201 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2202 } else if (GTK_IS_EDITABLE (focused_widget)) {
2203 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2204 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2205 GtkTextBuffer *buffer;
2206 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2207 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2208 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2209 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2210 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2211 TnyIterator *iter = tny_list_create_iterator (header_list);
2212 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2213 TnyFolder *folder = tny_header_get_folder (header);
2214 TnyAccount *account = tny_folder_get_account (folder);
2215 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2216 /* If it's POP then ask */
2217 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2218 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2219 g_object_unref (account);
2220 g_object_unref (folder);
2221 g_object_unref (header);
2222 g_object_unref (iter);
2224 /* Check that the messages have been previously downloaded */
2225 gboolean continue_download = TRUE;
2227 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window));
2228 if (continue_download)
2229 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2230 g_object_unref (header_list);
2231 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2232 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2237 modest_ui_actions_on_undo (GtkAction *action,
2238 ModestWindow *window)
2240 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2241 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2243 g_return_if_reached ();
2248 modest_ui_actions_on_paste (GtkAction *action,
2249 ModestWindow *window)
2251 GtkWidget *focused_widget;
2252 ModestMailOperation *mail_op = NULL;
2254 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2255 if (GTK_IS_EDITABLE (focused_widget)) {
2256 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2257 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2258 GtkTextBuffer *buffer;
2259 GtkClipboard *clipboard;
2261 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2262 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2263 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2264 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2265 ModestEmailClipboard *clipboard = NULL;
2266 TnyFolder *src_folder = NULL;
2267 TnyFolderStore *folder_store = NULL;
2268 TnyList *data = NULL;
2269 gboolean delete = FALSE;
2271 /* Check clipboard source */
2272 clipboard = modest_runtime_get_email_clipboard ();
2273 if (modest_email_clipboard_cleared (clipboard))
2276 /* Get elements to paste */
2277 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2279 /* Create a new mail operation */
2280 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2281 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2284 /* Get destination folder */
2285 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2287 /* transfer messages */
2289 modest_mail_operation_xfer_msgs (mail_op,
2291 TNY_FOLDER (folder_store),
2296 } else if (src_folder != NULL) {
2297 modest_mail_operation_xfer_folder (mail_op,
2305 g_object_unref (data);
2306 if (src_folder != NULL)
2307 g_object_unref (src_folder);
2308 if (folder_store != NULL)
2309 g_object_unref (folder_store);
2314 modest_ui_actions_on_select_all (GtkAction *action,
2315 ModestWindow *window)
2317 GtkWidget *focused_widget;
2319 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2320 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2321 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2322 } else if (GTK_IS_LABEL (focused_widget)) {
2323 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2324 } else if (GTK_IS_EDITABLE (focused_widget)) {
2325 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2326 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2327 GtkTextBuffer *buffer;
2328 GtkTextIter start, end;
2330 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2331 gtk_text_buffer_get_start_iter (buffer, &start);
2332 gtk_text_buffer_get_end_iter (buffer, &end);
2333 gtk_text_buffer_select_range (buffer, &start, &end);
2335 else if ((MODEST_IS_FOLDER_VIEW (focused_widget)) ||
2336 (MODEST_IS_HEADER_VIEW (focused_widget))) {
2338 GtkTreeSelection *selection = NULL;
2340 /* Get header view */
2341 GtkWidget *header_view = focused_widget;
2342 if (MODEST_IS_FOLDER_VIEW (focused_widget))
2343 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2344 MODEST_WIDGET_TYPE_HEADER_VIEW);
2346 /* Select all messages */
2347 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2348 gtk_tree_selection_select_all (selection);
2350 /* Set focuse on header view */
2351 gtk_widget_grab_focus (header_view);
2353 } else if (GTK_IS_HTML (focused_widget)) {
2354 gtk_html_select_all (GTK_HTML (focused_widget));
2359 modest_ui_actions_on_mark_as_read (GtkAction *action,
2360 ModestWindow *window)
2362 g_return_if_fail (MODEST_IS_WINDOW(window));
2364 /* Mark each header as read */
2365 do_headers_action (window, headers_action_mark_as_read, NULL);
2369 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2370 ModestWindow *window)
2372 g_return_if_fail (MODEST_IS_WINDOW(window));
2374 /* Mark each header as read */
2375 do_headers_action (window, headers_action_mark_as_unread, NULL);
2379 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2380 GtkRadioAction *selected,
2381 ModestWindow *window)
2385 value = gtk_radio_action_get_current_value (selected);
2386 if (MODEST_IS_WINDOW (window)) {
2387 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2391 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2392 GtkRadioAction *selected,
2393 ModestWindow *window)
2395 TnyHeaderFlags flags;
2396 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2398 flags = gtk_radio_action_get_current_value (selected);
2399 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2402 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2403 GtkRadioAction *selected,
2404 ModestWindow *window)
2408 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2410 file_format = gtk_radio_action_get_current_value (selected);
2411 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2416 modest_ui_actions_on_zoom_plus (GtkAction *action,
2417 ModestWindow *window)
2419 g_return_if_fail (MODEST_IS_WINDOW (window));
2421 modest_window_zoom_plus (MODEST_WINDOW (window));
2425 modest_ui_actions_on_zoom_minus (GtkAction *action,
2426 ModestWindow *window)
2428 g_return_if_fail (MODEST_IS_WINDOW (window));
2430 modest_window_zoom_minus (MODEST_WINDOW (window));
2434 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2435 ModestWindow *window)
2437 ModestWindowMgr *mgr;
2438 gboolean fullscreen, active;
2439 g_return_if_fail (MODEST_IS_WINDOW (window));
2441 mgr = modest_runtime_get_window_mgr ();
2443 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2444 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2446 if (active != fullscreen) {
2447 modest_window_mgr_set_fullscreen_mode (mgr, active);
2448 gtk_window_present (GTK_WINDOW (window));
2453 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2454 ModestWindow *window)
2456 ModestWindowMgr *mgr;
2457 gboolean fullscreen;
2459 g_return_if_fail (MODEST_IS_WINDOW (window));
2461 mgr = modest_runtime_get_window_mgr ();
2462 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2463 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2465 gtk_window_present (GTK_WINDOW (window));
2469 * Used by modest_ui_actions_on_details to call do_headers_action
2472 headers_action_show_details (TnyHeader *header,
2473 ModestWindow *window,
2480 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2483 gtk_widget_show_all (dialog);
2484 gtk_dialog_run (GTK_DIALOG (dialog));
2486 gtk_widget_destroy (dialog);
2490 * Show the folder details in a ModestDetailsDialog widget
2493 show_folder_details (TnyFolder *folder,
2499 dialog = modest_details_dialog_new_with_folder (window, folder);
2502 gtk_widget_show_all (dialog);
2503 gtk_dialog_run (GTK_DIALOG (dialog));
2505 gtk_widget_destroy (dialog);
2509 * Show the header details in a ModestDetailsDialog widget
2512 modest_ui_actions_on_details (GtkAction *action,
2515 TnyList * headers_list;
2519 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2522 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2525 g_object_unref (msg);
2527 headers_list = get_selected_headers (win);
2531 iter = tny_list_create_iterator (headers_list);
2533 header = TNY_HEADER (tny_iterator_get_current (iter));
2534 headers_action_show_details (header, win, NULL);
2535 g_object_unref (header);
2537 g_object_unref (iter);
2538 g_object_unref (headers_list);
2540 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2541 GtkWidget *folder_view, *header_view;
2543 /* Check which widget has the focus */
2544 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2545 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2546 if (gtk_widget_is_focus (folder_view)) {
2549 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2551 /* Show only when it's a folder */
2552 if (!folder || !TNY_IS_FOLDER (folder))
2555 show_folder_details (folder, GTK_WINDOW (win));
2556 g_object_unref (folder);
2559 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2560 MODEST_WIDGET_TYPE_HEADER_VIEW);
2561 /* Show details of each header */
2562 do_headers_action (win, headers_action_show_details, header_view);
2568 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2569 ModestMsgEditWindow *window)
2571 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2573 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2577 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2578 ModestMsgEditWindow *window)
2580 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2582 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2586 modest_ui_actions_toggle_folders_view (GtkAction *action,
2587 ModestMainWindow *main_window)
2591 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2593 conf = modest_runtime_get_conf ();
2595 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2596 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2598 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2602 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2603 ModestWindow *window)
2605 gboolean active, fullscreen = FALSE;
2606 ModestWindowMgr *mgr;
2608 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2610 /* Check if we want to toggle the toolbar vuew in fullscreen
2612 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2613 "ViewShowToolbarFullScreen")) {
2617 /* Toggle toolbar */
2618 mgr = modest_runtime_get_window_mgr ();
2619 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2623 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2624 ModestMsgEditWindow *window)
2626 modest_msg_edit_window_select_font (window);
2630 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2631 const gchar *display_name,
2634 /* Do not change the application name if the widget has not
2635 the focus. This callback could be called even if the folder
2636 view has not the focus, because the handled signal could be
2637 emitted when the folder view is redrawn */
2638 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2640 gtk_window_set_title (window, display_name);
2642 gtk_window_set_title (window, " ");
2647 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2649 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2650 modest_msg_edit_window_select_contacts (window);
2654 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2656 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2657 modest_msg_edit_window_check_names (window);
2662 create_move_to_dialog (ModestWindow *win,
2663 GtkWidget *folder_view,
2664 GtkWidget **tree_view)
2666 GtkWidget *dialog, *scroll;
2668 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2670 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2672 GTK_RESPONSE_ACCEPT,
2674 GTK_RESPONSE_REJECT,
2677 /* Create scrolled window */
2678 scroll = gtk_scrolled_window_new (NULL, NULL);
2679 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2680 GTK_POLICY_AUTOMATIC,
2681 GTK_POLICY_AUTOMATIC);
2683 /* Create folder view */
2684 *tree_view = modest_platform_create_folder_view (NULL);
2686 /* It could happen that we're trying to move a message from a
2687 window (msg window for example) after the main window was
2688 closed, so we can not just get the model of the folder
2690 if (MODEST_IS_FOLDER_VIEW (folder_view))
2691 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2692 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2694 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
2695 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
2697 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2699 /* Add scroll to dialog */
2700 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2701 scroll, FALSE, FALSE, 0);
2703 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2705 /* Select INBOX or local account */
2706 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (*tree_view));
2712 * Returns TRUE if at least one of the headers of the list belongs to
2713 * a message that has been fully retrieved.
2716 has_retrieved_msgs (TnyList *list)
2719 gboolean found = FALSE;
2721 iter = tny_list_create_iterator (list);
2722 while (tny_iterator_is_done (iter) && !found) {
2724 TnyHeaderFlags flags;
2726 header = TNY_HEADER (tny_iterator_get_current (iter));
2727 flags = tny_header_get_flags (header);
2728 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2732 tny_iterator_next (iter);
2734 g_object_unref (iter);
2740 * Shows a confirmation dialog to the user when we're moving messages
2741 * from a remote server to the local storage. Returns the dialog
2742 * response. If it's other kind of movement the it always returns
2746 msgs_move_to_confirmation (GtkWindow *win,
2747 TnyFolder *dest_folder,
2750 gint response = GTK_RESPONSE_OK;
2752 /* If the destination is a local folder */
2753 if (modest_tny_folder_is_local_folder (dest_folder)) {
2754 TnyFolder *src_folder;
2758 /* Get source folder */
2759 iter = tny_list_create_iterator (headers);
2760 header = TNY_HEADER (tny_iterator_get_current (iter));
2761 src_folder = tny_header_get_folder (header);
2762 g_object_unref (header);
2763 g_object_unref (iter);
2765 /* If the source is a remote folder */
2766 if (!modest_tny_folder_is_local_folder (src_folder)) {
2767 const gchar *message;
2769 if (has_retrieved_msgs (headers))
2770 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
2771 tny_list_get_length (headers));
2773 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
2774 tny_list_get_length (headers));
2776 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2777 (const gchar *) message);
2779 g_object_unref (src_folder);
2786 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2788 ModestMsgViewWindow *self = NULL;
2790 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2791 self = MODEST_MSG_VIEW_WINDOW (object);
2793 /* If there are not more messages don't do anything. The
2794 viewer will show the same message */
2795 if (!modest_msg_view_window_select_first_message (self))
2800 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
2803 GObject *win = modest_mail_operation_get_source (mail_op);
2805 /* TODO: show error message */
2806 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2807 _("mail_in_ui_folder_move_target_error"));
2808 g_object_unref (win);
2812 * UI handler for the "Move to" action when invoked from the
2816 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2817 ModestMainWindow *win)
2819 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2820 GtkWidget *header_view = NULL;
2822 TnyFolderStore *folder_store = NULL;
2823 ModestMailOperation *mail_op = NULL;
2825 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2827 /* Get the folder view */
2828 folder_view = modest_main_window_get_child_widget (win,
2829 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2831 /* Get header view */
2832 header_view = modest_main_window_get_child_widget (win,
2833 MODEST_WIDGET_TYPE_HEADER_VIEW);
2835 /* Create and run the dialog */
2836 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2837 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
2838 result = gtk_dialog_run (GTK_DIALOG(dialog));
2839 g_object_ref (tree_view);
2841 /* We do this to save an indentation level ;-) */
2842 if (result != GTK_RESPONSE_ACCEPT)
2845 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2847 if (TNY_IS_ACCOUNT (folder_store))
2850 /* Get folder or messages to transfer */
2851 if (gtk_widget_is_focus (folder_view)) {
2852 TnyFolderStore *src_folder;
2853 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2855 /* Clean folder on header view before moving it */
2856 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2858 if (TNY_IS_FOLDER (src_folder)) {
2860 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2862 modest_ui_actions_move_folder_error_handler,
2864 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2866 modest_mail_operation_xfer_folder (mail_op,
2867 TNY_FOLDER (src_folder),
2870 /* Unref mail operation */
2871 g_object_unref (G_OBJECT (mail_op));
2875 g_object_unref (G_OBJECT (src_folder));
2877 if (gtk_widget_is_focus (header_view)) {
2881 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2883 /* Ask for user confirmation */
2884 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2885 TNY_FOLDER (folder_store),
2888 /* Transfer messages */
2889 if (response == GTK_RESPONSE_OK) {
2890 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2891 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2894 modest_mail_operation_xfer_msgs (mail_op,
2896 TNY_FOLDER (folder_store),
2901 g_object_unref (G_OBJECT (mail_op));
2903 g_object_unref (headers);
2906 g_object_unref (folder_store);
2908 gtk_widget_destroy (dialog);
2913 * UI handler for the "Move to" action when invoked from the
2914 * ModestMsgViewWindow
2917 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2918 ModestMsgViewWindow *win)
2920 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2922 ModestMainWindow *main_window;
2926 /* Get the folder view */
2927 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2929 folder_view = modest_main_window_get_child_widget (main_window,
2930 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2934 /* Create and run the dialog */
2935 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2936 result = gtk_dialog_run (GTK_DIALOG(dialog));
2937 g_object_ref (tree_view);
2939 if (result == GTK_RESPONSE_ACCEPT) {
2940 TnyFolderStore *folder_store;
2943 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2945 /* Create header list */
2946 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2947 headers = tny_simple_list_new ();
2948 tny_list_prepend (headers, G_OBJECT (header));
2949 g_object_unref (header);
2951 /* Ask user for confirmation. MSG-NOT404 */
2952 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2953 TNY_FOLDER (folder_store),
2956 /* Transfer current msg */
2957 if (response == GTK_RESPONSE_OK) {
2958 ModestMailOperation *mail_op;
2960 /* Create mail op */
2961 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2962 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2965 /* Transfer messages */
2966 modest_mail_operation_xfer_msgs (mail_op,
2968 TNY_FOLDER (folder_store),
2970 transfer_msgs_from_viewer_cb,
2972 g_object_unref (G_OBJECT (mail_op));
2974 g_object_unref (headers);
2975 g_object_unref (folder_store);
2977 gtk_widget_destroy (dialog);
2981 modest_ui_actions_on_move_to (GtkAction *action,
2984 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2985 MODEST_IS_MSG_VIEW_WINDOW (win));
2987 if (MODEST_IS_MAIN_WINDOW (win))
2988 modest_ui_actions_on_main_window_move_to (action,
2989 MODEST_MAIN_WINDOW (win));
2991 modest_ui_actions_on_msg_view_window_move_to (action,
2992 MODEST_MSG_VIEW_WINDOW (win));
2996 * Calls #HeadersFunc for each header already selected in the main
2997 * window or the message currently being shown in the msg view window
3000 do_headers_action (ModestWindow *win,
3004 TnyList *headers_list;
3010 headers_list = get_selected_headers (win);
3014 /* Get the folder */
3015 iter = tny_list_create_iterator (headers_list);
3016 header = TNY_HEADER (tny_iterator_get_current (iter));
3017 folder = tny_header_get_folder (header);
3018 g_object_unref (header);
3020 /* Call the function for each header */
3021 while (!tny_iterator_is_done (iter)) {
3022 header = TNY_HEADER (tny_iterator_get_current (iter));
3023 func (header, win, user_data);
3024 g_object_unref (header);
3025 tny_iterator_next (iter);
3028 /* Trick: do a poke status in order to speed up the signaling
3030 tny_folder_poke_status (folder);
3033 g_object_unref (folder);
3034 g_object_unref (iter);
3035 g_object_unref (headers_list);
3039 modest_ui_actions_view_attachment (GtkAction *action,
3040 ModestWindow *window)
3042 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3043 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3045 /* not supported window for this action */
3046 g_return_if_reached ();
3051 modest_ui_actions_save_attachments (GtkAction *action,
3052 ModestWindow *window)
3054 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3055 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3057 /* not supported window for this action */
3058 g_return_if_reached ();
3063 modest_ui_actions_remove_attachments (GtkAction *action,
3064 ModestWindow *window)
3066 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3067 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3069 /* not supported window for this action */
3070 g_return_if_reached ();
3075 modest_ui_actions_on_settings (GtkAction *action,
3080 dialog = modest_platform_get_global_settings_dialog ();
3081 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3082 gtk_widget_show (dialog);
3084 gtk_dialog_run (GTK_DIALOG (dialog));
3086 gtk_widget_destroy (dialog);
3090 modest_ui_actions_on_help (GtkAction *action,
3093 const gchar *help_id = NULL;
3095 if (MODEST_IS_MAIN_WINDOW (win)) {
3096 const gchar *action_name;
3097 action_name = gtk_action_get_name (action);
3099 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3100 !strcmp (action_name, "HeaderViewCSMHelp")) {
3101 GtkWidget *folder_view;
3102 TnyFolderStore *folder_store;
3103 /* Get selected folder */
3104 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3105 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3106 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3108 /* Switch help_id */
3109 if (TNY_IS_FOLDER (folder_store)) {
3110 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
3111 case TNY_FOLDER_TYPE_NORMAL:
3112 help_id = "applications_email_userfolder";
3114 case TNY_FOLDER_TYPE_INBOX:
3115 help_id = "applications_email_inbox";
3117 case TNY_FOLDER_TYPE_OUTBOX:
3118 help_id = "applications_email_outbox";
3120 case TNY_FOLDER_TYPE_SENT:
3121 help_id = "applications_email_sent";
3123 case TNY_FOLDER_TYPE_DRAFTS:
3124 help_id = "applications_email_drafts";
3126 case TNY_FOLDER_TYPE_ARCHIVE:
3127 help_id = "applications_email_archive";
3133 g_object_unref (folder_store);
3135 help_id = "applications_email_mainview";
3137 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3138 help_id = "applications_email_viewer";
3139 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3140 help_id = "applications_email_editor";
3142 modest_platform_show_help (GTK_WINDOW (win), help_id);
3146 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3147 ModestWindow *window)
3149 ModestMailOperation *mail_op;
3153 headers = get_selected_headers (window);
3157 /* Create mail operation */
3158 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3160 modest_ui_actions_get_msgs_full_error_handler,
3162 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3163 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3166 g_object_unref (headers);
3167 g_object_unref (mail_op);
3171 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3172 ModestWindow *window)
3174 g_return_if_fail (MODEST_IS_WINDOW (window));
3177 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3181 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3182 ModestWindow *window)
3184 g_return_if_fail (MODEST_IS_WINDOW (window));
3187 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3191 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3192 ModestWindow *window)
3194 g_return_if_fail (MODEST_IS_WINDOW (window));
3197 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3201 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3202 ModestWindow *window)
3204 g_return_if_fail (MODEST_IS_WINDOW (window));
3207 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3211 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3212 ModestWindow *window)
3214 g_return_if_fail (MODEST_IS_WINDOW (window));
3217 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3221 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3222 ModestWindow *window)
3224 g_return_if_fail (MODEST_IS_WINDOW (window));
3227 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3231 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3232 ModestWindow *window)
3234 g_return_if_fail (MODEST_IS_WINDOW (window));
3237 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3241 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3242 ModestWindow *window)
3244 g_return_if_fail (MODEST_IS_WINDOW (window));
3247 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3251 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3253 g_return_if_fail (MODEST_IS_WINDOW (window));
3256 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3260 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3262 g_return_if_fail (MODEST_IS_WINDOW (window));
3264 modest_platform_show_search_messages (GTK_WINDOW (window));
3268 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3270 g_return_if_fail (MODEST_IS_WINDOW (win));
3271 modest_platform_show_addressbook (GTK_WINDOW (win));
3276 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3277 ModestWindow *window)
3279 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3281 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3285 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3286 ModestMailOperationState *state,
3289 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3291 /* Set send/receive operation finished */
3292 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3293 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));