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 #endif /* MODEST_PLATFORM_MAEMO */
53 #include "widgets/modest-ui-constants.h"
54 #include <widgets/modest-main-window.h>
55 #include <widgets/modest-msg-view-window.h>
56 #include <widgets/modest-account-view-window.h>
57 #include <widgets/modest-details-dialog.h>
58 #include <widgets/modest-attachments-view.h>
59 #include "widgets/modest-folder-view.h"
60 #include "widgets/modest-global-settings-dialog.h"
61 #include "modest-connection-specific-smtp-window.h"
62 #include "modest-account-mgr-helpers.h"
63 #include "modest-mail-operation.h"
64 #include "modest-text-utils.h"
66 #ifdef MODEST_HAVE_EASYSETUP
67 #include "easysetup/modest-easysetup-wizard.h"
68 #endif /* MODEST_HAVE_EASYSETUP */
70 #include <modest-widget-memory.h>
71 #include <tny-error.h>
72 #include <tny-simple-list.h>
73 #include <tny-msg-view.h>
74 #include <tny-device.h>
75 #include <tny-merge-folder.h>
77 #include <gtkhtml/gtkhtml.h>
79 typedef struct _GetMsgAsyncHelper {
81 ModestMailOperation *mail_op;
88 typedef enum _ReplyForwardAction {
94 typedef struct _ReplyForwardHelper {
95 guint reply_forward_type;
96 ReplyForwardAction action;
98 GtkWidget *parent_window;
103 * The do_headers_action uses this kind of functions to perform some
104 * action to each member of a list of headers
106 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
108 static void do_headers_action (ModestWindow *win,
112 static void open_msg_cb (ModestMailOperation *mail_op,
117 static void reply_forward_cb (ModestMailOperation *mail_op,
122 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
124 static void folder_refreshed_cb (ModestMailOperation *mail_op,
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));
255 /* refilter treemodel to hide marked-as-deleted rows */
256 if (MODEST_IS_HEADER_VIEW (user_data))
257 modest_header_view_refilter (MODEST_HEADER_VIEW (user_data));
261 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
263 TnyList *header_list = NULL;
264 TnyIterator *iter = NULL;
265 TnyHeader *header = NULL;
266 gchar *message = NULL;
269 ModestWindowMgr *mgr;
270 GtkWidget *header_view = NULL;
272 g_return_if_fail (MODEST_IS_WINDOW(win));
274 /* Check first if the header view has the focus */
275 if (MODEST_IS_MAIN_WINDOW (win)) {
277 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
278 MODEST_WIDGET_TYPE_HEADER_VIEW);
279 if (!gtk_widget_is_focus (header_view))
283 header_list = get_selected_headers (win);
284 if (!header_list) return;
286 /* Check if any of the headers is already opened, or in the process of being opened */
287 if (MODEST_IS_MAIN_WINDOW (win)) {
289 iter = tny_list_create_iterator (header_list);
291 mgr = modest_runtime_get_window_mgr ();
292 while (!tny_iterator_is_done (iter) && !found) {
293 header = TNY_HEADER (tny_iterator_get_current (iter));
294 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
295 g_object_unref (header);
296 tny_iterator_next (iter);
298 g_object_unref (iter);
303 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
304 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
306 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
310 g_object_unref (header_list);
316 if (tny_list_get_length(header_list) == 1) {
317 iter = tny_list_create_iterator (header_list);
318 header = TNY_HEADER (tny_iterator_get_current (iter));
319 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
320 g_object_unref (header);
321 g_object_unref (iter);
323 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
324 tny_list_get_length(header_list)), desc);
326 /* Confirmation dialog */
327 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
331 if (response == GTK_RESPONSE_OK) {
332 ModestMainWindow *main_window;
333 ModestWindowMgr *mgr;
335 /* Remove each header. If it's a view window header_view == NULL */
336 do_headers_action (win, headers_action_delete, header_view);
338 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
339 /* Close msg view window or select next */
340 if (modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW (win)) &&
341 modest_msg_view_window_first_message_selected (MODEST_MSG_VIEW_WINDOW (win))) {
342 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
344 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (win));
348 /* Refilter header view model, if main window still exists */
349 mgr = modest_runtime_get_window_mgr ();
350 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (mgr));
354 widget = modest_main_window_get_child_widget (main_window,
355 MODEST_WIDGET_TYPE_HEADER_VIEW);
356 modest_header_view_refilter (MODEST_HEADER_VIEW (widget));
358 /* Update toolbar dimming state */
359 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
366 g_object_unref (header_list);
372 /* delete either message or folder, based on where we are */
374 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
376 g_return_if_fail (MODEST_IS_WINDOW(win));
378 /* Check first if the header view has the focus */
379 if (MODEST_IS_MAIN_WINDOW (win)) {
381 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
382 MODEST_WIDGET_TYPE_FOLDER_VIEW);
383 if (gtk_widget_is_focus (w)) {
384 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
388 modest_ui_actions_on_delete_message (action, win);
394 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
396 #ifdef MODEST_PLATFORM_MAEMO
397 modest_osso_save_state();
398 #endif /* MODEST_PLATFORM_MAEMO */
400 g_debug ("closing down, clearing %d item(s) from operation queue",
401 modest_mail_operation_queue_num_elements
402 (modest_runtime_get_mail_operation_queue()));
404 /* cancel all outstanding operations */
405 modest_mail_operation_queue_cancel_all
406 (modest_runtime_get_mail_operation_queue());
408 g_debug ("queue has been cleared");
410 /* note: when modest-tny-account-store is finalized,
411 it will automatically set all network connections
418 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
421 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
423 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
424 /* gtk_widget_destroy (GTK_WIDGET (win)); */
425 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
426 /* gboolean ret_value; */
427 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
428 /* } else if (MODEST_IS_WINDOW (win)) { */
429 /* gtk_widget_destroy (GTK_WIDGET (win)); */
431 /* g_return_if_reached (); */
436 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
438 GtkClipboard *clipboard = NULL;
439 gchar *selection = NULL;
441 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
442 selection = gtk_clipboard_wait_for_text (clipboard);
444 /* Question: why is the clipboard being used here?
445 * It doesn't really make a lot of sense. */
449 modest_address_book_add_address (selection);
455 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
457 /* This is currently only implemented for Maemo */
458 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
459 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
460 run_account_setup_wizard (win);
463 /* Show the list of accounts: */
464 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
465 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
466 gtk_dialog_run (account_win);
467 gtk_widget_destroy (GTK_WIDGET(account_win));
470 GtkWidget *dialog, *label;
472 /* Create the widgets */
474 dialog = gtk_dialog_new_with_buttons ("Message",
476 GTK_DIALOG_DESTROY_WITH_PARENT,
480 label = gtk_label_new ("Hello World!");
482 /* Ensure that the dialog box is destroyed when the user responds. */
484 g_signal_connect_swapped (dialog, "response",
485 G_CALLBACK (gtk_widget_destroy),
488 /* Add the label, and show everything we've added to the dialog. */
490 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
492 gtk_widget_show_all (dialog);
493 #endif /* MODEST_PLATFORM_MAEMO */
497 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
499 ModestWindow *main_window = MODEST_WINDOW (user_data);
501 /* Save any changes. */
502 modest_connection_specific_smtp_window_save_server_accounts (
503 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
504 modest_window_get_active_account (main_window));
505 gtk_widget_destroy (GTK_WIDGET (window));
511 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
513 /* This is currently only implemented for Maemo,
514 * because it requires an API (libconic) to detect different connection
517 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
519 /* Create the window if necessary: */
520 const gchar *active_account_name = modest_window_get_active_account (win);
522 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
523 * or show the default account?
524 * If we show the default account then the account name should be shown in
525 * the window when we show it. */
526 if (!active_account_name) {
527 g_warning ("%s: No account is active.", __FUNCTION__);
531 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
532 modest_connection_specific_smtp_window_fill_with_connections (
533 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
534 modest_runtime_get_account_mgr(),
535 active_account_name);
537 /* Show the window: */
538 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
539 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
540 gtk_widget_show (specific_window);
542 /* Save changes when the window is hidden: */
543 g_signal_connect (specific_window, "hide",
544 G_CALLBACK (on_smtp_servers_window_hide), win);
545 #endif /* MODEST_PLATFORM_MAEMO */
549 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
551 ModestWindow *msg_win = NULL;
553 TnyFolder *folder = NULL;
554 gchar *account_name = NULL;
555 gchar *from_str = NULL;
556 /* GError *err = NULL; */
557 TnyAccount *account = NULL;
558 ModestWindowMgr *mgr;
559 gchar *signature = NULL, *blank_and_signature = NULL;
561 /* if there are no accounts yet, just show the wizard */
562 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
563 run_account_setup_wizard (win);
567 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
569 account_name = g_strdup (modest_window_get_active_account (win));
571 g_printerr ("modest: no account found\n");
575 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
577 TNY_ACCOUNT_TYPE_STORE);
579 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
583 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
585 g_printerr ("modest: failed get from string for '%s'\n", account_name);
589 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
590 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
591 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
592 MODEST_ACCOUNT_SIGNATURE, FALSE);
593 blank_and_signature = g_strconcat ("\n", signature, NULL);
596 blank_and_signature = g_strdup ("");
599 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
601 g_printerr ("modest: failed to create new msg\n");
605 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
607 g_printerr ("modest: failed to find Drafts folder\n");
612 /* Create and register edit window */
613 /* This is destroyed by TOOD. */
614 msg_win = modest_msg_edit_window_new (msg, account_name);
615 mgr = modest_runtime_get_window_mgr ();
616 modest_window_mgr_register_window (mgr, msg_win);
619 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
621 gtk_widget_show_all (GTK_WIDGET (msg_win));
624 g_free (account_name);
626 g_free (blank_and_signature);
628 g_object_unref (msg_win);
630 g_object_unref (G_OBJECT(account));
632 g_object_unref (G_OBJECT(msg));
634 g_object_unref (G_OBJECT(folder));
638 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
642 ModestMailOperationStatus status;
644 /* If there is no message or the operation was not successful */
645 status = modest_mail_operation_get_status (mail_op);
646 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
648 /* Remove the header from the preregistered uids */
649 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
659 open_msg_cb (ModestMailOperation *mail_op,
664 ModestWindowMgr *mgr = NULL;
665 ModestWindow *parent_win = NULL;
666 ModestWindow *win = NULL;
667 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
668 gchar *account = NULL;
671 /* Do nothing if there was any problem with the mail
672 operation. The error will be shown by the error_handler of
673 the mail operation */
674 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
675 printf ("DEBUG: %s: modest_ui_actions_msg_retrieval_check() failed.\n",
680 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
681 folder = tny_header_get_folder (header);
683 /* Mark header as read */
684 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
687 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
689 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
691 /* Gets folder type (OUTBOX headers will be opened in edit window */
692 if (modest_tny_folder_is_local_folder (folder))
693 folder_type = modest_tny_folder_get_local_folder_type (folder);
695 /* If the header is in the drafts folder then open the editor,
696 else the message view window */
697 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
698 /* we cannot edit without a valid account... */
699 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
700 run_account_setup_wizard(parent_win);
703 win = modest_msg_edit_window_new (msg, account);
705 gchar *uid = modest_tny_folder_get_header_unique_id (header);
707 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
708 GtkWidget *header_view;
709 GtkTreeSelection *sel;
710 GList *sel_list = NULL;
713 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
714 MODEST_WIDGET_TYPE_HEADER_VIEW);
716 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
717 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
719 if (sel_list != NULL) {
720 GtkTreeRowReference *row_reference;
722 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
723 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
724 g_list_free (sel_list);
726 win = modest_msg_view_window_new_with_header_model (msg,
731 gtk_tree_row_reference_free (row_reference);
733 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
736 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
741 /* Register and show new window */
743 mgr = modest_runtime_get_window_mgr ();
744 modest_window_mgr_register_window (mgr, win);
745 g_object_unref (win);
746 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
747 gtk_widget_show_all (GTK_WIDGET(win));
750 /* Update toolbar dimming state */
751 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
752 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
758 g_object_unref (parent_win);
759 /* g_object_unref (msg); */
760 g_object_unref (folder);
764 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
768 GObject *win = modest_mail_operation_get_source (mail_op);
770 error = modest_mail_operation_get_error (mail_op);
771 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
773 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
775 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
778 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
779 _("mail_ni_ui_folder_get_msg_folder_error"));
783 g_object_unref (win);
787 * This function is used by both modest_ui_actions_on_open and
788 * modest_ui_actions_on_header_activated. This way we always do the
789 * same when trying to open messages.
792 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
794 ModestWindowMgr *mgr = NULL;
795 TnyIterator *iter = NULL;
796 ModestMailOperation *mail_op1 = NULL;
797 ModestMailOperation *mail_op2 = NULL;
798 TnyList *not_opened_headers = NULL;
799 TnyList *not_opened_cached_headers = NULL;
800 TnyHeaderFlags flags;
802 /* Look if we already have a message view for each header. If
803 true, then remove the header from the list of headers to
805 mgr = modest_runtime_get_window_mgr ();
806 iter = tny_list_create_iterator (headers);
807 not_opened_headers = tny_simple_list_new ();
808 not_opened_cached_headers = tny_simple_list_new ();
809 while (!tny_iterator_is_done (iter)) {
811 ModestWindow *window;
815 header = TNY_HEADER (tny_iterator_get_current (iter));
816 flags = tny_header_get_flags (header);
819 found = modest_window_mgr_find_registered_header (mgr, header, &window);
821 /* Do not open again the message and present the
822 window to the user */
825 gtk_window_present (GTK_WINDOW (window));
827 /* the header has been registered already, we don't do
828 * anything but wait for the window to come up*/
829 g_warning ("debug: header %p already registered, waiting for window",
832 if (!(flags & TNY_HEADER_FLAG_CACHED))
833 tny_list_append (not_opened_headers, G_OBJECT (header));
834 /* Check if msg has already been retreived */
836 tny_list_append (not_opened_cached_headers, G_OBJECT (header));
838 g_object_unref (header);
839 tny_iterator_next (iter);
841 g_object_unref (iter);
844 /* If some messages would have to be downloaded, ask the user to
845 * make a connection. It's generally easier to do this here (in the mainloop)
846 * than later in a thread:
848 if (tny_list_get_length (not_opened_cached_headers) > 0) {
849 gboolean connected = modest_platform_connect_and_wait (GTK_WINDOW (win));
851 /* Don't go further if a connection would be necessary but none is available: */
853 g_object_unref (not_opened_headers);
854 g_object_unref (not_opened_cached_headers);
859 /* Register the headers before actually creating the windows: */
860 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
861 while (!tny_iterator_is_done (iter_not_opened)) {
862 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
863 modest_window_mgr_register_header (mgr, header);
864 g_object_unref (header);
866 tny_iterator_next (iter_not_opened);
868 g_object_unref (iter_not_opened);
869 iter_not_opened = NULL;
871 TnyIterator *iter_cached = tny_list_create_iterator (not_opened_cached_headers);
872 while (!tny_iterator_is_done (iter_cached)) {
873 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_cached));
874 modest_window_mgr_register_header (mgr, header);
875 g_object_unref (header);
877 tny_iterator_next (iter_cached);
879 g_object_unref (iter_cached);
883 /* Open each uncached message */
884 if (tny_list_get_length (not_opened_headers) > 0) {
885 mail_op1 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
887 modest_ui_actions_get_msgs_full_error_handler,
889 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op1);
890 if (tny_list_get_length (not_opened_headers) > 1) {
891 modest_mail_operation_get_msgs_full (mail_op1,
897 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
898 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
899 modest_mail_operation_get_msg (mail_op1, header, open_msg_cb, NULL);
900 g_object_unref (header);
901 g_object_unref (iter);
905 /* Open each cached message */
906 if (tny_list_get_length (not_opened_cached_headers) > 0) {
907 mail_op2 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
909 modest_ui_actions_get_msgs_full_error_handler,
911 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op2);
912 if (tny_list_get_length (not_opened_cached_headers) > 1) {
913 modest_mail_operation_get_msgs_full (mail_op2,
919 TnyIterator *iter = tny_list_create_iterator (not_opened_cached_headers);
920 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
921 modest_mail_operation_get_msg (mail_op2, header, open_msg_cb, NULL);
922 g_object_unref (header);
923 g_object_unref (iter);
928 if (not_opened_headers != NULL)
929 g_object_unref (not_opened_headers);
930 if (not_opened_cached_headers != NULL)
931 g_object_unref (not_opened_cached_headers);
933 g_object_unref (iter);
934 if (mail_op1 != NULL)
935 g_object_unref (mail_op1);
936 if (mail_op2 != NULL)
937 g_object_unref (mail_op2);
941 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
946 headers = get_selected_headers (win);
951 _modest_ui_actions_open (headers, win);
953 g_object_unref(headers);
958 free_reply_forward_helper (gpointer data)
960 ReplyForwardHelper *helper;
962 helper = (ReplyForwardHelper *) data;
963 g_free (helper->account_name);
964 g_slice_free (ReplyForwardHelper, helper);
968 reply_forward_cb (ModestMailOperation *mail_op,
974 ReplyForwardHelper *rf_helper;
975 ModestWindow *msg_win = NULL;
976 ModestEditType edit_type;
978 TnyAccount *account = NULL;
979 ModestWindowMgr *mgr = NULL;
980 gchar *signature = NULL;
982 /* If there was any error. The mail operation could be NULL,
983 this means that we already have the message downloaded and
984 that we didn't do a mail operation to retrieve it */
985 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
988 g_return_if_fail (user_data != NULL);
989 rf_helper = (ReplyForwardHelper *) user_data;
991 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
992 rf_helper->account_name);
993 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
994 rf_helper->account_name,
995 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
996 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
997 rf_helper->account_name,
998 MODEST_ACCOUNT_SIGNATURE, FALSE);
1001 /* Create reply mail */
1002 switch (rf_helper->action) {
1005 modest_tny_msg_create_reply_msg (msg, from, signature,
1006 rf_helper->reply_forward_type,
1007 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1009 case ACTION_REPLY_TO_ALL:
1011 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
1012 MODEST_TNY_MSG_REPLY_MODE_ALL);
1013 edit_type = MODEST_EDIT_TYPE_REPLY;
1015 case ACTION_FORWARD:
1017 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1018 edit_type = MODEST_EDIT_TYPE_FORWARD;
1021 g_return_if_reached ();
1028 g_printerr ("modest: failed to create message\n");
1032 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1033 rf_helper->account_name,
1034 TNY_ACCOUNT_TYPE_STORE);
1036 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1040 /* Create and register the windows */
1041 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
1042 mgr = modest_runtime_get_window_mgr ();
1043 modest_window_mgr_register_window (mgr, msg_win);
1045 if (rf_helper->parent_window != NULL) {
1046 gdouble parent_zoom;
1048 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1049 modest_window_set_zoom (msg_win, parent_zoom);
1052 /* Show edit window */
1053 gtk_widget_show_all (GTK_WIDGET (msg_win));
1057 g_object_unref (msg_win);
1059 g_object_unref (G_OBJECT (new_msg));
1061 g_object_unref (G_OBJECT (account));
1062 /* g_object_unref (msg); */
1063 g_object_unref (header);
1064 free_reply_forward_helper (rf_helper);
1068 * Checks a list of headers. If any of them are not currently
1069 * downloaded (CACHED) then it asks the user for permission to
1072 * Returns FALSE if the user does not want to download the
1073 * messages. Returns TRUE if the user allowed the download or if all
1074 * of them are currently downloaded
1077 download_uncached_messages (TnyList *header_list, GtkWindow *win)
1081 gint uncached_messages = 0;
1083 iter = tny_list_create_iterator (header_list);
1084 while (!tny_iterator_is_done (iter)) {
1086 TnyHeaderFlags flags;
1088 header = TNY_HEADER (tny_iterator_get_current (iter));
1089 flags = tny_header_get_flags (header);
1090 /* TODO: is this the right flag?, it seems that some
1091 headers that have been previously downloaded do not
1093 if (! (flags & TNY_HEADER_FLAG_CACHED))
1094 uncached_messages ++;
1095 g_object_unref (header);
1096 tny_iterator_next (iter);
1098 g_object_unref (iter);
1100 /* Ask for user permission to download the messages */
1102 if (uncached_messages > 0) {
1103 GtkResponseType response;
1105 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1106 ngettext("mcen_nc_get_msg",
1108 uncached_messages));
1109 if (response == GTK_RESPONSE_CANCEL)
1112 /* If a download will be necessary, make sure that we have a connection: */
1113 retval = modest_platform_connect_and_wait(win);
1121 * Common code for the reply and forward actions
1124 reply_forward (ReplyForwardAction action, ModestWindow *win)
1126 ModestMailOperation *mail_op = NULL;
1127 TnyList *header_list = NULL;
1128 ReplyForwardHelper *rf_helper = NULL;
1129 guint reply_forward_type;
1130 gboolean continue_download;
1132 g_return_if_fail (MODEST_IS_WINDOW(win));
1134 /* we need an account when editing */
1135 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1136 run_account_setup_wizard (win);
1140 header_list = get_selected_headers (win);
1144 /* Check that the messages have been previously downloaded */
1145 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
1146 if (!continue_download) {
1147 g_object_unref (header_list);
1151 reply_forward_type =
1152 modest_conf_get_int (modest_runtime_get_conf (),
1153 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1155 /* We assume that we can only select messages of the
1156 same folder and that we reply all of them from the
1157 same account. In fact the interface currently only
1158 allows single selection */
1161 rf_helper = g_slice_new0 (ReplyForwardHelper);
1162 rf_helper->reply_forward_type = reply_forward_type;
1163 rf_helper->action = action;
1164 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1165 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1166 rf_helper->parent_window = GTK_WIDGET (win);
1167 if (!rf_helper->account_name)
1168 rf_helper->account_name =
1169 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1171 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1174 /* Get header and message. Do not free them here, the
1175 reply_forward_cb must do it */
1176 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1177 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1178 if (!msg || !header) {
1180 g_object_unref (msg);
1182 g_object_unref (header);
1183 g_printerr ("modest: no message found\n");
1186 reply_forward_cb (NULL, header, msg, rf_helper);
1192 /* Retrieve messages */
1193 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1195 modest_ui_actions_get_msgs_full_error_handler,
1197 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1199 /* Only reply/forward to one message */
1200 iter = tny_list_create_iterator (header_list);
1201 header = TNY_HEADER (tny_iterator_get_current (iter));
1202 g_object_unref (iter);
1204 modest_mail_operation_get_msg (mail_op,
1209 /* modest_mail_operation_get_msgs_full (mail_op, */
1211 /* reply_forward_cb, */
1213 /* free_reply_forward_helper); */
1216 g_object_unref(mail_op);
1220 g_object_unref (header_list);
1224 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1226 g_return_if_fail (MODEST_IS_WINDOW(win));
1228 reply_forward (ACTION_REPLY, win);
1232 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1234 g_return_if_fail (MODEST_IS_WINDOW(win));
1236 reply_forward (ACTION_FORWARD, win);
1240 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1242 g_return_if_fail (MODEST_IS_WINDOW(win));
1244 reply_forward (ACTION_REPLY_TO_ALL, win);
1248 modest_ui_actions_on_next (GtkAction *action,
1249 ModestWindow *window)
1251 if (MODEST_IS_MAIN_WINDOW (window)) {
1252 GtkWidget *header_view;
1254 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1255 MODEST_WIDGET_TYPE_HEADER_VIEW);
1259 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1260 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1261 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1263 g_return_if_reached ();
1268 modest_ui_actions_on_prev (GtkAction *action,
1269 ModestWindow *window)
1271 g_return_if_fail (MODEST_IS_WINDOW(window));
1273 if (MODEST_IS_MAIN_WINDOW (window)) {
1274 GtkWidget *header_view;
1275 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1276 MODEST_WIDGET_TYPE_HEADER_VIEW);
1280 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1281 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1282 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1284 g_return_if_reached ();
1289 modest_ui_actions_on_sort (GtkAction *action,
1290 ModestWindow *window)
1292 g_return_if_fail (MODEST_IS_WINDOW(window));
1294 if (MODEST_IS_MAIN_WINDOW (window)) {
1295 GtkWidget *header_view;
1296 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1297 MODEST_WIDGET_TYPE_HEADER_VIEW);
1301 /* Show sorting dialog */
1302 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1307 new_messages_arrived (ModestMailOperation *self,
1311 if (new_messages == 0)
1314 modest_platform_on_new_msg ();
1318 * This function performs the send & receive required actions. The
1319 * window is used to create the mail operation. Typically it should
1320 * always be the main window, but we pass it as argument in order to
1324 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1326 gchar *acc_name = NULL;
1327 ModestMailOperation *mail_op;
1329 /* If no account name was provided then get the current account, and if
1330 there is no current account then pick the default one: */
1331 if (!account_name) {
1332 acc_name = g_strdup (modest_window_get_active_account(win));
1334 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1336 g_printerr ("modest: cannot get default account\n");
1340 acc_name = g_strdup (account_name);
1343 /* Set send/receive operation in progress */
1344 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1346 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1348 modest_ui_actions_send_receive_error_handler,
1351 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1352 G_CALLBACK (_on_send_receive_progress_changed),
1355 /* Send & receive. */
1356 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1357 /* Receive and then send. The operation is tagged initially as
1358 a receive operation because the account update performs a
1359 receive and then a send. The operation changes its type
1360 internally, so the progress objects will receive the proper
1361 progress information */
1362 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1363 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1364 g_object_unref (G_OBJECT (mail_op));
1372 modest_ui_actions_do_cancel_send (const gchar *account_name,
1375 TnyTransportAccount *transport_account;
1376 TnySendQueue *send_queue = NULL;
1377 GError *error = NULL;
1379 /* Get transport account */
1381 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1382 (modest_runtime_get_account_store(),
1384 TNY_ACCOUNT_TYPE_TRANSPORT));
1385 if (!transport_account) {
1386 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1391 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1392 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1393 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1394 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1395 "modest: could not find send queue for account\n");
1397 /* Keeep messages in outbox folder */
1398 tny_send_queue_cancel (send_queue, FALSE, &error);
1402 if (transport_account != NULL)
1403 g_object_unref (G_OBJECT (transport_account));
1407 modest_ui_actions_cancel_send_all (ModestWindow *win)
1409 GSList *account_names, *iter;
1411 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1414 iter = account_names;
1416 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1417 iter = g_slist_next (iter);
1420 modest_account_mgr_free_account_names (account_names);
1421 account_names = NULL;
1425 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1428 /* Check if accounts exist */
1429 gboolean accounts_exist =
1430 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1432 /* If not, allow the user to create an account before trying to send/receive. */
1433 if (!accounts_exist)
1434 modest_ui_actions_on_accounts (NULL, win);
1436 /* Cancel all sending operaitons */
1437 modest_ui_actions_cancel_send_all (win);
1441 * Refreshes all accounts. This function will be used by automatic
1445 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1447 GSList *account_names, *iter;
1449 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1452 iter = account_names;
1454 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1455 iter = g_slist_next (iter);
1458 modest_account_mgr_free_account_names (account_names);
1459 account_names = NULL;
1463 * Handler of the click on Send&Receive button in the main toolbar
1466 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1468 /* Check if accounts exist */
1469 gboolean accounts_exist =
1470 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1472 /* If not, allow the user to create an account before trying to send/receive. */
1473 if (!accounts_exist)
1474 modest_ui_actions_on_accounts (NULL, win);
1476 /* Refresh currently selected folder. Note that if we only
1477 want to retrive the headers, then the refresh only will
1478 invoke a poke_status over all folders, i.e., only the
1479 total/unread count will be updated */
1480 if (MODEST_IS_MAIN_WINDOW (win)) {
1481 GtkWidget *header_view, *folder_view;
1482 TnyFolderStore *folder_store;
1484 /* Get folder and header view */
1486 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1487 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1489 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1491 if (TNY_IS_FOLDER (folder_store)) {
1493 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1494 MODEST_WIDGET_TYPE_HEADER_VIEW);
1496 /* We do not need to set the contents style
1497 because it hasn't changed. We also do not
1498 need to save the widget status. Just force
1500 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1501 TNY_FOLDER (folder_store),
1502 folder_refreshed_cb,
1503 MODEST_MAIN_WINDOW (win));
1505 g_object_unref (folder_store);
1508 /* Refresh the active account */
1509 modest_ui_actions_do_send_receive (NULL, win);
1514 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1517 GtkWidget *header_view;
1519 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1521 header_view = modest_main_window_get_child_widget (main_window,
1522 MODEST_WIDGET_TYPE_HEADER_VIEW);
1526 conf = modest_runtime_get_conf ();
1528 /* what is saved/restored is depending on the style; thus; we save with
1529 * old style, then update the style, and restore for this new style
1531 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1533 if (modest_header_view_get_style
1534 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1535 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1536 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1538 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1539 MODEST_HEADER_VIEW_STYLE_DETAILS);
1541 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1542 MODEST_CONF_HEADER_VIEW_KEY);
1547 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1549 ModestMainWindow *main_window)
1551 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1552 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1554 /* If no header has been selected then exit */
1559 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1560 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1562 /* Update Main window title */
1563 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1564 const gchar *subject = tny_header_get_subject (header);
1565 if (subject && strlen(subject) > 0)
1566 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1568 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1571 /* Update toolbar dimming state */
1572 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1576 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1578 ModestMainWindow *main_window)
1582 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1587 headers = tny_simple_list_new ();
1588 tny_list_prepend (headers, G_OBJECT (header));
1590 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1592 g_object_unref (headers);
1596 set_active_account_from_tny_account (TnyAccount *account,
1597 ModestWindow *window)
1599 const gchar *server_acc_name = tny_account_get_id (account);
1601 /* We need the TnyAccount provided by the
1602 account store because that is the one that
1603 knows the name of the Modest account */
1604 TnyAccount *modest_server_account = modest_server_account =
1605 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1606 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1609 const gchar *modest_acc_name =
1610 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1611 modest_window_set_active_account (window, modest_acc_name);
1612 g_object_unref (modest_server_account);
1617 folder_refreshed_cb (ModestMailOperation *mail_op,
1621 ModestMainWindow *win = NULL;
1622 GtkWidget *header_view;
1624 g_return_if_fail (TNY_IS_FOLDER (folder));
1626 win = MODEST_MAIN_WINDOW (user_data);
1628 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1630 /* Check if folder is empty and set headers view contents style */
1631 if (tny_folder_get_all_count (folder) == 0) {
1632 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1633 modest_main_window_set_contents_style (win,
1634 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1636 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1641 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1642 TnyFolderStore *folder_store,
1644 ModestMainWindow *main_window)
1647 GtkWidget *header_view;
1649 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1651 header_view = modest_main_window_get_child_widget(main_window,
1652 MODEST_WIDGET_TYPE_HEADER_VIEW);
1656 conf = modest_runtime_get_conf ();
1658 if (TNY_IS_ACCOUNT (folder_store)) {
1660 /* Update active account */
1661 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1662 /* Show account details */
1663 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1666 if (TNY_IS_FOLDER (folder_store) && selected) {
1668 /* Update the active account */
1669 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1671 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1672 g_object_unref (account);
1676 /* Set the header style by default, it could
1677 be changed later by the refresh callback to
1679 modest_main_window_set_contents_style (main_window,
1680 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1682 /* Set folder on header view. This function
1683 will call tny_folder_refresh_async so we
1684 pass a callback that will be called when
1685 finished. We use that callback to set the
1686 empty view if there are no messages */
1687 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1688 TNY_FOLDER (folder_store),
1689 folder_refreshed_cb,
1692 /* Restore configuration. We need to do this
1693 *after* the set_folder because the widget
1694 memory asks the header view about its
1696 modest_widget_memory_restore (modest_runtime_get_conf (),
1697 G_OBJECT(header_view),
1698 MODEST_CONF_HEADER_VIEW_KEY);
1700 /* Update the active account */
1701 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1702 /* Save only if we're seeing headers */
1703 if (modest_main_window_get_contents_style (main_window) ==
1704 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1705 modest_widget_memory_save (conf, G_OBJECT (header_view),
1706 MODEST_CONF_HEADER_VIEW_KEY);
1707 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1711 /* Update toolbar dimming state */
1712 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1716 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1723 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1725 online = tny_device_is_online (modest_runtime_get_device());
1728 /* already online -- the item is simply not there... */
1729 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1731 GTK_MESSAGE_WARNING,
1733 _("The %s you selected cannot be found"),
1735 gtk_dialog_run (GTK_DIALOG(dialog));
1737 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1741 GTK_RESPONSE_REJECT,
1743 GTK_RESPONSE_ACCEPT,
1745 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1746 "Do you want to get online?"), item);
1747 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1748 gtk_label_new (txt), FALSE, FALSE, 0);
1749 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1752 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1753 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1754 // modest_platform_connect_and_wait ();
1757 gtk_widget_destroy (dialog);
1761 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1764 /* g_message ("%s %s", __FUNCTION__, link); */
1769 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1772 modest_platform_activate_uri (link);
1776 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1779 modest_platform_show_uri_popup (link);
1783 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1786 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1790 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1791 const gchar *address,
1794 /* g_message ("%s %s", __FUNCTION__, address); */
1798 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1800 TnyTransportAccount *transport_account;
1801 ModestMailOperation *mail_operation;
1803 gchar *account_name, *from;
1804 ModestAccountMgr *account_mgr;
1805 gchar *info_text = NULL;
1806 TnyMsg *new_draft = NULL;
1808 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1810 data = modest_msg_edit_window_get_msg_data (edit_window);
1812 account_mgr = modest_runtime_get_account_mgr();
1813 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1815 account_name = modest_account_mgr_get_default_account (account_mgr);
1816 if (!account_name) {
1817 g_printerr ("modest: no account found\n");
1818 modest_msg_edit_window_free_msg_data (edit_window, data);
1822 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1823 account_name = g_strdup (data->account_name);
1827 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1828 (modest_runtime_get_account_store(),
1830 TNY_ACCOUNT_TYPE_TRANSPORT));
1831 if (!transport_account) {
1832 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1833 g_free (account_name);
1834 modest_msg_edit_window_free_msg_data (edit_window, data);
1837 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1839 /* Create the mail operation */
1840 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1841 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1843 new_draft = modest_mail_operation_save_to_drafts (mail_operation,
1854 data->priority_flags);
1857 g_free (account_name);
1858 g_object_unref (G_OBJECT (transport_account));
1859 g_object_unref (G_OBJECT (mail_operation));
1861 modest_msg_edit_window_free_msg_data (edit_window, data);
1863 modest_msg_edit_window_set_draft (edit_window, new_draft);
1864 if (new_draft != NULL)
1865 g_object_unref (new_draft);
1867 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1868 modest_platform_information_banner (NULL, NULL, info_text);
1872 /* For instance, when clicking the Send toolbar button when editing a message: */
1874 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1876 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1878 if (!modest_msg_edit_window_check_names (edit_window))
1881 /* Offer the connection dialog, if necessary: */
1882 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window)))
1885 /* FIXME: Code added just for testing. The final version will
1886 use the send queue provided by tinymail and some
1888 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1889 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1891 account_name = modest_account_mgr_get_default_account (account_mgr);
1893 if (!account_name) {
1894 g_printerr ("modest: no account found\n");
1898 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1900 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1901 account_name = g_strdup (data->account_name);
1904 /* Get the currently-active transport account for this modest account: */
1905 TnyTransportAccount *transport_account =
1906 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1907 (modest_runtime_get_account_store(),
1909 if (!transport_account) {
1910 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1911 g_free (account_name);
1912 modest_msg_edit_window_free_msg_data (edit_window, data);
1916 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1918 /* mail content checks and dialogs */
1919 if (data->subject == NULL || data->subject[0] == '\0') {
1920 GtkResponseType response;
1921 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1922 _("mcen_nc_subject_is_empty_send"));
1923 if (response == GTK_RESPONSE_CANCEL) {
1924 g_free (account_name);
1929 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1930 GtkResponseType response;
1931 gchar *note_message;
1932 gchar *note_subject = data->subject;
1933 if (note_subject == NULL || note_subject[0] == '\0')
1934 note_subject = _("mail_va_no_subject");
1935 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1936 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1938 g_free (note_message);
1939 if (response == GTK_RESPONSE_CANCEL) {
1940 g_free (account_name);
1945 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
1947 /* Create the mail operation */
1948 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1949 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1951 modest_mail_operation_send_new_mail (mail_operation,
1962 data->priority_flags);
1966 g_free (account_name);
1967 g_object_unref (G_OBJECT (transport_account));
1968 g_object_unref (G_OBJECT (mail_operation));
1970 modest_msg_edit_window_free_msg_data (edit_window, data);
1971 modest_msg_edit_window_set_sent (edit_window, TRUE);
1973 /* Save settings and close the window: */
1974 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
1978 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1979 ModestMsgEditWindow *window)
1981 ModestMsgEditFormatState *format_state = NULL;
1983 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1984 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1986 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1989 format_state = modest_msg_edit_window_get_format_state (window);
1990 g_return_if_fail (format_state != NULL);
1992 format_state->bold = gtk_toggle_action_get_active (action);
1993 modest_msg_edit_window_set_format_state (window, format_state);
1994 g_free (format_state);
1999 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2000 ModestMsgEditWindow *window)
2002 ModestMsgEditFormatState *format_state = NULL;
2004 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2005 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2007 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2010 format_state = modest_msg_edit_window_get_format_state (window);
2011 g_return_if_fail (format_state != NULL);
2013 format_state->italics = gtk_toggle_action_get_active (action);
2014 modest_msg_edit_window_set_format_state (window, format_state);
2015 g_free (format_state);
2020 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2021 ModestMsgEditWindow *window)
2023 ModestMsgEditFormatState *format_state = NULL;
2025 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2026 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2028 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2031 format_state = modest_msg_edit_window_get_format_state (window);
2032 g_return_if_fail (format_state != NULL);
2034 format_state->bullet = gtk_toggle_action_get_active (action);
2035 modest_msg_edit_window_set_format_state (window, format_state);
2036 g_free (format_state);
2041 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2042 GtkRadioAction *selected,
2043 ModestMsgEditWindow *window)
2045 ModestMsgEditFormatState *format_state = NULL;
2046 GtkJustification value;
2048 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2050 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2053 value = gtk_radio_action_get_current_value (selected);
2055 format_state = modest_msg_edit_window_get_format_state (window);
2056 g_return_if_fail (format_state != NULL);
2058 format_state->justification = value;
2059 modest_msg_edit_window_set_format_state (window, format_state);
2060 g_free (format_state);
2064 modest_ui_actions_on_select_editor_color (GtkAction *action,
2065 ModestMsgEditWindow *window)
2067 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2068 g_return_if_fail (GTK_IS_ACTION (action));
2070 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2073 modest_msg_edit_window_select_color (window);
2077 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2078 ModestMsgEditWindow *window)
2080 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2081 g_return_if_fail (GTK_IS_ACTION (action));
2083 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2086 modest_msg_edit_window_select_background_color (window);
2090 modest_ui_actions_on_insert_image (GtkAction *action,
2091 ModestMsgEditWindow *window)
2093 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2094 g_return_if_fail (GTK_IS_ACTION (action));
2096 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2099 modest_msg_edit_window_insert_image (window);
2103 modest_ui_actions_on_attach_file (GtkAction *action,
2104 ModestMsgEditWindow *window)
2106 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2107 g_return_if_fail (GTK_IS_ACTION (action));
2109 modest_msg_edit_window_attach_file (window);
2113 modest_ui_actions_on_remove_attachments (GtkAction *action,
2114 ModestMsgEditWindow *window)
2116 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2117 g_return_if_fail (GTK_IS_ACTION (action));
2119 modest_msg_edit_window_remove_attachments (window, NULL);
2123 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2126 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2128 /* TODO: Note that folder creation might go wrong due to other
2129 * failures such as when the parent folder is non-writable. We can
2130 * query a GError* with modest_mail_operation_get_error(), but the
2131 * the error code (from tinymail) does not give us a clue about what
2132 * has gone wrong. We might use the error->message but it might come
2133 * from camel and not be suitable to show to the user directly. */
2134 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2135 _CS("ckdg_ib_folder_already_exists"));
2137 /* modest_platform_information_banner (GTK_WIDGET (window), NULL,
2138 modest_mail_operation_get_error (mail_op)->message);*/
2142 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2144 TnyFolderStore *parent_folder;
2145 GtkWidget *folder_view;
2147 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2149 folder_view = modest_main_window_get_child_widget (main_window,
2150 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2154 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2156 if (parent_folder) {
2157 gboolean finished = FALSE;
2159 gchar *folder_name = NULL, *suggested_name = NULL;
2161 /* Run the new folder dialog */
2163 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
2168 g_free (suggested_name);
2169 suggested_name = NULL;
2171 if (result == GTK_RESPONSE_REJECT) {
2174 ModestMailOperation *mail_op;
2175 TnyFolder *new_folder = NULL;
2177 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2178 G_OBJECT(main_window),
2179 modest_ui_actions_new_folder_error_handler,
2182 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2184 new_folder = modest_mail_operation_create_folder (mail_op,
2186 (const gchar *) folder_name);
2188 g_object_unref (new_folder);
2191 g_object_unref (mail_op);
2194 suggested_name = folder_name;
2198 g_object_unref (parent_folder);
2203 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2206 GObject *win = modest_mail_operation_get_source (mail_op);
2207 const GError *error = NULL;
2208 const gchar *message = NULL;
2210 /* Get error message */
2211 error = modest_mail_operation_get_error (mail_op);
2212 if (error != NULL && error->message != NULL) {
2213 message = error->message;
2215 message = _("!!! FIXME: Unable to rename");
2218 /* Show notification dialog */
2219 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
2220 g_object_unref (win);
2224 modest_ui_actions_on_rename_folder (GtkAction *action,
2225 ModestMainWindow *main_window)
2227 TnyFolderStore *folder;
2228 GtkWidget *folder_view;
2229 GtkWidget *header_view;
2231 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2233 folder_view = modest_main_window_get_child_widget (main_window,
2234 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2238 header_view = modest_main_window_get_child_widget (main_window,
2239 MODEST_WIDGET_TYPE_HEADER_VIEW);
2244 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2246 /* Offer the connection dialog if necessary: */
2247 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2248 g_object_unref (G_OBJECT (folder));
2253 if (folder && TNY_IS_FOLDER (folder)) {
2256 const gchar *current_name;
2258 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2259 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2260 current_name, &folder_name);
2262 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2263 ModestMailOperation *mail_op;
2266 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2267 G_OBJECT(main_window),
2268 modest_ui_actions_rename_folder_error_handler,
2272 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2275 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2277 modest_mail_operation_rename_folder (mail_op,
2278 TNY_FOLDER (folder),
2279 (const gchar *) folder_name);
2281 g_object_unref (mail_op);
2282 g_free (folder_name);
2284 g_object_unref (folder);
2289 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2292 GObject *win = modest_mail_operation_get_source (mail_op);
2294 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2295 _("mail_in_ui_folder_delete_error"));
2296 g_object_unref (win);
2300 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2302 TnyFolderStore *folder;
2303 GtkWidget *folder_view;
2307 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2309 folder_view = modest_main_window_get_child_widget (main_window,
2310 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2314 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2316 /* Show an error if it's an account */
2317 if (!TNY_IS_FOLDER (folder)) {
2318 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2319 _("mail_in_ui_folder_delete_error"));
2320 g_object_unref (G_OBJECT (folder));
2324 /* Offer the connection dialog if necessary: */
2325 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2326 g_object_unref (G_OBJECT (folder));
2331 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2332 tny_folder_get_name (TNY_FOLDER (folder)));
2333 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2334 (const gchar *) message);
2337 if (response == GTK_RESPONSE_OK) {
2338 ModestMailOperation *mail_op =
2339 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2340 G_OBJECT(main_window),
2341 modest_ui_actions_delete_folder_error_handler,
2344 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2346 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2347 g_object_unref (G_OBJECT (mail_op));
2350 g_object_unref (G_OBJECT (folder));
2354 modest_ui_actions_on_delete_folder (GtkAction *action,
2355 ModestMainWindow *main_window)
2357 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2359 delete_folder (main_window, FALSE);
2363 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2365 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2367 delete_folder (main_window, TRUE);
2371 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2372 const gchar* server_account_name,
2377 ModestMainWindow *main_window)
2379 g_return_if_fail(server_account_name);
2380 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2382 /* Initalize output parameters: */
2389 #ifdef MODEST_PLATFORM_MAEMO
2390 /* Maemo uses a different (awkward) button order,
2391 * It should probably just use gtk_alternative_dialog_button_order ().
2393 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2397 GTK_RESPONSE_ACCEPT,
2399 GTK_RESPONSE_REJECT,
2402 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2406 GTK_RESPONSE_REJECT,
2408 GTK_RESPONSE_ACCEPT,
2410 #endif /* MODEST_PLATFORM_MAEMO */
2412 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2414 gchar *server_name = modest_server_account_get_hostname (
2415 modest_runtime_get_account_mgr(), server_account_name);
2416 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2417 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2422 /* This causes a warning because the logical ID has no %s in it,
2423 * though the translation does, but there is not much we can do about that: */
2424 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2425 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2428 g_free (server_name);
2432 gchar *initial_username = modest_server_account_get_username (
2433 modest_runtime_get_account_mgr(), server_account_name);
2435 GtkWidget *entry_username = gtk_entry_new ();
2436 if (initial_username)
2437 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2438 /* Dim this if a connection has ever succeeded with this username,
2439 * as per the UI spec: */
2440 const gboolean username_known =
2441 modest_server_account_get_username_has_succeeded(
2442 modest_runtime_get_account_mgr(), server_account_name);
2443 gtk_widget_set_sensitive (entry_username, !username_known);
2445 #ifdef MODEST_PLATFORM_MAEMO
2446 /* Auto-capitalization is the default, so let's turn it off: */
2447 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2449 /* Create a size group to be used by all captions.
2450 * Note that HildonCaption does not create a default size group if we do not specify one.
2451 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2452 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2454 GtkWidget *caption = hildon_caption_new (sizegroup,
2455 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2456 gtk_widget_show (entry_username);
2457 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2458 FALSE, FALSE, MODEST_MARGIN_HALF);
2459 gtk_widget_show (caption);
2461 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2463 #endif /* MODEST_PLATFORM_MAEMO */
2466 GtkWidget *entry_password = gtk_entry_new ();
2467 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2468 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2470 #ifdef MODEST_PLATFORM_MAEMO
2471 /* Auto-capitalization is the default, so let's turn it off: */
2472 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2473 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2475 caption = hildon_caption_new (sizegroup,
2476 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2477 gtk_widget_show (entry_password);
2478 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2479 FALSE, FALSE, MODEST_MARGIN_HALF);
2480 gtk_widget_show (caption);
2481 g_object_unref (sizegroup);
2483 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2485 #endif /* MODEST_PLATFORM_MAEMO */
2487 /* This is not in the Maemo UI spec:
2488 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2489 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2493 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2495 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2497 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2499 modest_server_account_set_username (
2500 modest_runtime_get_account_mgr(), server_account_name,
2503 const gboolean username_was_changed =
2504 (strcmp (*username, initial_username) != 0);
2505 if (username_was_changed) {
2506 g_warning ("%s: tinymail does not yet support changing the "
2507 "username in the get_password() callback.\n", __FUNCTION__);
2512 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2514 /* We do not save the password in the configuration,
2515 * because this function is only called for passwords that should
2516 * not be remembered:
2517 modest_server_account_set_password (
2518 modest_runtime_get_account_mgr(), server_account_name,
2537 /* This is not in the Maemo UI spec:
2538 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2544 gtk_widget_destroy (dialog);
2546 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2550 modest_ui_actions_on_cut (GtkAction *action,
2551 ModestWindow *window)
2553 GtkWidget *focused_widget;
2555 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2556 if (GTK_IS_EDITABLE (focused_widget)) {
2557 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2558 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2559 GtkTextBuffer *buffer;
2560 GtkClipboard *clipboard;
2562 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2563 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2564 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2565 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2566 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2567 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2568 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2569 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2574 modest_ui_actions_on_copy (GtkAction *action,
2575 ModestWindow *window)
2577 GtkClipboard *clipboard;
2578 GtkWidget *focused_widget;
2580 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2581 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2583 if (GTK_IS_LABEL (focused_widget)) {
2584 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2585 } else if (GTK_IS_EDITABLE (focused_widget)) {
2586 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2587 } else if (GTK_IS_HTML (focused_widget)) {
2588 gtk_html_copy (GTK_HTML (focused_widget));
2589 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2590 GtkTextBuffer *buffer;
2591 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2592 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2593 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2594 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2595 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2596 TnyIterator *iter = tny_list_create_iterator (header_list);
2597 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2598 TnyFolder *folder = tny_header_get_folder (header);
2599 TnyAccount *account = tny_folder_get_account (folder);
2600 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2601 /* If it's POP then ask */
2602 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2603 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2604 g_object_unref (account);
2605 g_object_unref (folder);
2606 g_object_unref (header);
2607 g_object_unref (iter);
2609 /* Check that the messages have been previously downloaded */
2610 gboolean continue_download = TRUE;
2612 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window));
2613 if (continue_download)
2614 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2615 g_object_unref (header_list);
2616 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2617 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2620 /* Show information banner */
2621 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2626 modest_ui_actions_on_undo (GtkAction *action,
2627 ModestWindow *window)
2629 ModestEmailClipboard *clipboard = NULL;
2631 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2632 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2633 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2634 /* Clear clipboard source */
2635 clipboard = modest_runtime_get_email_clipboard ();
2636 modest_email_clipboard_clear (clipboard);
2639 g_return_if_reached ();
2644 modest_ui_actions_on_redo (GtkAction *action,
2645 ModestWindow *window)
2647 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2648 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2651 g_return_if_reached ();
2657 paste_msgs_cb (const GObject *object, gpointer user_data)
2659 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2660 g_return_if_fail (GTK_IS_WIDGET (user_data));
2662 /* destroy information note */
2663 gtk_widget_destroy (GTK_WIDGET(user_data));
2667 modest_ui_actions_on_paste (GtkAction *action,
2668 ModestWindow *window)
2670 GtkWidget *focused_widget = NULL;
2671 GtkWidget *inf_note = NULL;
2672 ModestMailOperation *mail_op = NULL;
2674 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2675 if (GTK_IS_EDITABLE (focused_widget)) {
2676 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2677 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2678 GtkTextBuffer *buffer;
2679 GtkClipboard *clipboard;
2681 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2682 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2683 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2684 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2685 ModestEmailClipboard *clipboard = NULL;
2686 TnyFolder *src_folder = NULL;
2687 TnyFolderStore *folder_store = NULL;
2688 TnyList *data = NULL;
2689 gboolean delete = FALSE;
2691 /* Check clipboard source */
2692 clipboard = modest_runtime_get_email_clipboard ();
2693 if (modest_email_clipboard_cleared (clipboard))
2696 /* Get elements to paste */
2697 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2699 /* Create a new mail operation */
2700 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2701 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2704 /* Get destination folder */
2705 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2707 /* Launch notification */
2708 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2709 _CS("ckct_nw_pasting"));
2710 if (inf_note != NULL) {
2711 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
2712 gtk_widget_show (GTK_WIDGET(inf_note));
2715 /* transfer messages */
2717 modest_mail_operation_xfer_msgs (mail_op,
2719 TNY_FOLDER (folder_store),
2724 } else if (src_folder != NULL) {
2725 modest_mail_operation_xfer_folder (mail_op,
2735 g_object_unref (data);
2736 if (src_folder != NULL)
2737 g_object_unref (src_folder);
2738 if (folder_store != NULL)
2739 g_object_unref (folder_store);
2745 modest_ui_actions_on_select_all (GtkAction *action,
2746 ModestWindow *window)
2748 GtkWidget *focused_widget;
2750 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2751 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2752 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2753 } else if (GTK_IS_LABEL (focused_widget)) {
2754 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2755 } else if (GTK_IS_EDITABLE (focused_widget)) {
2756 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2757 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2758 GtkTextBuffer *buffer;
2759 GtkTextIter start, end;
2761 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2762 gtk_text_buffer_get_start_iter (buffer, &start);
2763 gtk_text_buffer_get_end_iter (buffer, &end);
2764 gtk_text_buffer_select_range (buffer, &start, &end);
2765 } else if (GTK_IS_HTML (focused_widget)) {
2766 gtk_html_select_all (GTK_HTML (focused_widget));
2767 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2768 GtkWidget *header_view = focused_widget;
2769 GtkTreeSelection *selection = NULL;
2771 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2772 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2773 MODEST_WIDGET_TYPE_HEADER_VIEW);
2775 /* Select all messages */
2776 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2777 gtk_tree_selection_select_all (selection);
2779 /* Set focuse on header view */
2780 gtk_widget_grab_focus (header_view);
2786 modest_ui_actions_on_mark_as_read (GtkAction *action,
2787 ModestWindow *window)
2789 g_return_if_fail (MODEST_IS_WINDOW(window));
2791 /* Mark each header as read */
2792 do_headers_action (window, headers_action_mark_as_read, NULL);
2796 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2797 ModestWindow *window)
2799 g_return_if_fail (MODEST_IS_WINDOW(window));
2801 /* Mark each header as read */
2802 do_headers_action (window, headers_action_mark_as_unread, NULL);
2806 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2807 GtkRadioAction *selected,
2808 ModestWindow *window)
2812 value = gtk_radio_action_get_current_value (selected);
2813 if (MODEST_IS_WINDOW (window)) {
2814 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2818 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2819 GtkRadioAction *selected,
2820 ModestWindow *window)
2822 TnyHeaderFlags flags;
2823 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2825 flags = gtk_radio_action_get_current_value (selected);
2826 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2829 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2830 GtkRadioAction *selected,
2831 ModestWindow *window)
2835 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2837 file_format = gtk_radio_action_get_current_value (selected);
2838 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2843 modest_ui_actions_on_zoom_plus (GtkAction *action,
2844 ModestWindow *window)
2846 g_return_if_fail (MODEST_IS_WINDOW (window));
2848 modest_window_zoom_plus (MODEST_WINDOW (window));
2852 modest_ui_actions_on_zoom_minus (GtkAction *action,
2853 ModestWindow *window)
2855 g_return_if_fail (MODEST_IS_WINDOW (window));
2857 modest_window_zoom_minus (MODEST_WINDOW (window));
2861 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2862 ModestWindow *window)
2864 ModestWindowMgr *mgr;
2865 gboolean fullscreen, active;
2866 g_return_if_fail (MODEST_IS_WINDOW (window));
2868 mgr = modest_runtime_get_window_mgr ();
2870 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2871 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2873 if (active != fullscreen) {
2874 modest_window_mgr_set_fullscreen_mode (mgr, active);
2875 gtk_window_present (GTK_WINDOW (window));
2880 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2881 ModestWindow *window)
2883 ModestWindowMgr *mgr;
2884 gboolean fullscreen;
2886 g_return_if_fail (MODEST_IS_WINDOW (window));
2888 mgr = modest_runtime_get_window_mgr ();
2889 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2890 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2892 gtk_window_present (GTK_WINDOW (window));
2896 * Used by modest_ui_actions_on_details to call do_headers_action
2899 headers_action_show_details (TnyHeader *header,
2900 ModestWindow *window,
2907 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2910 gtk_widget_show_all (dialog);
2911 gtk_dialog_run (GTK_DIALOG (dialog));
2913 gtk_widget_destroy (dialog);
2917 * Show the folder details in a ModestDetailsDialog widget
2920 show_folder_details (TnyFolder *folder,
2926 dialog = modest_details_dialog_new_with_folder (window, folder);
2929 gtk_widget_show_all (dialog);
2930 gtk_dialog_run (GTK_DIALOG (dialog));
2932 gtk_widget_destroy (dialog);
2936 * Show the header details in a ModestDetailsDialog widget
2939 modest_ui_actions_on_details (GtkAction *action,
2942 TnyList * headers_list;
2946 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2949 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2952 g_object_unref (msg);
2954 headers_list = get_selected_headers (win);
2958 iter = tny_list_create_iterator (headers_list);
2960 header = TNY_HEADER (tny_iterator_get_current (iter));
2961 headers_action_show_details (header, win, NULL);
2962 g_object_unref (header);
2964 g_object_unref (iter);
2965 g_object_unref (headers_list);
2967 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2968 GtkWidget *folder_view, *header_view;
2970 /* Check which widget has the focus */
2971 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2972 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2973 if (gtk_widget_is_focus (folder_view)) {
2974 TnyFolderStore *folder_store
2975 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2976 if (!folder_store) {
2977 g_warning ("%s: No item was selected.\n", __FUNCTION__);
2980 /* Show only when it's a folder */
2981 /* This function should not be called for account items,
2982 * because we dim the menu item for them. */
2983 if (TNY_IS_FOLDER (folder_store)) {
2984 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
2987 g_object_unref (folder_store);
2990 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2991 MODEST_WIDGET_TYPE_HEADER_VIEW);
2992 /* Show details of each header */
2993 do_headers_action (win, headers_action_show_details, header_view);
2999 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3000 ModestMsgEditWindow *window)
3002 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3004 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3008 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3009 ModestMsgEditWindow *window)
3011 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3013 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3017 modest_ui_actions_toggle_folders_view (GtkAction *action,
3018 ModestMainWindow *main_window)
3022 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3024 conf = modest_runtime_get_conf ();
3026 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
3027 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3029 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3033 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3034 ModestWindow *window)
3036 gboolean active, fullscreen = FALSE;
3037 ModestWindowMgr *mgr;
3039 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3041 /* Check if we want to toggle the toolbar vuew in fullscreen
3043 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3044 "ViewShowToolbarFullScreen")) {
3048 /* Toggle toolbar */
3049 mgr = modest_runtime_get_window_mgr ();
3050 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3054 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3055 ModestMsgEditWindow *window)
3057 modest_msg_edit_window_select_font (window);
3061 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3062 const gchar *display_name,
3065 /* Do not change the application name if the widget has not
3066 the focus. This callback could be called even if the folder
3067 view has not the focus, because the handled signal could be
3068 emitted when the folder view is redrawn */
3069 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3071 gtk_window_set_title (window, display_name);
3073 gtk_window_set_title (window, " ");
3078 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3080 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3081 modest_msg_edit_window_select_contacts (window);
3085 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3087 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3088 modest_msg_edit_window_check_names (window);
3093 create_move_to_dialog (ModestWindow *win,
3094 GtkWidget *folder_view,
3095 GtkWidget **tree_view)
3097 GtkWidget *dialog, *scroll;
3099 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3101 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3103 GTK_RESPONSE_ACCEPT,
3105 GTK_RESPONSE_REJECT,
3108 /* Create scrolled window */
3109 scroll = gtk_scrolled_window_new (NULL, NULL);
3110 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3111 GTK_POLICY_AUTOMATIC,
3112 GTK_POLICY_AUTOMATIC);
3114 /* Create folder view */
3115 *tree_view = modest_platform_create_folder_view (NULL);
3117 /* It could happen that we're trying to move a message from a
3118 window (msg window for example) after the main window was
3119 closed, so we can not just get the model of the folder
3121 if (MODEST_IS_FOLDER_VIEW (folder_view))
3122 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3123 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3125 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3126 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3128 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3130 /* Add scroll to dialog */
3131 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3132 scroll, FALSE, FALSE, 0);
3134 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3136 /* Select INBOX or local account */
3137 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (*tree_view));
3143 * Returns TRUE if at least one of the headers of the list belongs to
3144 * a message that has been fully retrieved.
3147 has_retrieved_msgs (TnyList *list)
3150 gboolean found = FALSE;
3152 iter = tny_list_create_iterator (list);
3153 while (tny_iterator_is_done (iter) && !found) {
3155 TnyHeaderFlags flags;
3157 header = TNY_HEADER (tny_iterator_get_current (iter));
3158 flags = tny_header_get_flags (header);
3159 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
3163 tny_iterator_next (iter);
3165 g_object_unref (iter);
3171 * Shows a confirmation dialog to the user when we're moving messages
3172 * from a remote server to the local storage. Returns the dialog
3173 * response. If it's other kind of movement the it always returns
3177 msgs_move_to_confirmation (GtkWindow *win,
3178 TnyFolder *dest_folder,
3181 gint response = GTK_RESPONSE_OK;
3183 /* If the destination is a local folder */
3184 if (modest_tny_folder_is_local_folder (dest_folder)) {
3185 TnyFolder *src_folder;
3189 /* Get source folder */
3190 iter = tny_list_create_iterator (headers);
3191 header = TNY_HEADER (tny_iterator_get_current (iter));
3192 src_folder = tny_header_get_folder (header);
3193 g_object_unref (header);
3194 g_object_unref (iter);
3196 /* if no src_folder, message may be an attahcment */
3197 if (src_folder == NULL)
3198 return GTK_RESPONSE_CANCEL;
3200 /* If the source is a remote folder */
3201 if (!modest_tny_folder_is_local_folder (src_folder)) {
3202 const gchar *message;
3204 if (has_retrieved_msgs (headers))
3205 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3206 tny_list_get_length (headers));
3208 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3209 tny_list_get_length (headers));
3211 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3212 (const gchar *) message);
3214 g_object_unref (src_folder);
3222 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3224 ModestMsgViewWindow *self = NULL;
3225 gboolean last, first;
3227 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3228 self = MODEST_MSG_VIEW_WINDOW (object);
3230 last = modest_msg_view_window_last_message_selected (self);
3231 first = modest_msg_view_window_first_message_selected (self);
3233 /* No more messages to view, so close this window */
3234 /* gboolean ret_value; */
3235 /* g_signal_emit_by_name (G_OBJECT (self), "delete-event", NULL, &ret_value); */
3236 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3238 modest_msg_view_window_select_previous_message (self);
3240 modest_msg_view_window_select_next_message (self);
3244 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3247 GObject *win = modest_mail_operation_get_source (mail_op);
3248 const GError *error = NULL;
3249 const gchar *message = NULL;
3251 /* Get error message */
3252 error = modest_mail_operation_get_error (mail_op);
3253 if (error != NULL && error->message != NULL) {
3254 message = error->message;
3256 message = _("mail_in_ui_folder_move_target_error");
3259 /* Show notification dialog */
3260 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3261 g_object_unref (win);
3265 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3268 GObject *win = modest_mail_operation_get_source (mail_op);
3269 const GError *error = modest_mail_operation_get_error (mail_op);
3271 g_return_if_fail (error != NULL);
3272 if (error->message != NULL)
3273 g_printerr ("modest: %s\n", error->message);
3275 g_printerr ("modest: unkonw error on send&receive operation");
3277 /* Show error message */
3278 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3279 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3280 /* _CS("sfil_ib_unable_to_receive")); */
3282 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3283 /* _CS("sfil_ib_unable_to_send")); */
3284 g_object_unref (win);
3288 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3295 gint pending_purges = 0;
3296 gboolean some_purged = FALSE;
3297 ModestWindow *win = MODEST_WINDOW (user_data);
3299 /* If there was any error */
3300 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
3303 /* Once the message has been retrieved for purging, we check if
3304 * it's all ok for purging */
3306 parts = tny_simple_list_new ();
3307 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3308 iter = tny_list_create_iterator (parts);
3310 while (!tny_iterator_is_done (iter)) {
3312 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3313 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)) {
3314 if (tny_mime_part_is_purged (part))
3319 tny_iterator_next (iter);
3322 if (pending_purges>0) {
3324 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3326 if (response == GTK_RESPONSE_OK) {
3327 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3328 tny_iterator_first (iter);
3329 while (!tny_iterator_is_done (iter)) {
3332 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3333 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))
3334 tny_mime_part_set_purged (part);
3335 tny_iterator_next (iter);
3338 tny_msg_rewrite_cache (msg);
3341 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3344 /* remove attachments */
3345 tny_iterator_first (iter);
3346 while (!tny_iterator_is_done (iter)) {
3349 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3350 g_object_unref (part);
3351 tny_iterator_next (iter);
3354 g_object_unref (iter);
3355 g_object_unref (parts);
3359 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3360 ModestMainWindow *win)
3362 GtkWidget *header_view;
3363 TnyList *header_list;
3366 TnyHeaderFlags flags;
3367 ModestWindow *msg_view_window = NULL;
3370 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3372 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3373 MODEST_WIDGET_TYPE_HEADER_VIEW);
3375 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3377 if (tny_list_get_length (header_list) == 1) {
3378 iter = tny_list_create_iterator (header_list);
3379 header = TNY_HEADER (tny_iterator_get_current (iter));
3380 g_object_unref (iter);
3385 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3386 header, &msg_view_window);
3387 flags = tny_header_get_flags (header);
3388 if (!(flags & TNY_HEADER_FLAG_CACHED))
3391 if (msg_view_window != NULL)
3392 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3394 /* do nothing; uid was registered before, so window is probably on it's way */
3395 g_warning ("debug: header %p has already been registered", header);
3398 ModestMailOperation *mail_op = NULL;
3399 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3400 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3402 modest_ui_actions_get_msgs_full_error_handler,
3404 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3405 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3407 g_object_unref (mail_op);
3410 g_object_unref (header);
3412 g_object_unref (header_list);
3416 * UI handler for the "Move to" action when invoked from the
3420 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3421 ModestMainWindow *win)
3423 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3424 GtkWidget *header_view = NULL;
3426 TnyFolderStore *folder_store = NULL;
3427 ModestMailOperation *mail_op = NULL;
3429 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3431 /* Get the folder view */
3432 folder_view = modest_main_window_get_child_widget (win,
3433 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3435 TnyFolderStore *src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3437 /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3438 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win), src_folder)) {
3440 g_object_unref (src_folder);
3446 /* Get header view */
3447 header_view = modest_main_window_get_child_widget (win,
3448 MODEST_WIDGET_TYPE_HEADER_VIEW);
3450 /* Create and run the dialog */
3451 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
3452 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3453 result = gtk_dialog_run (GTK_DIALOG(dialog));
3454 g_object_ref (tree_view);
3456 /* We do this to save an indentation level ;-) */
3457 if (result != GTK_RESPONSE_ACCEPT)
3460 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3462 if (TNY_IS_ACCOUNT (folder_store) &&
3463 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (folder_store))
3466 /* Offer the connection dialog if necessary: */
3467 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win), folder_store)) {
3471 /* Get folder or messages to transfer */
3472 if (gtk_widget_is_focus (folder_view)) {
3474 /* Clean folder on header view before moving it */
3475 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3477 if (TNY_IS_FOLDER (src_folder)) {
3479 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3481 modest_ui_actions_move_folder_error_handler,
3483 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3485 modest_mail_operation_xfer_folder (mail_op,
3486 TNY_FOLDER (src_folder),
3489 /* Unref mail operation */
3490 g_object_unref (G_OBJECT (mail_op));
3492 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3495 if (gtk_widget_is_focus (header_view)) {
3496 TnyList *headers = NULL;
3499 /* TODO: Check for connection if the headers are on a network account. */
3500 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3502 /* Ask for user confirmation */
3503 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3504 TNY_FOLDER (folder_store),
3507 /* Transfer messages */
3508 if (response == GTK_RESPONSE_OK) {
3510 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3512 modest_ui_actions_move_folder_error_handler,
3514 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3517 modest_mail_operation_xfer_msgs (mail_op,
3519 TNY_FOLDER (folder_store),
3524 g_object_unref (G_OBJECT (mail_op));
3526 g_object_unref (headers);
3532 g_object_unref (src_folder);
3535 g_object_unref (folder_store);
3537 gtk_widget_destroy (dialog);
3542 * UI handler for the "Move to" action when invoked from the
3543 * ModestMsgViewWindow
3546 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3547 ModestMsgViewWindow *win)
3549 GtkWidget *dialog, *folder_view, *tree_view = NULL;
3551 ModestMainWindow *main_window = NULL;
3552 TnyHeader *header = NULL;
3553 TnyList *headers = NULL;
3555 /* Get the folder view */
3556 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3558 folder_view = modest_main_window_get_child_widget (main_window,
3559 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3563 /* Create and run the dialog */
3564 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
3565 result = gtk_dialog_run (GTK_DIALOG(dialog));
3567 if (result == GTK_RESPONSE_ACCEPT) {
3568 TnyFolderStore *folder_store;
3571 /* Create header list */
3572 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3573 g_return_if_fail (header != NULL);
3575 /* Offer the connection dialog if necessary: */
3576 /* TODO: What's the extra g_object_ref() for? Isn't this leaking a ref? */
3577 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (g_object_ref (tree_view)));
3578 TnyFolder *header_folder = tny_header_get_folder(header);
3579 if (modest_platform_connect_and_wait_if_network_folderstore (NULL, folder_store) &&
3580 modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (header_folder))) {
3582 headers = tny_simple_list_new ();
3583 tny_list_prepend (headers, G_OBJECT (header));
3584 g_object_unref (header);
3586 /* Ask user for confirmation. MSG-NOT404 */
3587 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3588 TNY_FOLDER (folder_store),
3591 /* Transfer current msg */
3592 if (response == GTK_RESPONSE_OK) {
3593 ModestMailOperation *mail_op;
3595 /* Create mail op */
3596 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
3597 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3600 /* Transfer messages */
3601 modest_mail_operation_xfer_msgs (mail_op,
3603 TNY_FOLDER (folder_store),
3605 transfer_msgs_from_viewer_cb,
3607 g_object_unref (G_OBJECT (mail_op));
3612 g_object_unref (header_folder);
3615 g_object_unref (headers);
3618 g_object_unref (folder_store);
3621 gtk_widget_destroy (dialog);
3625 modest_ui_actions_on_move_to (GtkAction *action,
3628 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3629 MODEST_IS_MSG_VIEW_WINDOW (win));
3631 if (MODEST_IS_MAIN_WINDOW (win))
3632 modest_ui_actions_on_main_window_move_to (action,
3633 MODEST_MAIN_WINDOW (win));
3635 modest_ui_actions_on_msg_view_window_move_to (action,
3636 MODEST_MSG_VIEW_WINDOW (win));
3640 * Calls #HeadersFunc for each header already selected in the main
3641 * window or the message currently being shown in the msg view window
3644 do_headers_action (ModestWindow *win,
3648 TnyList *headers_list;
3654 headers_list = get_selected_headers (win);
3658 /* Get the folder */
3659 iter = tny_list_create_iterator (headers_list);
3660 header = TNY_HEADER (tny_iterator_get_current (iter));
3661 folder = tny_header_get_folder (header);
3662 g_object_unref (header);
3664 /* Call the function for each header */
3665 while (!tny_iterator_is_done (iter)) {
3666 header = TNY_HEADER (tny_iterator_get_current (iter));
3667 func (header, win, user_data);
3668 g_object_unref (header);
3669 tny_iterator_next (iter);
3672 /* Trick: do a poke status in order to speed up the signaling
3674 tny_folder_poke_status (folder);
3677 g_object_unref (folder);
3678 g_object_unref (iter);
3679 g_object_unref (headers_list);
3683 modest_ui_actions_view_attachment (GtkAction *action,
3684 ModestWindow *window)
3686 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3687 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3689 /* not supported window for this action */
3690 g_return_if_reached ();
3695 modest_ui_actions_save_attachments (GtkAction *action,
3696 ModestWindow *window)
3698 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3699 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3701 /* not supported window for this action */
3702 g_return_if_reached ();
3707 modest_ui_actions_remove_attachments (GtkAction *action,
3708 ModestWindow *window)
3710 if (MODEST_IS_MAIN_WINDOW (window)) {
3711 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
3712 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3713 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
3715 /* not supported window for this action */
3716 g_return_if_reached ();
3721 modest_ui_actions_on_settings (GtkAction *action,
3726 dialog = modest_platform_get_global_settings_dialog ();
3727 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3728 gtk_widget_show_all (dialog);
3730 gtk_dialog_run (GTK_DIALOG (dialog));
3732 gtk_widget_destroy (dialog);
3736 modest_ui_actions_on_help (GtkAction *action,
3739 const gchar *help_id = NULL;
3741 if (MODEST_IS_MAIN_WINDOW (win)) {
3742 const gchar *action_name;
3743 action_name = gtk_action_get_name (action);
3745 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3746 !strcmp (action_name, "HeaderViewCSMHelp")) {
3747 GtkWidget *folder_view;
3748 TnyFolderStore *folder_store;
3749 /* Get selected folder */
3750 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3751 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3752 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3754 /* Switch help_id */
3755 if (TNY_IS_FOLDER (folder_store)) {
3756 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
3757 case TNY_FOLDER_TYPE_NORMAL:
3758 help_id = "applications_email_userfolder";
3760 case TNY_FOLDER_TYPE_INBOX:
3761 help_id = "applications_email_inbox";
3763 case TNY_FOLDER_TYPE_OUTBOX:
3764 help_id = "applications_email_outbox";
3766 case TNY_FOLDER_TYPE_SENT:
3767 help_id = "applications_email_sent";
3769 case TNY_FOLDER_TYPE_DRAFTS:
3770 help_id = "applications_email_drafts";
3772 case TNY_FOLDER_TYPE_ARCHIVE:
3773 help_id = "applications_email_archive";
3776 help_id = "applications_email_mainview";
3779 help_id = "applications_email_mainview";
3781 g_object_unref (folder_store);
3783 help_id = "applications_email_mainview";
3785 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3786 help_id = "applications_email_viewer";
3787 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3788 help_id = "applications_email_editor";
3790 modest_platform_show_help (GTK_WINDOW (win), help_id);
3794 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3795 ModestWindow *window)
3797 ModestMailOperation *mail_op;
3801 headers = get_selected_headers (window);
3805 /* Create mail operation */
3806 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3808 modest_ui_actions_get_msgs_full_error_handler,
3810 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3811 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3814 g_object_unref (headers);
3815 g_object_unref (mail_op);
3819 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3820 ModestWindow *window)
3822 g_return_if_fail (MODEST_IS_WINDOW (window));
3825 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3829 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3830 ModestWindow *window)
3832 g_return_if_fail (MODEST_IS_WINDOW (window));
3835 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3839 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3840 ModestWindow *window)
3842 g_return_if_fail (MODEST_IS_WINDOW (window));
3845 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3849 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3850 ModestWindow *window)
3852 g_return_if_fail (MODEST_IS_WINDOW (window));
3855 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3859 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3860 ModestWindow *window)
3862 g_return_if_fail (MODEST_IS_WINDOW (window));
3865 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3869 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3870 ModestWindow *window)
3872 g_return_if_fail (MODEST_IS_WINDOW (window));
3875 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3879 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3880 ModestWindow *window)
3882 g_return_if_fail (MODEST_IS_WINDOW (window));
3885 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3889 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3890 ModestWindow *window)
3892 g_return_if_fail (MODEST_IS_WINDOW (window));
3895 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3899 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3901 g_return_if_fail (MODEST_IS_WINDOW (window));
3904 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3908 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3910 g_return_if_fail (MODEST_IS_WINDOW (window));
3912 modest_platform_show_search_messages (GTK_WINDOW (window));
3916 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3918 g_return_if_fail (MODEST_IS_WINDOW (win));
3919 modest_platform_show_addressbook (GTK_WINDOW (win));
3924 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3925 ModestWindow *window)
3927 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3929 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3933 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3934 ModestMailOperationState *state,
3937 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3939 /* Set send/receive operation finished */
3940 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3941 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));