1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #endif /*HAVE_CONFIG_H*/
34 #include <glib/gi18n.h>
35 #include <glib/gprintf.h>
37 #include <modest-runtime.h>
38 #include <modest-tny-folder.h>
39 #include <modest-tny-msg.h>
40 #include <modest-tny-account.h>
41 #include <modest-address-book.h>
42 #include "modest-error.h"
43 #include "modest-ui-actions.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
47 #include <tny-mime-part.h>
49 #ifdef MODEST_PLATFORM_MAEMO
50 #include "maemo/modest-osso-state-saving.h"
51 #include "maemo/modest-maemo-utils.h"
52 #endif /* MODEST_PLATFORM_MAEMO */
54 #include "widgets/modest-ui-constants.h"
55 #include <widgets/modest-main-window.h>
56 #include <widgets/modest-msg-view-window.h>
57 #include <widgets/modest-account-view-window.h>
58 #include <widgets/modest-details-dialog.h>
59 #include <widgets/modest-attachments-view.h>
60 #include "widgets/modest-folder-view.h"
61 #include "widgets/modest-global-settings-dialog.h"
62 #include "modest-connection-specific-smtp-window.h"
63 #include "modest-account-mgr-helpers.h"
64 #include "modest-mail-operation.h"
65 #include "modest-text-utils.h"
67 #ifdef MODEST_HAVE_EASYSETUP
68 #include "easysetup/modest-easysetup-wizard.h"
69 #endif /* MODEST_HAVE_EASYSETUP */
71 #include <modest-widget-memory.h>
72 #include <tny-error.h>
73 #include <tny-simple-list.h>
74 #include <tny-msg-view.h>
75 #include <tny-device.h>
76 #include <tny-merge-folder.h>
78 #include <gtkhtml/gtkhtml.h>
80 typedef struct _GetMsgAsyncHelper {
82 ModestMailOperation *mail_op;
89 typedef enum _ReplyForwardAction {
95 typedef struct _ReplyForwardHelper {
96 guint reply_forward_type;
97 ReplyForwardAction action;
99 GtkWidget *parent_window;
100 } ReplyForwardHelper;
104 * The do_headers_action uses this kind of functions to perform some
105 * action to each member of a list of headers
107 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
109 static void do_headers_action (ModestWindow *win,
113 static void open_msg_cb (ModestMailOperation *mail_op,
118 static void reply_forward_cb (ModestMailOperation *mail_op,
123 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
125 static void folder_refreshed_cb (ModestMailOperation *mail_op,
129 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
130 ModestMailOperationState *state,
136 run_account_setup_wizard (ModestWindow *win)
138 ModestEasysetupWizardDialog *wizard;
140 g_return_if_fail (MODEST_IS_WINDOW(win));
142 wizard = modest_easysetup_wizard_dialog_new ();
143 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
144 gtk_dialog_run (GTK_DIALOG (wizard));
145 gtk_widget_destroy (GTK_WIDGET (wizard));
150 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
153 const gchar *authors[] = {
154 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
157 about = gtk_about_dialog_new ();
158 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
159 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
160 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
161 _("Copyright (c) 2006, Nokia Corporation\n"
162 "All rights reserved."));
163 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
164 _("a modest e-mail client\n\n"
165 "design and implementation: Dirk-Jan C. Binnema\n"
166 "contributions from the fine people at KC and Ig\n"
167 "uses the tinymail email framework written by Philip van Hoof"));
168 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
169 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
171 gtk_dialog_run (GTK_DIALOG (about));
172 gtk_widget_destroy(about);
176 * Gets the list of currently selected messages. If the win is the
177 * main window, then it returns a newly allocated list of the headers
178 * selected in the header view. If win is the msg view window, then
179 * the value returned is a list with just a single header.
181 * The caller of this funcion must free the list.
184 get_selected_headers (ModestWindow *win)
186 if (MODEST_IS_MAIN_WINDOW(win)) {
187 GtkWidget *header_view;
189 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
190 MODEST_WIDGET_TYPE_HEADER_VIEW);
191 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
193 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
194 /* for MsgViewWindows, we simply return a list with one element */
196 TnyList *list = NULL;
198 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
199 if (header != NULL) {
200 list = tny_simple_list_new ();
201 tny_list_prepend (list, G_OBJECT(header));
202 g_object_unref (G_OBJECT(header));
212 headers_action_mark_as_read (TnyHeader *header,
216 TnyHeaderFlags flags;
218 g_return_if_fail (TNY_IS_HEADER(header));
220 flags = tny_header_get_flags (header);
221 if (flags & TNY_HEADER_FLAG_SEEN) return;
222 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
226 headers_action_mark_as_unread (TnyHeader *header,
230 TnyHeaderFlags flags;
232 g_return_if_fail (TNY_IS_HEADER(header));
234 flags = tny_header_get_flags (header);
235 if (flags & TNY_HEADER_FLAG_SEEN) {
236 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
242 headers_action_delete (TnyHeader *header,
246 ModestMailOperation *mail_op = NULL;
248 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
249 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
252 /* Always delete. TODO: Move to trash still not supported */
253 modest_mail_operation_remove_msg (mail_op, header, FALSE);
254 g_object_unref (G_OBJECT (mail_op));
256 /* refilter treemodel to hide marked-as-deleted rows */
257 /* if (MODEST_IS_HEADER_VIEW (user_data)) */
258 /* modest_header_view_refilter (MODEST_HEADER_VIEW (user_data)); */
261 /** After deleing a message that is currently visible in a window,
262 * show the next message from the list, or close the window if there are no more messages.
264 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
266 /* Close msg view window or select next */
267 if (modest_msg_view_window_last_message_selected (win) &&
268 modest_msg_view_window_first_message_selected (win)) {
269 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
271 modest_msg_view_window_select_next_message (win);
276 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
278 TnyList *header_list = NULL;
279 TnyIterator *iter = NULL;
280 TnyHeader *header = NULL;
281 gchar *message = NULL;
284 ModestWindowMgr *mgr;
285 GtkWidget *header_view = NULL;
287 g_return_if_fail (MODEST_IS_WINDOW(win));
289 /* Check first if the header view has the focus */
290 if (MODEST_IS_MAIN_WINDOW (win)) {
292 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
293 MODEST_WIDGET_TYPE_HEADER_VIEW);
294 if (!gtk_widget_is_focus (header_view))
298 header_list = get_selected_headers (win);
299 if (!header_list) return;
301 /* Check if any of the headers are already opened, or in the process of being opened */
302 if (MODEST_IS_MAIN_WINDOW (win)) {
304 iter = tny_list_create_iterator (header_list);
306 mgr = modest_runtime_get_window_mgr ();
307 while (!tny_iterator_is_done (iter) && !found) {
308 header = TNY_HEADER (tny_iterator_get_current (iter));
309 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
310 g_object_unref (header);
311 tny_iterator_next (iter);
313 g_object_unref (iter);
318 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
319 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
321 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
325 g_object_unref (header_list);
331 if (tny_list_get_length(header_list) == 1) {
332 iter = tny_list_create_iterator (header_list);
333 header = TNY_HEADER (tny_iterator_get_current (iter));
334 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
335 g_object_unref (header);
336 g_object_unref (iter);
338 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
339 tny_list_get_length(header_list)), desc);
341 /* Confirmation dialog */
342 printf("DEBUG: %s\n", __FUNCTION__);
343 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
347 if (response == GTK_RESPONSE_OK) {
348 ModestWindow *main_window = NULL;
349 ModestWindowMgr *mgr = NULL;
350 GtkTreeModel *model = NULL;
351 GtkTreeSelection *sel = NULL;
352 GList *sel_list = NULL, *tmp = NULL;
353 GtkTreeRowReference *row_reference = NULL;
354 GtkTreePath *next_path = NULL;
356 /* Find last selected row */
357 if (MODEST_IS_MAIN_WINDOW (win)) {
358 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
359 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
360 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
361 for (tmp=sel_list; tmp; tmp=tmp->next) {
362 if (tmp->next == NULL) {
363 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
364 gtk_tree_path_next (next_path);
365 row_reference = gtk_tree_row_reference_new (model, next_path);
366 gtk_tree_path_free (next_path);
371 /* Remove each header. If it's a view window header_view == NULL */
372 do_headers_action (win, headers_action_delete, header_view);
374 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
375 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
377 /* Get main window */
378 mgr = modest_runtime_get_window_mgr ();
379 main_window = modest_window_mgr_get_main_window (mgr);
382 /* Move cursor to next row */
385 /* Select next row */
386 if (gtk_tree_row_reference_valid (row_reference)) {
387 next_path = gtk_tree_row_reference_get_path (row_reference);
388 gtk_tree_selection_select_path (sel, next_path);
389 gtk_tree_path_free (next_path);
391 if (row_reference != NULL)
392 gtk_tree_row_reference_free (row_reference);
395 /* Update toolbar dimming state */
396 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
399 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
400 g_list_free (sel_list);
406 g_object_unref (header_list);
412 /* delete either message or folder, based on where we are */
414 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
416 g_return_if_fail (MODEST_IS_WINDOW(win));
418 /* Check first if the header view has the focus */
419 if (MODEST_IS_MAIN_WINDOW (win)) {
421 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
422 MODEST_WIDGET_TYPE_FOLDER_VIEW);
423 if (gtk_widget_is_focus (w)) {
424 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
428 modest_ui_actions_on_delete_message (action, win);
434 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
436 #ifdef MODEST_PLATFORM_MAEMO
437 modest_osso_save_state();
438 #endif /* MODEST_PLATFORM_MAEMO */
440 g_debug ("closing down, clearing %d item(s) from operation queue",
441 modest_mail_operation_queue_num_elements
442 (modest_runtime_get_mail_operation_queue()));
444 /* cancel all outstanding operations */
445 modest_mail_operation_queue_cancel_all
446 (modest_runtime_get_mail_operation_queue());
448 g_debug ("queue has been cleared");
450 /* note: when modest-tny-account-store is finalized,
451 it will automatically set all network connections
458 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
461 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
463 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
464 /* gtk_widget_destroy (GTK_WIDGET (win)); */
465 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
466 /* gboolean ret_value; */
467 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
468 /* } else if (MODEST_IS_WINDOW (win)) { */
469 /* gtk_widget_destroy (GTK_WIDGET (win)); */
471 /* g_return_if_reached (); */
476 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
478 GtkClipboard *clipboard = NULL;
479 gchar *selection = NULL;
481 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
482 selection = gtk_clipboard_wait_for_text (clipboard);
484 /* Question: why is the clipboard being used here?
485 * It doesn't really make a lot of sense. */
489 modest_address_book_add_address (selection);
495 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
497 /* This is currently only implemented for Maemo */
498 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
499 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
500 run_account_setup_wizard (win);
503 /* Show the list of accounts: */
504 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
505 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
508 GtkWidget *dialog, *label;
510 /* Create the widgets */
512 dialog = gtk_dialog_new_with_buttons ("Message",
514 GTK_DIALOG_DESTROY_WITH_PARENT,
518 label = gtk_label_new ("Hello World!");
520 /* Ensure that the dialog box is destroyed when the user responds. */
522 g_signal_connect_swapped (dialog, "response",
523 G_CALLBACK (gtk_widget_destroy),
526 /* Add the label, and show everything we've added to the dialog. */
528 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
530 gtk_widget_show_all (dialog);
531 #endif /* MODEST_PLATFORM_MAEMO */
535 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
537 ModestWindow *main_window = MODEST_WINDOW (user_data);
539 /* Save any changes. */
540 modest_connection_specific_smtp_window_save_server_accounts (
541 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
542 modest_window_get_active_account (main_window));
543 gtk_widget_destroy (GTK_WIDGET (window));
549 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
551 /* This is currently only implemented for Maemo,
552 * because it requires an API (libconic) to detect different connection
555 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
557 /* Create the window if necessary: */
558 const gchar *active_account_name = modest_window_get_active_account (win);
560 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
561 * or show the default account?
562 * If we show the default account then the account name should be shown in
563 * the window when we show it. */
564 if (!active_account_name) {
565 g_warning ("%s: No account is active.", __FUNCTION__);
569 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
570 modest_connection_specific_smtp_window_fill_with_connections (
571 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
572 modest_runtime_get_account_mgr(),
573 active_account_name);
575 /* Show the window: */
576 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
577 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
578 gtk_widget_show (specific_window);
580 /* Save changes when the window is hidden: */
581 g_signal_connect (specific_window, "hide",
582 G_CALLBACK (on_smtp_servers_window_hide), win);
583 #endif /* MODEST_PLATFORM_MAEMO */
587 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
589 ModestWindow *msg_win = NULL;
591 TnyFolder *folder = NULL;
592 gchar *account_name = NULL;
593 gchar *from_str = NULL;
594 /* GError *err = NULL; */
595 TnyAccount *account = NULL;
596 ModestWindowMgr *mgr;
597 gchar *signature = NULL, *blank_and_signature = NULL;
599 /* if there are no accounts yet, just show the wizard */
600 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
601 run_account_setup_wizard (win);
605 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
607 account_name = g_strdup (modest_window_get_active_account (win));
609 g_printerr ("modest: no account found\n");
613 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
615 TNY_ACCOUNT_TYPE_STORE);
617 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
621 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
623 g_printerr ("modest: failed get from string for '%s'\n", account_name);
627 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
628 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
629 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
630 MODEST_ACCOUNT_SIGNATURE, FALSE);
631 blank_and_signature = g_strconcat ("\n", signature, NULL);
634 blank_and_signature = g_strdup ("");
637 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
639 g_printerr ("modest: failed to create new msg\n");
643 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
645 g_printerr ("modest: failed to find Drafts folder\n");
650 /* Create and register edit window */
651 /* This is destroyed by TOOD. */
652 msg_win = modest_msg_edit_window_new (msg, account_name);
653 mgr = modest_runtime_get_window_mgr ();
654 modest_window_mgr_register_window (mgr, msg_win);
657 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
659 gtk_widget_show_all (GTK_WIDGET (msg_win));
662 g_free (account_name);
664 g_free (blank_and_signature);
666 g_object_unref (msg_win);
668 g_object_unref (G_OBJECT(account));
670 g_object_unref (G_OBJECT(msg));
672 g_object_unref (G_OBJECT(folder));
676 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
680 ModestMailOperationStatus status;
682 /* If there is no message or the operation was not successful */
683 status = modest_mail_operation_get_status (mail_op);
684 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
686 /* Remove the header from the preregistered uids */
687 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
697 open_msg_cb (ModestMailOperation *mail_op,
702 ModestWindowMgr *mgr = NULL;
703 ModestWindow *parent_win = NULL;
704 ModestWindow *win = NULL;
705 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
706 gchar *account = NULL;
709 /* Do nothing if there was any problem with the mail
710 operation. The error will be shown by the error_handler of
711 the mail operation */
712 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
716 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
717 folder = tny_header_get_folder (header);
719 /* Mark header as read */
720 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
723 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
725 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
727 /* Gets folder type (OUTBOX headers will be opened in edit window */
728 if (modest_tny_folder_is_local_folder (folder))
729 folder_type = modest_tny_folder_get_local_folder_type (folder);
731 /* If the header is in the drafts folder then open the editor,
732 else the message view window */
733 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
734 /* we cannot edit without a valid account... */
735 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
736 run_account_setup_wizard(parent_win);
739 win = modest_msg_edit_window_new (msg, account);
741 gchar *uid = modest_tny_folder_get_header_unique_id (header);
743 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
744 GtkWidget *header_view;
745 GtkTreeSelection *sel;
746 GList *sel_list = NULL;
749 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
750 MODEST_WIDGET_TYPE_HEADER_VIEW);
752 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
753 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
755 if (sel_list != NULL) {
756 GtkTreeRowReference *row_reference;
758 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
759 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
760 g_list_free (sel_list);
762 win = modest_msg_view_window_new_with_header_model (msg,
767 gtk_tree_row_reference_free (row_reference);
769 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
772 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
777 /* Register and show new window */
779 mgr = modest_runtime_get_window_mgr ();
780 modest_window_mgr_register_window (mgr, win);
781 g_object_unref (win);
782 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
783 gtk_widget_show_all (GTK_WIDGET(win));
786 /* Update toolbar dimming state */
787 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
788 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
794 g_object_unref (parent_win);
795 g_object_unref (folder);
799 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
803 GObject *win = modest_mail_operation_get_source (mail_op);
805 error = modest_mail_operation_get_error (mail_op);
806 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
808 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
810 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
813 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
814 _("mail_ni_ui_folder_get_msg_folder_error"));
818 g_object_unref (win);
822 * This function is used by both modest_ui_actions_on_open and
823 * modest_ui_actions_on_header_activated. This way we always do the
824 * same when trying to open messages.
827 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
829 ModestWindowMgr *mgr = NULL;
830 TnyIterator *iter = NULL;
831 ModestMailOperation *mail_op1 = NULL;
832 ModestMailOperation *mail_op2 = NULL;
833 TnyList *not_opened_headers = NULL;
834 TnyList *not_opened_cached_headers = NULL;
835 TnyHeaderFlags flags;
837 /* Look if we already have a message view for each header. If
838 true, then remove the header from the list of headers to
840 mgr = modest_runtime_get_window_mgr ();
841 iter = tny_list_create_iterator (headers);
842 not_opened_headers = tny_simple_list_new ();
843 not_opened_cached_headers = tny_simple_list_new ();
844 while (!tny_iterator_is_done (iter)) {
846 ModestWindow *window;
850 header = TNY_HEADER (tny_iterator_get_current (iter));
851 flags = tny_header_get_flags (header);
854 found = modest_window_mgr_find_registered_header (mgr, header, &window);
856 /* Do not open again the message and present the
857 window to the user */
860 gtk_window_present (GTK_WINDOW (window));
862 /* the header has been registered already, we don't do
863 * anything but wait for the window to come up*/
864 g_warning ("debug: header %p already registered, waiting for window",
867 if (!(flags & TNY_HEADER_FLAG_CACHED))
868 tny_list_append (not_opened_headers, G_OBJECT (header));
869 /* Check if msg has already been retreived */
871 tny_list_append (not_opened_cached_headers, G_OBJECT (header));
873 g_object_unref (header);
874 tny_iterator_next (iter);
876 g_object_unref (iter);
879 /* If some messages would have to be downloaded, ask the user to
880 * make a connection. It's generally easier to do this here (in the mainloop)
881 * than later in a thread:
883 if (tny_list_get_length (not_opened_cached_headers) > 0) {
884 gboolean connected = modest_platform_connect_and_wait (GTK_WINDOW (win));
886 /* Don't go further if a connection would be necessary but none is available: */
888 g_object_unref (not_opened_headers);
889 g_object_unref (not_opened_cached_headers);
894 /* Register the headers before actually creating the windows: */
895 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
896 while (!tny_iterator_is_done (iter_not_opened)) {
897 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
898 modest_window_mgr_register_header (mgr, header);
899 g_object_unref (header);
901 tny_iterator_next (iter_not_opened);
903 g_object_unref (iter_not_opened);
904 iter_not_opened = NULL;
906 TnyIterator *iter_cached = tny_list_create_iterator (not_opened_cached_headers);
907 while (!tny_iterator_is_done (iter_cached)) {
908 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_cached));
909 modest_window_mgr_register_header (mgr, header);
910 g_object_unref (header);
912 tny_iterator_next (iter_cached);
914 g_object_unref (iter_cached);
918 /* Open each uncached message */
919 if (tny_list_get_length (not_opened_headers) > 0) {
920 mail_op1 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
922 modest_ui_actions_get_msgs_full_error_handler,
924 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op1);
925 if (tny_list_get_length (not_opened_headers) > 1) {
926 modest_mail_operation_get_msgs_full (mail_op1,
932 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
933 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
934 modest_mail_operation_get_msg (mail_op1, header, open_msg_cb, NULL);
935 g_object_unref (header);
936 g_object_unref (iter);
940 /* Open each cached message */
941 if (tny_list_get_length (not_opened_cached_headers) > 0) {
942 mail_op2 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
944 modest_ui_actions_get_msgs_full_error_handler,
946 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op2);
947 if (tny_list_get_length (not_opened_cached_headers) > 1) {
948 modest_mail_operation_get_msgs_full (mail_op2,
954 TnyIterator *iter = tny_list_create_iterator (not_opened_cached_headers);
955 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
956 modest_mail_operation_get_msg (mail_op2, header, open_msg_cb, NULL);
957 g_object_unref (header);
958 g_object_unref (iter);
963 if (not_opened_headers != NULL)
964 g_object_unref (not_opened_headers);
965 if (not_opened_cached_headers != NULL)
966 g_object_unref (not_opened_cached_headers);
968 g_object_unref (iter);
969 if (mail_op1 != NULL)
970 g_object_unref (mail_op1);
971 if (mail_op2 != NULL)
972 g_object_unref (mail_op2);
976 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
981 headers = get_selected_headers (win);
986 _modest_ui_actions_open (headers, win);
988 g_object_unref(headers);
993 free_reply_forward_helper (gpointer data)
995 ReplyForwardHelper *helper;
997 helper = (ReplyForwardHelper *) data;
998 g_free (helper->account_name);
999 g_slice_free (ReplyForwardHelper, helper);
1003 reply_forward_cb (ModestMailOperation *mail_op,
1009 ReplyForwardHelper *rf_helper;
1010 ModestWindow *msg_win = NULL;
1011 ModestEditType edit_type;
1013 TnyAccount *account = NULL;
1014 ModestWindowMgr *mgr = NULL;
1015 gchar *signature = NULL;
1017 /* If there was any error. The mail operation could be NULL,
1018 this means that we already have the message downloaded and
1019 that we didn't do a mail operation to retrieve it */
1020 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1023 g_return_if_fail (user_data != NULL);
1024 rf_helper = (ReplyForwardHelper *) user_data;
1026 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1027 rf_helper->account_name);
1028 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1029 rf_helper->account_name,
1030 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1031 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1032 rf_helper->account_name,
1033 MODEST_ACCOUNT_SIGNATURE, FALSE);
1036 /* Create reply mail */
1037 switch (rf_helper->action) {
1040 modest_tny_msg_create_reply_msg (msg, from, signature,
1041 rf_helper->reply_forward_type,
1042 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1044 case ACTION_REPLY_TO_ALL:
1046 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
1047 MODEST_TNY_MSG_REPLY_MODE_ALL);
1048 edit_type = MODEST_EDIT_TYPE_REPLY;
1050 case ACTION_FORWARD:
1052 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1053 edit_type = MODEST_EDIT_TYPE_FORWARD;
1056 g_return_if_reached ();
1063 g_printerr ("modest: failed to create message\n");
1067 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1068 rf_helper->account_name,
1069 TNY_ACCOUNT_TYPE_STORE);
1071 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1075 /* Create and register the windows */
1076 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
1077 mgr = modest_runtime_get_window_mgr ();
1078 modest_window_mgr_register_window (mgr, msg_win);
1080 if (rf_helper->parent_window != NULL) {
1081 gdouble parent_zoom;
1083 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1084 modest_window_set_zoom (msg_win, parent_zoom);
1087 /* Show edit window */
1088 gtk_widget_show_all (GTK_WIDGET (msg_win));
1092 g_object_unref (msg_win);
1094 g_object_unref (G_OBJECT (new_msg));
1096 g_object_unref (G_OBJECT (account));
1097 /* g_object_unref (msg); */
1098 g_object_unref (header);
1099 free_reply_forward_helper (rf_helper);
1103 * Checks a list of headers. If any of them are not currently
1104 * downloaded (CACHED) then it asks the user for permission to
1107 * Returns FALSE if the user does not want to download the
1108 * messages. Returns TRUE if the user allowed the download or if all
1109 * of them are currently downloaded
1112 download_uncached_messages (TnyList *header_list, GtkWindow *win,
1117 gint uncached_messages = 0;
1119 iter = tny_list_create_iterator (header_list);
1120 while (!tny_iterator_is_done (iter)) {
1122 TnyHeaderFlags flags;
1124 header = TNY_HEADER (tny_iterator_get_current (iter));
1125 flags = tny_header_get_flags (header);
1126 /* TODO: is this the right flag?, it seems that some
1127 headers that have been previously downloaded do not
1129 if (! (flags & TNY_HEADER_FLAG_CACHED))
1130 uncached_messages ++;
1131 g_object_unref (header);
1132 tny_iterator_next (iter);
1134 g_object_unref (iter);
1136 /* Ask for user permission to download the messages */
1138 if (uncached_messages > 0) {
1139 GtkResponseType response;
1141 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1142 _("emev_nc_include_original"));
1145 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1146 ngettext("mcen_nc_get_msg",
1148 uncached_messages));
1149 if (response == GTK_RESPONSE_CANCEL)
1152 /* If a download will be necessary, make sure that we have a connection: */
1153 retval = modest_platform_connect_and_wait(win);
1161 * Common code for the reply and forward actions
1164 reply_forward (ReplyForwardAction action, ModestWindow *win)
1166 ModestMailOperation *mail_op = NULL;
1167 TnyList *header_list = NULL;
1168 ReplyForwardHelper *rf_helper = NULL;
1169 guint reply_forward_type;
1170 gboolean continue_download;
1172 g_return_if_fail (MODEST_IS_WINDOW(win));
1174 /* we need an account when editing */
1175 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1176 run_account_setup_wizard (win);
1180 header_list = get_selected_headers (win);
1184 /* Check that the messages have been previously downloaded */
1185 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win), TRUE);
1186 if (!continue_download) {
1187 g_object_unref (header_list);
1191 reply_forward_type =
1192 modest_conf_get_int (modest_runtime_get_conf (),
1193 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1195 /* We assume that we can only select messages of the
1196 same folder and that we reply all of them from the
1197 same account. In fact the interface currently only
1198 allows single selection */
1201 rf_helper = g_slice_new0 (ReplyForwardHelper);
1202 rf_helper->reply_forward_type = reply_forward_type;
1203 rf_helper->action = action;
1204 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1205 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1206 rf_helper->parent_window = GTK_WIDGET (win);
1207 if (!rf_helper->account_name)
1208 rf_helper->account_name =
1209 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1211 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1214 /* Get header and message. Do not free them here, the
1215 reply_forward_cb must do it */
1216 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1217 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1218 if (!msg || !header) {
1220 g_object_unref (msg);
1222 g_object_unref (header);
1223 g_printerr ("modest: no message found\n");
1226 reply_forward_cb (NULL, header, msg, rf_helper);
1232 /* Retrieve messages */
1233 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1235 modest_ui_actions_get_msgs_full_error_handler,
1237 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1239 /* Only reply/forward to one message */
1240 iter = tny_list_create_iterator (header_list);
1241 header = TNY_HEADER (tny_iterator_get_current (iter));
1242 g_object_unref (iter);
1244 modest_mail_operation_get_msg (mail_op,
1249 /* modest_mail_operation_get_msgs_full (mail_op, */
1251 /* reply_forward_cb, */
1253 /* free_reply_forward_helper); */
1256 g_object_unref(mail_op);
1260 g_object_unref (header_list);
1264 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1266 g_return_if_fail (MODEST_IS_WINDOW(win));
1268 reply_forward (ACTION_REPLY, win);
1272 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1274 g_return_if_fail (MODEST_IS_WINDOW(win));
1276 reply_forward (ACTION_FORWARD, win);
1280 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1282 g_return_if_fail (MODEST_IS_WINDOW(win));
1284 reply_forward (ACTION_REPLY_TO_ALL, win);
1288 modest_ui_actions_on_next (GtkAction *action,
1289 ModestWindow *window)
1291 if (MODEST_IS_MAIN_WINDOW (window)) {
1292 GtkWidget *header_view;
1294 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1295 MODEST_WIDGET_TYPE_HEADER_VIEW);
1299 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1300 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1301 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1303 g_return_if_reached ();
1308 modest_ui_actions_on_prev (GtkAction *action,
1309 ModestWindow *window)
1311 g_return_if_fail (MODEST_IS_WINDOW(window));
1313 if (MODEST_IS_MAIN_WINDOW (window)) {
1314 GtkWidget *header_view;
1315 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1316 MODEST_WIDGET_TYPE_HEADER_VIEW);
1320 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1321 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1322 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1324 g_return_if_reached ();
1329 modest_ui_actions_on_sort (GtkAction *action,
1330 ModestWindow *window)
1332 g_return_if_fail (MODEST_IS_WINDOW(window));
1334 if (MODEST_IS_MAIN_WINDOW (window)) {
1335 GtkWidget *header_view;
1336 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1337 MODEST_WIDGET_TYPE_HEADER_VIEW);
1341 /* Show sorting dialog */
1342 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1347 new_messages_arrived (ModestMailOperation *self,
1351 if (new_messages == 0)
1354 modest_platform_on_new_msg ();
1358 * This function performs the send & receive required actions. The
1359 * window is used to create the mail operation. Typically it should
1360 * always be the main window, but we pass it as argument in order to
1364 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1366 gchar *acc_name = NULL;
1367 ModestMailOperation *mail_op;
1369 /* If no account name was provided then get the current account, and if
1370 there is no current account then pick the default one: */
1371 if (!account_name) {
1372 acc_name = g_strdup (modest_window_get_active_account(win));
1374 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1376 g_printerr ("modest: cannot get default account\n");
1380 acc_name = g_strdup (account_name);
1383 /* Set send/receive operation in progress */
1384 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1386 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1388 modest_ui_actions_send_receive_error_handler,
1391 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1392 G_CALLBACK (_on_send_receive_progress_changed),
1395 /* Send & receive. */
1396 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1397 /* Receive and then send. The operation is tagged initially as
1398 a receive operation because the account update performs a
1399 receive and then a send. The operation changes its type
1400 internally, so the progress objects will receive the proper
1401 progress information */
1402 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1403 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1404 g_object_unref (G_OBJECT (mail_op));
1412 modest_ui_actions_do_cancel_send (const gchar *account_name,
1415 TnyTransportAccount *transport_account;
1416 TnySendQueue *send_queue = NULL;
1417 GError *error = NULL;
1419 /* Get transport account */
1421 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1422 (modest_runtime_get_account_store(),
1424 TNY_ACCOUNT_TYPE_TRANSPORT));
1425 if (!transport_account) {
1426 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1431 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1432 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1433 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1434 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1435 "modest: could not find send queue for account\n");
1437 /* Keeep messages in outbox folder */
1438 tny_send_queue_cancel (send_queue, FALSE, &error);
1442 if (transport_account != NULL)
1443 g_object_unref (G_OBJECT (transport_account));
1447 modest_ui_actions_cancel_send_all (ModestWindow *win)
1449 GSList *account_names, *iter;
1451 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1454 iter = account_names;
1456 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1457 iter = g_slist_next (iter);
1460 modest_account_mgr_free_account_names (account_names);
1461 account_names = NULL;
1465 modest_ui_actions_cancel_send (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 /* Cancel all sending operaitons */
1477 modest_ui_actions_cancel_send_all (win);
1481 * Refreshes all accounts. This function will be used by automatic
1485 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1487 GSList *account_names, *iter;
1489 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1492 iter = account_names;
1494 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1495 iter = g_slist_next (iter);
1498 modest_account_mgr_free_account_names (account_names);
1499 account_names = NULL;
1503 * Handler of the click on Send&Receive button in the main toolbar
1506 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1508 /* Check if accounts exist */
1509 gboolean accounts_exist =
1510 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1512 /* If not, allow the user to create an account before trying to send/receive. */
1513 if (!accounts_exist)
1514 modest_ui_actions_on_accounts (NULL, win);
1516 /* Refresh currently selected folder. Note that if we only
1517 want to retrive the headers, then the refresh only will
1518 invoke a poke_status over all folders, i.e., only the
1519 total/unread count will be updated */
1520 if (MODEST_IS_MAIN_WINDOW (win)) {
1521 GtkWidget *header_view, *folder_view;
1522 TnyFolderStore *folder_store;
1524 /* Get folder and header view */
1526 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1527 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1529 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1531 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1533 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1534 MODEST_WIDGET_TYPE_HEADER_VIEW);
1536 /* We do not need to set the contents style
1537 because it hasn't changed. We also do not
1538 need to save the widget status. Just force
1540 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1541 TNY_FOLDER (folder_store),
1542 folder_refreshed_cb,
1543 MODEST_MAIN_WINDOW (win));
1547 g_object_unref (folder_store);
1550 /* Refresh the active account */
1551 modest_ui_actions_do_send_receive (NULL, win);
1556 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1559 GtkWidget *header_view;
1561 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1563 header_view = modest_main_window_get_child_widget (main_window,
1564 MODEST_WIDGET_TYPE_HEADER_VIEW);
1568 conf = modest_runtime_get_conf ();
1570 /* what is saved/restored is depending on the style; thus; we save with
1571 * old style, then update the style, and restore for this new style
1573 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1575 if (modest_header_view_get_style
1576 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1577 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1578 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1580 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1581 MODEST_HEADER_VIEW_STYLE_DETAILS);
1583 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1584 MODEST_CONF_HEADER_VIEW_KEY);
1589 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1591 ModestMainWindow *main_window)
1593 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1594 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1596 /* If no header has been selected then exit */
1601 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1602 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1604 /* Update Main window title */
1605 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1606 const gchar *subject = tny_header_get_subject (header);
1607 if (subject && strlen(subject) > 0)
1608 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1610 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1613 /* Update toolbar dimming state */
1614 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1618 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1620 ModestMainWindow *main_window)
1624 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1629 headers = tny_simple_list_new ();
1630 tny_list_prepend (headers, G_OBJECT (header));
1632 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1634 g_object_unref (headers);
1638 set_active_account_from_tny_account (TnyAccount *account,
1639 ModestWindow *window)
1641 const gchar *server_acc_name = tny_account_get_id (account);
1643 /* We need the TnyAccount provided by the
1644 account store because that is the one that
1645 knows the name of the Modest account */
1646 TnyAccount *modest_server_account = modest_server_account =
1647 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1648 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1651 const gchar *modest_acc_name =
1652 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1653 modest_window_set_active_account (window, modest_acc_name);
1654 g_object_unref (modest_server_account);
1659 folder_refreshed_cb (ModestMailOperation *mail_op,
1663 ModestMainWindow *win = NULL;
1664 GtkWidget *header_view;
1666 g_return_if_fail (TNY_IS_FOLDER (folder));
1668 win = MODEST_MAIN_WINDOW (user_data);
1670 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1672 /* Check if folder is empty and set headers view contents style */
1673 if (tny_folder_get_all_count (folder) == 0) {
1674 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1675 modest_main_window_set_contents_style (win,
1676 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1678 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1683 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1684 TnyFolderStore *folder_store,
1686 ModestMainWindow *main_window)
1689 GtkWidget *header_view;
1691 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1693 header_view = modest_main_window_get_child_widget(main_window,
1694 MODEST_WIDGET_TYPE_HEADER_VIEW);
1698 conf = modest_runtime_get_conf ();
1700 if (TNY_IS_ACCOUNT (folder_store)) {
1702 /* Update active account */
1703 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1704 /* Show account details */
1705 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1708 if (TNY_IS_FOLDER (folder_store) && selected) {
1710 /* Update the active account */
1711 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1713 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1714 g_object_unref (account);
1718 /* Set the header style by default, it could
1719 be changed later by the refresh callback to
1721 modest_main_window_set_contents_style (main_window,
1722 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1724 /* Set folder on header view. This function
1725 will call tny_folder_refresh_async so we
1726 pass a callback that will be called when
1727 finished. We use that callback to set the
1728 empty view if there are no messages */
1729 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1730 TNY_FOLDER (folder_store),
1731 folder_refreshed_cb,
1734 /* Restore configuration. We need to do this
1735 *after* the set_folder because the widget
1736 memory asks the header view about its
1738 modest_widget_memory_restore (modest_runtime_get_conf (),
1739 G_OBJECT(header_view),
1740 MODEST_CONF_HEADER_VIEW_KEY);
1742 /* Update the active account */
1743 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1744 /* Save only if we're seeing headers */
1745 if (modest_main_window_get_contents_style (main_window) ==
1746 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1747 modest_widget_memory_save (conf, G_OBJECT (header_view),
1748 MODEST_CONF_HEADER_VIEW_KEY);
1749 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1753 /* Update toolbar dimming state */
1754 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1758 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1765 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1767 online = tny_device_is_online (modest_runtime_get_device());
1770 /* already online -- the item is simply not there... */
1771 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1773 GTK_MESSAGE_WARNING,
1775 _("The %s you selected cannot be found"),
1777 gtk_dialog_run (GTK_DIALOG(dialog));
1779 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1783 GTK_RESPONSE_REJECT,
1785 GTK_RESPONSE_ACCEPT,
1787 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1788 "Do you want to get online?"), item);
1789 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1790 gtk_label_new (txt), FALSE, FALSE, 0);
1791 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1794 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1795 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1796 // modest_platform_connect_and_wait ();
1799 gtk_widget_destroy (dialog);
1803 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1806 /* g_message ("%s %s", __FUNCTION__, link); */
1811 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1814 modest_platform_activate_uri (link);
1818 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1821 modest_platform_show_uri_popup (link);
1825 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1828 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1832 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1833 const gchar *address,
1836 /* g_message ("%s %s", __FUNCTION__, address); */
1840 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1842 TnyTransportAccount *transport_account;
1843 ModestMailOperation *mail_operation;
1845 gchar *account_name, *from;
1846 ModestAccountMgr *account_mgr;
1847 gchar *info_text = NULL;
1849 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1851 data = modest_msg_edit_window_get_msg_data (edit_window);
1853 account_mgr = modest_runtime_get_account_mgr();
1854 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1856 account_name = modest_account_mgr_get_default_account (account_mgr);
1857 if (!account_name) {
1858 g_printerr ("modest: no account found\n");
1859 modest_msg_edit_window_free_msg_data (edit_window, data);
1863 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1864 account_name = g_strdup (data->account_name);
1868 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1869 (modest_runtime_get_account_store(),
1871 TNY_ACCOUNT_TYPE_TRANSPORT));
1872 if (!transport_account) {
1873 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1874 g_free (account_name);
1875 modest_msg_edit_window_free_msg_data (edit_window, data);
1878 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1880 /* Create the mail operation */
1881 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1882 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1884 modest_mail_operation_save_to_drafts (mail_operation,
1896 data->priority_flags);
1899 g_free (account_name);
1900 g_object_unref (G_OBJECT (transport_account));
1901 g_object_unref (G_OBJECT (mail_operation));
1903 modest_msg_edit_window_free_msg_data (edit_window, data);
1905 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1906 modest_platform_information_banner (NULL, NULL, info_text);
1910 /* For instance, when clicking the Send toolbar button when editing a message: */
1912 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1914 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1916 if (!modest_msg_edit_window_check_names (edit_window))
1919 /* Offer the connection dialog, if necessary: */
1920 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window)))
1923 /* FIXME: Code added just for testing. The final version will
1924 use the send queue provided by tinymail and some
1926 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1927 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1929 account_name = modest_account_mgr_get_default_account (account_mgr);
1931 if (!account_name) {
1932 g_printerr ("modest: no account found\n");
1936 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1938 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1939 account_name = g_strdup (data->account_name);
1942 /* Get the currently-active transport account for this modest account: */
1943 TnyTransportAccount *transport_account =
1944 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1945 (modest_runtime_get_account_store(),
1947 if (!transport_account) {
1948 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1949 g_free (account_name);
1950 modest_msg_edit_window_free_msg_data (edit_window, data);
1954 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1956 /* mail content checks and dialogs */
1957 if (data->subject == NULL || data->subject[0] == '\0') {
1958 GtkResponseType response;
1959 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1960 _("mcen_nc_subject_is_empty_send"));
1961 if (response == GTK_RESPONSE_CANCEL) {
1962 g_free (account_name);
1967 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1968 GtkResponseType response;
1969 gchar *note_message;
1970 gchar *note_subject = data->subject;
1971 if (note_subject == NULL || note_subject[0] == '\0')
1972 note_subject = _("mail_va_no_subject");
1973 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1974 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1976 g_free (note_message);
1977 if (response == GTK_RESPONSE_CANCEL) {
1978 g_free (account_name);
1983 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
1985 /* Create the mail operation */
1986 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1987 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1989 modest_mail_operation_send_new_mail (mail_operation,
2000 data->priority_flags);
2004 g_free (account_name);
2005 g_object_unref (G_OBJECT (transport_account));
2006 g_object_unref (G_OBJECT (mail_operation));
2008 modest_msg_edit_window_free_msg_data (edit_window, data);
2009 modest_msg_edit_window_set_sent (edit_window, TRUE);
2011 /* Save settings and close the window: */
2012 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2016 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2017 ModestMsgEditWindow *window)
2019 ModestMsgEditFormatState *format_state = NULL;
2021 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2022 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2024 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2027 format_state = modest_msg_edit_window_get_format_state (window);
2028 g_return_if_fail (format_state != NULL);
2030 format_state->bold = gtk_toggle_action_get_active (action);
2031 modest_msg_edit_window_set_format_state (window, format_state);
2032 g_free (format_state);
2037 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2038 ModestMsgEditWindow *window)
2040 ModestMsgEditFormatState *format_state = NULL;
2042 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2043 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2045 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2048 format_state = modest_msg_edit_window_get_format_state (window);
2049 g_return_if_fail (format_state != NULL);
2051 format_state->italics = gtk_toggle_action_get_active (action);
2052 modest_msg_edit_window_set_format_state (window, format_state);
2053 g_free (format_state);
2058 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2059 ModestMsgEditWindow *window)
2061 ModestMsgEditFormatState *format_state = NULL;
2063 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2064 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2066 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2069 format_state = modest_msg_edit_window_get_format_state (window);
2070 g_return_if_fail (format_state != NULL);
2072 format_state->bullet = gtk_toggle_action_get_active (action);
2073 modest_msg_edit_window_set_format_state (window, format_state);
2074 g_free (format_state);
2079 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2080 GtkRadioAction *selected,
2081 ModestMsgEditWindow *window)
2083 ModestMsgEditFormatState *format_state = NULL;
2084 GtkJustification value;
2086 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2088 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2091 value = gtk_radio_action_get_current_value (selected);
2093 format_state = modest_msg_edit_window_get_format_state (window);
2094 g_return_if_fail (format_state != NULL);
2096 format_state->justification = value;
2097 modest_msg_edit_window_set_format_state (window, format_state);
2098 g_free (format_state);
2102 modest_ui_actions_on_select_editor_color (GtkAction *action,
2103 ModestMsgEditWindow *window)
2105 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2106 g_return_if_fail (GTK_IS_ACTION (action));
2108 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2111 modest_msg_edit_window_select_color (window);
2115 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2116 ModestMsgEditWindow *window)
2118 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2119 g_return_if_fail (GTK_IS_ACTION (action));
2121 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2124 modest_msg_edit_window_select_background_color (window);
2128 modest_ui_actions_on_insert_image (GtkAction *action,
2129 ModestMsgEditWindow *window)
2131 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2132 g_return_if_fail (GTK_IS_ACTION (action));
2134 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2137 modest_msg_edit_window_insert_image (window);
2141 modest_ui_actions_on_attach_file (GtkAction *action,
2142 ModestMsgEditWindow *window)
2144 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2145 g_return_if_fail (GTK_IS_ACTION (action));
2147 modest_msg_edit_window_attach_file (window);
2151 modest_ui_actions_on_remove_attachments (GtkAction *action,
2152 ModestMsgEditWindow *window)
2154 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2155 g_return_if_fail (GTK_IS_ACTION (action));
2157 modest_msg_edit_window_remove_attachments (window, NULL);
2161 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2164 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2166 /* TODO: Note that folder creation might go wrong due to other
2167 * failures such as when the parent folder is non-writable. We can
2168 * query a GError* with modest_mail_operation_get_error(), but the
2169 * the error code (from tinymail) does not give us a clue about what
2170 * has gone wrong. We might use the error->message but it might come
2171 * from camel and not be suitable to show to the user directly. */
2172 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2173 _CS("ckdg_ib_folder_already_exists"));
2175 /* modest_platform_information_banner (GTK_WIDGET (window), NULL,
2176 modest_mail_operation_get_error (mail_op)->message);*/
2181 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2183 TnyFolderStore *parent_folder;
2184 GtkWidget *folder_view;
2186 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2188 folder_view = modest_main_window_get_child_widget (main_window,
2189 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2193 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2195 if (parent_folder) {
2196 gboolean finished = FALSE;
2198 gchar *folder_name = NULL, *suggested_name = NULL;
2200 /* Run the new folder dialog */
2202 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
2207 g_free (suggested_name);
2208 suggested_name = NULL;
2210 if (result == GTK_RESPONSE_REJECT) {
2213 ModestMailOperation *mail_op;
2214 TnyFolder *new_folder = NULL;
2216 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2217 G_OBJECT(main_window),
2218 modest_ui_actions_new_folder_error_handler,
2221 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2223 new_folder = modest_mail_operation_create_folder (mail_op,
2225 (const gchar *) folder_name);
2228 folder_view = modest_main_window_get_child_widget (main_window,
2229 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2231 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2235 g_object_unref (new_folder);
2238 g_object_unref (mail_op);
2241 suggested_name = folder_name;
2245 g_object_unref (parent_folder);
2250 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2253 GObject *win = modest_mail_operation_get_source (mail_op);
2254 const GError *error = NULL;
2255 const gchar *message = NULL;
2257 /* Get error message */
2258 error = modest_mail_operation_get_error (mail_op);
2259 if (error != NULL && error->message != NULL) {
2260 message = error->message;
2262 message = _("!!! FIXME: Unable to rename");
2265 /* Show notification dialog */
2266 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
2267 g_object_unref (win);
2271 modest_ui_actions_on_rename_folder (GtkAction *action,
2272 ModestMainWindow *main_window)
2274 TnyFolderStore *folder;
2275 GtkWidget *folder_view;
2276 GtkWidget *header_view;
2278 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2280 folder_view = modest_main_window_get_child_widget (main_window,
2281 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2285 header_view = modest_main_window_get_child_widget (main_window,
2286 MODEST_WIDGET_TYPE_HEADER_VIEW);
2291 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2295 /* Offer the connection dialog if necessary: */
2296 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2297 g_object_unref (G_OBJECT (folder));
2302 if (TNY_IS_FOLDER (folder)) {
2305 const gchar *current_name;
2307 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2308 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2309 current_name, &folder_name);
2311 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2312 ModestMailOperation *mail_op;
2315 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2316 G_OBJECT(main_window),
2317 modest_ui_actions_rename_folder_error_handler,
2321 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2324 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2326 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2327 TNY_FOLDER(folder), TRUE);
2330 modest_header_view_clear ((ModestHeaderView *) header_view);
2332 modest_mail_operation_rename_folder (mail_op,
2333 TNY_FOLDER (folder),
2334 (const gchar *) folder_name);
2336 g_object_unref (mail_op);
2337 g_free (folder_name);
2340 g_object_unref (folder);
2344 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2347 GObject *win = modest_mail_operation_get_source (mail_op);
2349 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2350 _("mail_in_ui_folder_delete_error"));
2351 g_object_unref (win);
2355 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2357 TnyFolderStore *folder;
2358 GtkWidget *folder_view;
2362 g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2364 folder_view = modest_main_window_get_child_widget (main_window,
2365 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2369 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2371 /* Show an error if it's an account */
2372 if (!TNY_IS_FOLDER (folder)) {
2373 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2374 _("mail_in_ui_folder_delete_error"));
2375 g_object_unref (G_OBJECT (folder));
2379 /* Offer the connection dialog if necessary: */
2380 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2381 g_object_unref (G_OBJECT (folder));
2386 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2387 tny_folder_get_name (TNY_FOLDER (folder)));
2388 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2389 (const gchar *) message);
2392 if (response == GTK_RESPONSE_OK) {
2393 ModestMailOperation *mail_op =
2394 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2395 G_OBJECT(main_window),
2396 modest_ui_actions_delete_folder_error_handler,
2399 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2401 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2402 g_object_unref (G_OBJECT (mail_op));
2405 g_object_unref (G_OBJECT (folder));
2409 modest_ui_actions_on_delete_folder (GtkAction *action,
2410 ModestMainWindow *main_window)
2412 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2414 delete_folder (main_window, FALSE);
2418 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2420 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2422 delete_folder (main_window, TRUE);
2426 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2427 const gchar* server_account_name,
2432 ModestMainWindow *main_window)
2434 g_return_if_fail(server_account_name);
2435 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2437 /* Initalize output parameters: */
2444 #ifdef MODEST_PLATFORM_MAEMO
2445 /* Maemo uses a different (awkward) button order,
2446 * It should probably just use gtk_alternative_dialog_button_order ().
2448 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2452 GTK_RESPONSE_ACCEPT,
2454 GTK_RESPONSE_REJECT,
2457 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2461 GTK_RESPONSE_REJECT,
2463 GTK_RESPONSE_ACCEPT,
2465 #endif /* MODEST_PLATFORM_MAEMO */
2467 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2469 gchar *server_name = modest_server_account_get_hostname (
2470 modest_runtime_get_account_mgr(), server_account_name);
2471 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2472 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2477 /* This causes a warning because the logical ID has no %s in it,
2478 * though the translation does, but there is not much we can do about that: */
2479 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2480 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2483 g_free (server_name);
2487 gchar *initial_username = modest_server_account_get_username (
2488 modest_runtime_get_account_mgr(), server_account_name);
2490 GtkWidget *entry_username = gtk_entry_new ();
2491 if (initial_username)
2492 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2493 /* Dim this if a connection has ever succeeded with this username,
2494 * as per the UI spec: */
2495 const gboolean username_known =
2496 modest_server_account_get_username_has_succeeded(
2497 modest_runtime_get_account_mgr(), server_account_name);
2498 gtk_widget_set_sensitive (entry_username, !username_known);
2500 #ifdef MODEST_PLATFORM_MAEMO
2501 /* Auto-capitalization is the default, so let's turn it off: */
2502 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2504 /* Create a size group to be used by all captions.
2505 * Note that HildonCaption does not create a default size group if we do not specify one.
2506 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2507 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2509 GtkWidget *caption = hildon_caption_new (sizegroup,
2510 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2511 gtk_widget_show (entry_username);
2512 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2513 FALSE, FALSE, MODEST_MARGIN_HALF);
2514 gtk_widget_show (caption);
2516 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2518 #endif /* MODEST_PLATFORM_MAEMO */
2521 GtkWidget *entry_password = gtk_entry_new ();
2522 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2523 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2525 #ifdef MODEST_PLATFORM_MAEMO
2526 /* Auto-capitalization is the default, so let's turn it off: */
2527 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2528 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2530 caption = hildon_caption_new (sizegroup,
2531 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2532 gtk_widget_show (entry_password);
2533 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2534 FALSE, FALSE, MODEST_MARGIN_HALF);
2535 gtk_widget_show (caption);
2536 g_object_unref (sizegroup);
2538 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2540 #endif /* MODEST_PLATFORM_MAEMO */
2542 /* This is not in the Maemo UI spec:
2543 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2544 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2548 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2550 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2552 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2554 modest_server_account_set_username (
2555 modest_runtime_get_account_mgr(), server_account_name,
2558 const gboolean username_was_changed =
2559 (strcmp (*username, initial_username) != 0);
2560 if (username_was_changed) {
2561 g_warning ("%s: tinymail does not yet support changing the "
2562 "username in the get_password() callback.\n", __FUNCTION__);
2567 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2569 /* We do not save the password in the configuration,
2570 * because this function is only called for passwords that should
2571 * not be remembered:
2572 modest_server_account_set_password (
2573 modest_runtime_get_account_mgr(), server_account_name,
2592 /* This is not in the Maemo UI spec:
2593 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2599 gtk_widget_destroy (dialog);
2601 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2605 modest_ui_actions_on_cut (GtkAction *action,
2606 ModestWindow *window)
2608 GtkWidget *focused_widget;
2610 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2611 if (GTK_IS_EDITABLE (focused_widget)) {
2612 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2613 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2614 GtkTextBuffer *buffer;
2615 GtkClipboard *clipboard;
2617 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2618 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2619 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2620 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2621 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2622 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2623 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2624 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2629 modest_ui_actions_on_copy (GtkAction *action,
2630 ModestWindow *window)
2632 GtkClipboard *clipboard;
2633 GtkWidget *focused_widget;
2635 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2636 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2638 if (GTK_IS_LABEL (focused_widget)) {
2639 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2640 } else if (GTK_IS_EDITABLE (focused_widget)) {
2641 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2642 } else if (GTK_IS_HTML (focused_widget)) {
2643 gtk_html_copy (GTK_HTML (focused_widget));
2644 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2645 GtkTextBuffer *buffer;
2646 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2647 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2648 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2649 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2650 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2651 TnyIterator *iter = tny_list_create_iterator (header_list);
2652 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2653 TnyFolder *folder = tny_header_get_folder (header);
2654 TnyAccount *account = tny_folder_get_account (folder);
2655 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2656 /* If it's POP then ask */
2657 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2658 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2659 g_object_unref (account);
2660 g_object_unref (folder);
2661 g_object_unref (header);
2662 g_object_unref (iter);
2664 /* Check that the messages have been previously downloaded */
2665 gboolean continue_download = TRUE;
2667 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window), FALSE);
2668 if (continue_download)
2669 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2670 g_object_unref (header_list);
2671 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2672 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2675 /* Show information banner */
2676 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2681 modest_ui_actions_on_undo (GtkAction *action,
2682 ModestWindow *window)
2684 ModestEmailClipboard *clipboard = NULL;
2686 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2687 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2688 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2689 /* Clear clipboard source */
2690 clipboard = modest_runtime_get_email_clipboard ();
2691 modest_email_clipboard_clear (clipboard);
2694 g_return_if_reached ();
2699 modest_ui_actions_on_redo (GtkAction *action,
2700 ModestWindow *window)
2702 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2703 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2706 g_return_if_reached ();
2712 paste_msgs_cb (const GObject *object, gpointer user_data)
2714 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2715 g_return_if_fail (GTK_IS_WIDGET (user_data));
2717 /* destroy information note */
2718 gtk_widget_destroy (GTK_WIDGET(user_data));
2722 modest_ui_actions_on_paste (GtkAction *action,
2723 ModestWindow *window)
2725 GtkWidget *focused_widget = NULL;
2726 GtkWidget *inf_note = NULL;
2727 ModestMailOperation *mail_op = NULL;
2729 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2730 if (GTK_IS_EDITABLE (focused_widget)) {
2731 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2732 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2733 GtkTextBuffer *buffer;
2734 GtkClipboard *clipboard;
2736 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2737 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2738 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2739 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2740 ModestEmailClipboard *clipboard = NULL;
2741 TnyFolder *src_folder = NULL;
2742 TnyFolderStore *folder_store = NULL;
2743 TnyList *data = NULL;
2744 gboolean delete = FALSE;
2746 /* Check clipboard source */
2747 clipboard = modest_runtime_get_email_clipboard ();
2748 if (modest_email_clipboard_cleared (clipboard))
2751 /* Get elements to paste */
2752 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2754 /* Create a new mail operation */
2755 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2756 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2759 /* Get destination folder */
2760 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2762 /* Launch notification */
2763 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2764 _CS("ckct_nw_pasting"));
2765 if (inf_note != NULL) {
2766 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
2767 gtk_widget_show (GTK_WIDGET(inf_note));
2770 /* transfer messages */
2772 modest_mail_operation_xfer_msgs (mail_op,
2774 TNY_FOLDER (folder_store),
2779 } else if (src_folder != NULL) {
2780 modest_mail_operation_xfer_folder (mail_op,
2790 g_object_unref (data);
2791 if (src_folder != NULL)
2792 g_object_unref (src_folder);
2793 if (folder_store != NULL)
2794 g_object_unref (folder_store);
2800 modest_ui_actions_on_select_all (GtkAction *action,
2801 ModestWindow *window)
2803 GtkWidget *focused_widget;
2805 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2806 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2807 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2808 } else if (GTK_IS_LABEL (focused_widget)) {
2809 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2810 } else if (GTK_IS_EDITABLE (focused_widget)) {
2811 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2812 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2813 GtkTextBuffer *buffer;
2814 GtkTextIter start, end;
2816 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2817 gtk_text_buffer_get_start_iter (buffer, &start);
2818 gtk_text_buffer_get_end_iter (buffer, &end);
2819 gtk_text_buffer_select_range (buffer, &start, &end);
2820 } else if (GTK_IS_HTML (focused_widget)) {
2821 gtk_html_select_all (GTK_HTML (focused_widget));
2822 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2823 GtkWidget *header_view = focused_widget;
2824 GtkTreeSelection *selection = NULL;
2826 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2827 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2828 MODEST_WIDGET_TYPE_HEADER_VIEW);
2830 /* Select all messages */
2831 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2832 gtk_tree_selection_select_all (selection);
2834 /* Set focuse on header view */
2835 gtk_widget_grab_focus (header_view);
2841 modest_ui_actions_on_mark_as_read (GtkAction *action,
2842 ModestWindow *window)
2844 g_return_if_fail (MODEST_IS_WINDOW(window));
2846 /* Mark each header as read */
2847 do_headers_action (window, headers_action_mark_as_read, NULL);
2851 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2852 ModestWindow *window)
2854 g_return_if_fail (MODEST_IS_WINDOW(window));
2856 /* Mark each header as read */
2857 do_headers_action (window, headers_action_mark_as_unread, NULL);
2861 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2862 GtkRadioAction *selected,
2863 ModestWindow *window)
2867 value = gtk_radio_action_get_current_value (selected);
2868 if (MODEST_IS_WINDOW (window)) {
2869 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2873 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2874 GtkRadioAction *selected,
2875 ModestWindow *window)
2877 TnyHeaderFlags flags;
2878 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2880 flags = gtk_radio_action_get_current_value (selected);
2881 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2884 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2885 GtkRadioAction *selected,
2886 ModestWindow *window)
2890 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2892 file_format = gtk_radio_action_get_current_value (selected);
2893 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2898 modest_ui_actions_on_zoom_plus (GtkAction *action,
2899 ModestWindow *window)
2901 g_return_if_fail (MODEST_IS_WINDOW (window));
2903 modest_window_zoom_plus (MODEST_WINDOW (window));
2907 modest_ui_actions_on_zoom_minus (GtkAction *action,
2908 ModestWindow *window)
2910 g_return_if_fail (MODEST_IS_WINDOW (window));
2912 modest_window_zoom_minus (MODEST_WINDOW (window));
2916 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2917 ModestWindow *window)
2919 ModestWindowMgr *mgr;
2920 gboolean fullscreen, active;
2921 g_return_if_fail (MODEST_IS_WINDOW (window));
2923 mgr = modest_runtime_get_window_mgr ();
2925 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2926 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2928 if (active != fullscreen) {
2929 modest_window_mgr_set_fullscreen_mode (mgr, active);
2930 gtk_window_present (GTK_WINDOW (window));
2935 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2936 ModestWindow *window)
2938 ModestWindowMgr *mgr;
2939 gboolean fullscreen;
2941 g_return_if_fail (MODEST_IS_WINDOW (window));
2943 mgr = modest_runtime_get_window_mgr ();
2944 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2945 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2947 gtk_window_present (GTK_WINDOW (window));
2951 * Used by modest_ui_actions_on_details to call do_headers_action
2954 headers_action_show_details (TnyHeader *header,
2955 ModestWindow *window,
2962 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2965 gtk_widget_show_all (dialog);
2966 gtk_dialog_run (GTK_DIALOG (dialog));
2968 gtk_widget_destroy (dialog);
2972 * Show the folder details in a ModestDetailsDialog widget
2975 show_folder_details (TnyFolder *folder,
2981 dialog = modest_details_dialog_new_with_folder (window, folder);
2984 gtk_widget_show_all (dialog);
2985 gtk_dialog_run (GTK_DIALOG (dialog));
2987 gtk_widget_destroy (dialog);
2991 * Show the header details in a ModestDetailsDialog widget
2994 modest_ui_actions_on_details (GtkAction *action,
2997 TnyList * headers_list;
3001 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3004 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3007 g_object_unref (msg);
3009 headers_list = get_selected_headers (win);
3013 iter = tny_list_create_iterator (headers_list);
3015 header = TNY_HEADER (tny_iterator_get_current (iter));
3016 headers_action_show_details (header, win, NULL);
3017 g_object_unref (header);
3019 g_object_unref (iter);
3020 g_object_unref (headers_list);
3022 } else if (MODEST_IS_MAIN_WINDOW (win)) {
3023 GtkWidget *folder_view, *header_view;
3025 /* Check which widget has the focus */
3026 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3027 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3028 if (gtk_widget_is_focus (folder_view)) {
3029 TnyFolderStore *folder_store
3030 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3031 if (!folder_store) {
3032 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3035 /* Show only when it's a folder */
3036 /* This function should not be called for account items,
3037 * because we dim the menu item for them. */
3038 if (TNY_IS_FOLDER (folder_store)) {
3039 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3042 g_object_unref (folder_store);
3045 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3046 MODEST_WIDGET_TYPE_HEADER_VIEW);
3047 /* Show details of each header */
3048 do_headers_action (win, headers_action_show_details, header_view);
3054 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3055 ModestMsgEditWindow *window)
3057 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3059 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3063 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3064 ModestMsgEditWindow *window)
3066 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3068 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3072 modest_ui_actions_toggle_folders_view (GtkAction *action,
3073 ModestMainWindow *main_window)
3075 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3077 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3078 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3080 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3084 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3085 ModestWindow *window)
3087 gboolean active, fullscreen = FALSE;
3088 ModestWindowMgr *mgr;
3090 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3092 /* Check if we want to toggle the toolbar vuew in fullscreen
3094 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3095 "ViewShowToolbarFullScreen")) {
3099 /* Toggle toolbar */
3100 mgr = modest_runtime_get_window_mgr ();
3101 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3105 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3106 ModestMsgEditWindow *window)
3108 modest_msg_edit_window_select_font (window);
3112 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3113 const gchar *display_name,
3116 /* Do not change the application name if the widget has not
3117 the focus. This callback could be called even if the folder
3118 view has not the focus, because the handled signal could be
3119 emitted when the folder view is redrawn */
3120 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3122 gtk_window_set_title (window, display_name);
3124 gtk_window_set_title (window, " ");
3129 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3131 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3132 modest_msg_edit_window_select_contacts (window);
3136 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3138 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3139 modest_msg_edit_window_check_names (window);
3144 create_move_to_dialog (GtkWindow *win,
3145 GtkWidget *folder_view,
3146 GtkWidget **tree_view)
3148 GtkWidget *dialog, *scroll;
3150 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3152 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3154 GTK_RESPONSE_ACCEPT,
3156 GTK_RESPONSE_REJECT,
3159 /* Create scrolled window */
3160 scroll = gtk_scrolled_window_new (NULL, NULL);
3161 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3162 GTK_POLICY_AUTOMATIC,
3163 GTK_POLICY_AUTOMATIC);
3165 /* Create folder view */
3166 *tree_view = modest_platform_create_folder_view (NULL);
3168 /* It could happen that we're trying to move a message from a
3169 window (msg window for example) after the main window was
3170 closed, so we can not just get the model of the folder
3172 if (MODEST_IS_FOLDER_VIEW (folder_view))
3173 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3174 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3176 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3177 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3179 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3181 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3183 /* Add scroll to dialog */
3184 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3185 scroll, FALSE, FALSE, 0);
3187 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3193 * Returns TRUE if at least one of the headers of the list belongs to
3194 * a message that has been fully retrieved.
3197 has_retrieved_msgs (TnyList *list)
3200 gboolean found = FALSE;
3202 iter = tny_list_create_iterator (list);
3203 while (tny_iterator_is_done (iter) && !found) {
3205 TnyHeaderFlags flags;
3207 header = TNY_HEADER (tny_iterator_get_current (iter));
3208 flags = tny_header_get_flags (header);
3209 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
3213 tny_iterator_next (iter);
3215 g_object_unref (iter);
3221 * Shows a confirmation dialog to the user when we're moving messages
3222 * from a remote server to the local storage. Returns the dialog
3223 * response. If it's other kind of movement the it always returns
3227 msgs_move_to_confirmation (GtkWindow *win,
3228 TnyFolder *dest_folder,
3231 gint response = GTK_RESPONSE_OK;
3233 /* If the destination is a local folder */
3234 if (modest_tny_folder_is_local_folder (dest_folder)) {
3235 TnyFolder *src_folder;
3239 /* Get source folder */
3240 iter = tny_list_create_iterator (headers);
3241 header = TNY_HEADER (tny_iterator_get_current (iter));
3242 src_folder = tny_header_get_folder (header);
3243 g_object_unref (header);
3244 g_object_unref (iter);
3246 /* if no src_folder, message may be an attahcment */
3247 if (src_folder == NULL)
3248 return GTK_RESPONSE_CANCEL;
3250 /* If the source is a remote folder */
3251 if (!modest_tny_folder_is_local_folder (src_folder)) {
3252 const gchar *message;
3254 if (has_retrieved_msgs (headers))
3255 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3256 tny_list_get_length (headers));
3258 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3259 tny_list_get_length (headers));
3261 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3262 (const gchar *) message);
3264 g_object_unref (src_folder);
3272 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3274 ModestMsgViewWindow *self = NULL;
3276 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3277 self = MODEST_MSG_VIEW_WINDOW (object);
3279 if (!modest_msg_view_window_select_next_message (self))
3280 if (!modest_msg_view_window_select_previous_message (self))
3281 /* No more messages to view, so close this window */
3282 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3286 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3289 GObject *win = modest_mail_operation_get_source (mail_op);
3290 const GError *error = NULL;
3291 const gchar *message = NULL;
3293 /* Get error message */
3294 error = modest_mail_operation_get_error (mail_op);
3295 if (error != NULL && error->message != NULL) {
3296 message = error->message;
3298 message = _("mail_in_ui_folder_move_target_error");
3301 /* Show notification dialog */
3302 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3303 g_object_unref (win);
3307 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3310 GObject *win = modest_mail_operation_get_source (mail_op);
3311 const GError *error = modest_mail_operation_get_error (mail_op);
3313 g_return_if_fail (error != NULL);
3314 if (error->message != NULL)
3315 g_printerr ("modest: %s\n", error->message);
3317 g_printerr ("modest: unkonw error on send&receive operation");
3319 /* Show error message */
3320 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3321 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3322 /* _CS("sfil_ib_unable_to_receive")); */
3324 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3325 /* _CS("sfil_ib_unable_to_send")); */
3326 g_object_unref (win);
3330 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3337 gint pending_purges = 0;
3338 gboolean some_purged = FALSE;
3339 ModestWindow *win = MODEST_WINDOW (user_data);
3341 /* If there was any error */
3342 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
3345 /* Once the message has been retrieved for purging, we check if
3346 * it's all ok for purging */
3348 parts = tny_simple_list_new ();
3349 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3350 iter = tny_list_create_iterator (parts);
3352 while (!tny_iterator_is_done (iter)) {
3354 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3355 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)) {
3356 if (tny_mime_part_is_purged (part))
3361 tny_iterator_next (iter);
3364 if (pending_purges>0) {
3366 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3368 if (response == GTK_RESPONSE_OK) {
3369 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3370 tny_iterator_first (iter);
3371 while (!tny_iterator_is_done (iter)) {
3374 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3375 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))
3376 tny_mime_part_set_purged (part);
3377 tny_iterator_next (iter);
3380 tny_msg_rewrite_cache (msg);
3383 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3386 /* remove attachments */
3387 tny_iterator_first (iter);
3388 while (!tny_iterator_is_done (iter)) {
3391 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3392 g_object_unref (part);
3393 tny_iterator_next (iter);
3396 g_object_unref (iter);
3397 g_object_unref (parts);
3401 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3402 ModestMainWindow *win)
3404 GtkWidget *header_view;
3405 TnyList *header_list;
3408 TnyHeaderFlags flags;
3409 ModestWindow *msg_view_window = NULL;
3412 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3414 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3415 MODEST_WIDGET_TYPE_HEADER_VIEW);
3417 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3419 if (tny_list_get_length (header_list) == 1) {
3420 iter = tny_list_create_iterator (header_list);
3421 header = TNY_HEADER (tny_iterator_get_current (iter));
3422 g_object_unref (iter);
3427 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3428 header, &msg_view_window);
3429 flags = tny_header_get_flags (header);
3430 if (!(flags & TNY_HEADER_FLAG_CACHED))
3433 if (msg_view_window != NULL)
3434 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3436 /* do nothing; uid was registered before, so window is probably on it's way */
3437 g_warning ("debug: header %p has already been registered", header);
3440 ModestMailOperation *mail_op = NULL;
3441 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3442 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3444 modest_ui_actions_get_msgs_full_error_handler,
3446 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3447 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3449 g_object_unref (mail_op);
3452 g_object_unref (header);
3454 g_object_unref (header_list);
3458 * Utility function that transfer messages from both the main window
3459 * and the msg view window when using the "Move to" dialog
3462 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
3465 TnyList *headers = NULL;
3468 if (!TNY_IS_FOLDER (dst_folder)) {
3469 modest_platform_information_banner (GTK_WIDGET (win),
3471 _CS("ckdg_ib_unable_to_move_to_current_location"));
3475 /* Get selected headers */
3476 headers = get_selected_headers (MODEST_WINDOW (win));
3478 /* Ask for user confirmation */
3479 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3480 TNY_FOLDER (dst_folder),
3483 /* Transfer messages */
3484 if (response == GTK_RESPONSE_OK) {
3485 ModestMailOperation *mail_op =
3486 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3488 modest_ui_actions_move_folder_error_handler,
3490 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3493 modest_mail_operation_xfer_msgs (mail_op,
3495 TNY_FOLDER (dst_folder),
3497 (MODEST_IS_MSG_VIEW_WINDOW (win)) ? transfer_msgs_from_viewer_cb : NULL,
3500 g_object_unref (G_OBJECT (mail_op));
3502 g_object_unref (headers);
3507 * UI handler for the "Move to" action when invoked from the
3511 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3512 GtkWidget *folder_view,
3513 TnyFolderStore *dst_folder,
3514 ModestMainWindow *win)
3516 GtkWidget *header_view = NULL;
3517 ModestMailOperation *mail_op = NULL;
3518 TnyFolderStore *src_folder;
3520 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3522 /* Get the source folder */
3523 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3525 /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3526 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3530 /* Get header view */
3532 modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW);
3534 /* Get folder or messages to transfer */
3535 if (gtk_widget_is_focus (folder_view)) {
3537 /* Allow only to transfer folders to the local root folder */
3538 if (TNY_IS_ACCOUNT (dst_folder) &&
3539 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder))
3542 /* Clean folder on header view before moving it */
3543 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3545 if (TNY_IS_FOLDER (src_folder)) {
3547 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3549 modest_ui_actions_move_folder_error_handler,
3551 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3554 modest_mail_operation_xfer_folder (mail_op,
3555 TNY_FOLDER (src_folder),
3558 /* Unref mail operation */
3559 g_object_unref (G_OBJECT (mail_op));
3561 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3563 } else if (gtk_widget_is_focus (header_view)) {
3564 /* Transfer messages */
3565 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3570 g_object_unref (src_folder);
3575 * UI handler for the "Move to" action when invoked from the
3576 * ModestMsgViewWindow
3579 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3580 TnyFolderStore *dst_folder,
3581 ModestMsgViewWindow *win)
3583 TnyHeader *header = NULL;
3584 TnyFolder *src_folder;
3586 /* Create header list */
3587 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3588 src_folder = tny_header_get_folder(header);
3589 g_object_unref (header);
3591 /* Transfer the message */
3592 if (modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (src_folder)))
3593 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3595 g_object_unref (src_folder);
3599 modest_ui_actions_on_move_to (GtkAction *action,
3602 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3604 TnyFolderStore *dst_folder = NULL;
3605 ModestMainWindow *main_window;
3607 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3608 MODEST_IS_MSG_VIEW_WINDOW (win));
3610 /* Get the main window if exists */
3611 if (MODEST_IS_MAIN_WINDOW (win))
3612 main_window = MODEST_MAIN_WINDOW (win);
3615 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3617 /* Get the folder view widget if exists */
3619 folder_view = modest_main_window_get_child_widget (main_window,
3620 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3624 /* Create and run the dialog */
3625 dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
3626 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3627 result = gtk_dialog_run (GTK_DIALOG(dialog));
3628 g_object_ref (tree_view);
3629 gtk_widget_destroy (dialog);
3631 if (result != GTK_RESPONSE_ACCEPT)
3634 dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3635 /* Offer the connection dialog if necessary: */
3636 if (modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3639 /* Do window specific stuff */
3640 if (MODEST_IS_MAIN_WINDOW (win))
3641 modest_ui_actions_on_main_window_move_to (action,
3644 MODEST_MAIN_WINDOW (win));
3646 modest_ui_actions_on_msg_view_window_move_to (action,
3648 MODEST_MSG_VIEW_WINDOW (win));
3651 g_object_unref (dst_folder);
3655 * Calls #HeadersFunc for each header already selected in the main
3656 * window or the message currently being shown in the msg view window
3659 do_headers_action (ModestWindow *win,
3663 TnyList *headers_list;
3669 headers_list = get_selected_headers (win);
3673 /* Get the folder */
3674 iter = tny_list_create_iterator (headers_list);
3675 header = TNY_HEADER (tny_iterator_get_current (iter));
3676 folder = tny_header_get_folder (header);
3677 g_object_unref (header);
3679 /* Call the function for each header */
3680 while (!tny_iterator_is_done (iter)) {
3681 header = TNY_HEADER (tny_iterator_get_current (iter));
3682 func (header, win, user_data);
3683 g_object_unref (header);
3684 tny_iterator_next (iter);
3687 /* Trick: do a poke status in order to speed up the signaling
3689 tny_folder_poke_status (folder);
3692 g_object_unref (folder);
3693 g_object_unref (iter);
3694 g_object_unref (headers_list);
3698 modest_ui_actions_view_attachment (GtkAction *action,
3699 ModestWindow *window)
3701 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3702 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3704 /* not supported window for this action */
3705 g_return_if_reached ();
3710 modest_ui_actions_save_attachments (GtkAction *action,
3711 ModestWindow *window)
3713 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3714 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3716 /* not supported window for this action */
3717 g_return_if_reached ();
3722 modest_ui_actions_remove_attachments (GtkAction *action,
3723 ModestWindow *window)
3725 if (MODEST_IS_MAIN_WINDOW (window)) {
3726 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
3727 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3728 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
3730 /* not supported window for this action */
3731 g_return_if_reached ();
3736 modest_ui_actions_on_settings (GtkAction *action,
3741 dialog = modest_platform_get_global_settings_dialog ();
3742 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3743 gtk_widget_show_all (dialog);
3745 gtk_dialog_run (GTK_DIALOG (dialog));
3747 gtk_widget_destroy (dialog);
3751 modest_ui_actions_on_help (GtkAction *action,
3754 const gchar *help_id = NULL;
3756 if (MODEST_IS_MAIN_WINDOW (win)) {
3757 const gchar *action_name;
3758 action_name = gtk_action_get_name (action);
3760 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3761 !strcmp (action_name, "HeaderViewCSMHelp")) {
3762 GtkWidget *folder_view;
3763 TnyFolderStore *folder_store;
3764 /* Get selected folder */
3765 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3766 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3767 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3769 /* Switch help_id */
3770 if (TNY_IS_FOLDER (folder_store)) {
3771 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
3772 case TNY_FOLDER_TYPE_NORMAL:
3773 help_id = "applications_email_managefolders";
3775 case TNY_FOLDER_TYPE_INBOX:
3776 help_id = "applications_email_inbox";
3778 case TNY_FOLDER_TYPE_OUTBOX:
3779 help_id = "applications_email_outbox";
3781 case TNY_FOLDER_TYPE_SENT:
3782 help_id = "applications_email_sent";
3784 case TNY_FOLDER_TYPE_DRAFTS:
3785 help_id = "applications_email_drafts";
3787 case TNY_FOLDER_TYPE_ARCHIVE:
3788 help_id = "applications_email_managefolders";
3791 help_id = "applications_email_managefolders";
3794 help_id = "applications_email_mainview";
3796 g_object_unref (folder_store);
3798 help_id = "applications_email_mainview";
3800 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3801 help_id = "applications_email_viewer";
3802 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3803 help_id = "applications_email_editor";
3805 modest_platform_show_help (GTK_WINDOW (win), help_id);
3809 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3810 ModestWindow *window)
3812 ModestMailOperation *mail_op;
3816 headers = get_selected_headers (window);
3820 /* Create mail operation */
3821 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3823 modest_ui_actions_get_msgs_full_error_handler,
3825 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3826 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3829 g_object_unref (headers);
3830 g_object_unref (mail_op);
3834 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3835 ModestWindow *window)
3837 g_return_if_fail (MODEST_IS_WINDOW (window));
3840 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3844 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3845 ModestWindow *window)
3847 g_return_if_fail (MODEST_IS_WINDOW (window));
3850 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3854 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3855 ModestWindow *window)
3857 g_return_if_fail (MODEST_IS_WINDOW (window));
3860 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3864 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3865 ModestWindow *window)
3867 g_return_if_fail (MODEST_IS_WINDOW (window));
3870 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3874 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3875 ModestWindow *window)
3877 g_return_if_fail (MODEST_IS_WINDOW (window));
3880 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3884 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3885 ModestWindow *window)
3887 g_return_if_fail (MODEST_IS_WINDOW (window));
3890 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3894 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3895 ModestWindow *window)
3897 g_return_if_fail (MODEST_IS_WINDOW (window));
3900 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3904 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3905 ModestWindow *window)
3907 g_return_if_fail (MODEST_IS_WINDOW (window));
3910 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3914 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3916 g_return_if_fail (MODEST_IS_WINDOW (window));
3919 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3923 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3925 g_return_if_fail (MODEST_IS_WINDOW (window));
3927 modest_platform_show_search_messages (GTK_WINDOW (window));
3931 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3933 g_return_if_fail (MODEST_IS_WINDOW (win));
3934 modest_platform_show_addressbook (GTK_WINDOW (win));
3939 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3940 ModestWindow *window)
3942 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3944 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3948 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3949 ModestMailOperationState *state,
3952 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3954 /* Set send/receive operation finished */
3955 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3956 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));