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);
240 /** A convenience method, because deleting a message is
241 * otherwise complicated, and it's best to change it in one place
244 void modest_do_message_delete (TnyHeader *header, ModestWindow *win)
246 ModestMailOperation *mail_op = NULL;
247 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
248 win ? G_OBJECT(win) : NULL);
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));
258 headers_action_delete (TnyHeader *header,
262 modest_do_message_delete (header, win);
264 /* refilter treemodel to hide marked-as-deleted rows */
265 /* if (MODEST_IS_HEADER_VIEW (user_data)) */
266 /* modest_header_view_refilter (MODEST_HEADER_VIEW (user_data)); */
269 /** After deleing a message that is currently visible in a window,
270 * show the next message from the list, or close the window if there are no more messages.
272 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
274 /* Close msg view window or select next */
275 if (modest_msg_view_window_last_message_selected (win) &&
276 modest_msg_view_window_first_message_selected (win)) {
277 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
279 modest_msg_view_window_select_next_message (win);
284 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
286 TnyList *header_list = NULL;
287 TnyIterator *iter = NULL;
288 TnyHeader *header = NULL;
289 gchar *message = NULL;
292 ModestWindowMgr *mgr;
293 GtkWidget *header_view = NULL;
295 g_return_if_fail (MODEST_IS_WINDOW(win));
297 /* Check first if the header view has the focus */
298 if (MODEST_IS_MAIN_WINDOW (win)) {
300 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
301 MODEST_WIDGET_TYPE_HEADER_VIEW);
302 if (!gtk_widget_is_focus (header_view))
306 header_list = get_selected_headers (win);
307 if (!header_list) return;
309 /* Check if any of the headers are already opened, or in the process of being opened */
310 if (MODEST_IS_MAIN_WINDOW (win)) {
312 iter = tny_list_create_iterator (header_list);
314 mgr = modest_runtime_get_window_mgr ();
315 while (!tny_iterator_is_done (iter) && !found) {
316 header = TNY_HEADER (tny_iterator_get_current (iter));
317 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
318 g_object_unref (header);
319 tny_iterator_next (iter);
321 g_object_unref (iter);
326 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
327 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
329 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
333 g_object_unref (header_list);
339 if (tny_list_get_length(header_list) == 1) {
340 iter = tny_list_create_iterator (header_list);
341 header = TNY_HEADER (tny_iterator_get_current (iter));
342 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
343 g_object_unref (header);
344 g_object_unref (iter);
346 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
347 tny_list_get_length(header_list)), desc);
349 /* Confirmation dialog */
350 printf("DEBUG: %s\n", __FUNCTION__);
351 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
355 if (response == GTK_RESPONSE_OK) {
356 ModestWindow *main_window = NULL;
357 ModestWindowMgr *mgr = NULL;
358 GtkTreeModel *model = NULL;
359 GtkTreeSelection *sel = NULL;
360 GList *sel_list = NULL, *tmp = NULL;
361 GtkTreeRowReference *row_reference = NULL;
362 GtkTreePath *next_path = NULL;
364 /* Find last selected row */
365 if (MODEST_IS_MAIN_WINDOW (win)) {
366 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
367 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
368 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
369 for (tmp=sel_list; tmp; tmp=tmp->next) {
370 if (tmp->next == NULL) {
371 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
372 gtk_tree_path_next (next_path);
373 row_reference = gtk_tree_row_reference_new (model, next_path);
374 gtk_tree_path_free (next_path);
379 /* Remove each header. If it's a view window header_view == NULL */
380 do_headers_action (win, headers_action_delete, header_view);
382 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
383 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
385 /* Get main window */
386 mgr = modest_runtime_get_window_mgr ();
387 main_window = modest_window_mgr_get_main_window (mgr);
390 /* Move cursor to next row */
393 /* Select next row */
394 if (gtk_tree_row_reference_valid (row_reference)) {
395 next_path = gtk_tree_row_reference_get_path (row_reference);
396 gtk_tree_selection_select_path (sel, next_path);
397 gtk_tree_path_free (next_path);
399 if (row_reference != NULL)
400 gtk_tree_row_reference_free (row_reference);
403 /* Update toolbar dimming state */
404 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
407 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
408 g_list_free (sel_list);
414 g_object_unref (header_list);
420 /* delete either message or folder, based on where we are */
422 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
424 g_return_if_fail (MODEST_IS_WINDOW(win));
426 /* Check first if the header view has the focus */
427 if (MODEST_IS_MAIN_WINDOW (win)) {
429 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
430 MODEST_WIDGET_TYPE_FOLDER_VIEW);
431 if (gtk_widget_is_focus (w)) {
432 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
436 modest_ui_actions_on_delete_message (action, win);
442 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
444 #ifdef MODEST_PLATFORM_MAEMO
445 modest_osso_save_state();
446 #endif /* MODEST_PLATFORM_MAEMO */
448 g_debug ("closing down, clearing %d item(s) from operation queue",
449 modest_mail_operation_queue_num_elements
450 (modest_runtime_get_mail_operation_queue()));
452 /* cancel all outstanding operations */
453 modest_mail_operation_queue_cancel_all
454 (modest_runtime_get_mail_operation_queue());
456 g_debug ("queue has been cleared");
458 /* note: when modest-tny-account-store is finalized,
459 it will automatically set all network connections
466 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
469 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
471 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
472 /* gtk_widget_destroy (GTK_WIDGET (win)); */
473 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
474 /* gboolean ret_value; */
475 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
476 /* } else if (MODEST_IS_WINDOW (win)) { */
477 /* gtk_widget_destroy (GTK_WIDGET (win)); */
479 /* g_return_if_reached (); */
484 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
486 GtkClipboard *clipboard = NULL;
487 gchar *selection = NULL;
489 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
490 selection = gtk_clipboard_wait_for_text (clipboard);
492 /* Question: why is the clipboard being used here?
493 * It doesn't really make a lot of sense. */
497 modest_address_book_add_address (selection);
503 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
505 /* This is currently only implemented for Maemo */
506 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
507 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
508 run_account_setup_wizard (win);
511 /* Show the list of accounts: */
512 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
513 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
516 GtkWidget *dialog, *label;
518 /* Create the widgets */
520 dialog = gtk_dialog_new_with_buttons ("Message",
522 GTK_DIALOG_DESTROY_WITH_PARENT,
526 label = gtk_label_new ("Hello World!");
528 /* Ensure that the dialog box is destroyed when the user responds. */
530 g_signal_connect_swapped (dialog, "response",
531 G_CALLBACK (gtk_widget_destroy),
534 /* Add the label, and show everything we've added to the dialog. */
536 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
538 gtk_widget_show_all (dialog);
539 #endif /* MODEST_PLATFORM_MAEMO */
543 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
545 ModestWindow *main_window = MODEST_WINDOW (user_data);
547 /* Save any changes. */
548 modest_connection_specific_smtp_window_save_server_accounts (
549 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
550 modest_window_get_active_account (main_window));
551 gtk_widget_destroy (GTK_WIDGET (window));
557 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
559 /* This is currently only implemented for Maemo,
560 * because it requires an API (libconic) to detect different connection
563 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
565 /* Create the window if necessary: */
566 const gchar *active_account_name = modest_window_get_active_account (win);
568 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
569 * or show the default account?
570 * If we show the default account then the account name should be shown in
571 * the window when we show it. */
572 if (!active_account_name) {
573 g_warning ("%s: No account is active.", __FUNCTION__);
577 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
578 modest_connection_specific_smtp_window_fill_with_connections (
579 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
580 modest_runtime_get_account_mgr(),
581 active_account_name);
583 /* Show the window: */
584 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
585 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
586 gtk_widget_show (specific_window);
588 /* Save changes when the window is hidden: */
589 g_signal_connect (specific_window, "hide",
590 G_CALLBACK (on_smtp_servers_window_hide), win);
591 #endif /* MODEST_PLATFORM_MAEMO */
595 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
597 ModestWindow *msg_win = NULL;
599 TnyFolder *folder = NULL;
600 gchar *account_name = NULL;
601 gchar *from_str = NULL;
602 /* GError *err = NULL; */
603 TnyAccount *account = NULL;
604 ModestWindowMgr *mgr;
605 gchar *signature = NULL, *blank_and_signature = NULL;
607 /* if there are no accounts yet, just show the wizard */
608 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
609 run_account_setup_wizard (win);
613 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
615 account_name = g_strdup (modest_window_get_active_account (win));
617 g_printerr ("modest: no account found\n");
621 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
623 TNY_ACCOUNT_TYPE_STORE);
625 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
629 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
631 g_printerr ("modest: failed get from string for '%s'\n", account_name);
635 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
636 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
637 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
638 MODEST_ACCOUNT_SIGNATURE, FALSE);
639 blank_and_signature = g_strconcat ("\n", signature, NULL);
642 blank_and_signature = g_strdup ("");
645 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
647 g_printerr ("modest: failed to create new msg\n");
651 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
653 g_printerr ("modest: failed to find Drafts folder\n");
658 /* Create and register edit window */
659 /* This is destroyed by TOOD. */
660 msg_win = modest_msg_edit_window_new (msg, account_name);
661 mgr = modest_runtime_get_window_mgr ();
662 modest_window_mgr_register_window (mgr, msg_win);
665 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
667 gtk_widget_show_all (GTK_WIDGET (msg_win));
670 g_free (account_name);
672 g_free (blank_and_signature);
674 g_object_unref (msg_win);
676 g_object_unref (G_OBJECT(account));
678 g_object_unref (G_OBJECT(msg));
680 g_object_unref (G_OBJECT(folder));
684 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
688 ModestMailOperationStatus status;
690 /* If there is no message or the operation was not successful */
691 status = modest_mail_operation_get_status (mail_op);
692 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
694 /* Remove the header from the preregistered uids */
695 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
705 open_msg_cb (ModestMailOperation *mail_op,
710 ModestWindowMgr *mgr = NULL;
711 ModestWindow *parent_win = NULL;
712 ModestWindow *win = NULL;
713 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
714 gchar *account = NULL;
717 /* Do nothing if there was any problem with the mail
718 operation. The error will be shown by the error_handler of
719 the mail operation */
720 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
724 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
725 folder = tny_header_get_folder (header);
727 /* Mark header as read */
728 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
731 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
733 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
735 /* Gets folder type (OUTBOX headers will be opened in edit window */
736 if (modest_tny_folder_is_local_folder (folder))
737 folder_type = modest_tny_folder_get_local_folder_type (folder);
739 /* If the header is in the drafts folder then open the editor,
740 else the message view window */
741 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
742 /* we cannot edit without a valid account... */
743 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
744 run_account_setup_wizard(parent_win);
747 win = modest_msg_edit_window_new (msg, account);
749 gchar *uid = modest_tny_folder_get_header_unique_id (header);
751 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
752 GtkWidget *header_view;
753 GtkTreeSelection *sel;
754 GList *sel_list = NULL;
757 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
758 MODEST_WIDGET_TYPE_HEADER_VIEW);
760 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
761 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
763 if (sel_list != NULL) {
764 GtkTreeRowReference *row_reference;
766 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
767 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
768 g_list_free (sel_list);
770 win = modest_msg_view_window_new_with_header_model (msg,
775 gtk_tree_row_reference_free (row_reference);
777 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
780 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
785 /* Register and show new window */
787 mgr = modest_runtime_get_window_mgr ();
788 modest_window_mgr_register_window (mgr, win);
789 g_object_unref (win);
790 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
791 gtk_widget_show_all (GTK_WIDGET(win));
794 /* Update toolbar dimming state */
795 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
796 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
802 g_object_unref (parent_win);
803 g_object_unref (folder);
807 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
811 GObject *win = modest_mail_operation_get_source (mail_op);
813 error = modest_mail_operation_get_error (mail_op);
814 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
816 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
818 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
821 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
822 _("mail_ni_ui_folder_get_msg_folder_error"));
826 g_object_unref (win);
830 * This function is used by both modest_ui_actions_on_open and
831 * modest_ui_actions_on_header_activated. This way we always do the
832 * same when trying to open messages.
835 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
837 ModestWindowMgr *mgr = NULL;
838 TnyIterator *iter = NULL;
839 ModestMailOperation *mail_op1 = NULL;
840 ModestMailOperation *mail_op2 = NULL;
841 TnyList *not_opened_headers = NULL;
842 TnyList *not_opened_cached_headers = NULL;
843 TnyHeaderFlags flags;
845 /* Look if we already have a message view for each header. If
846 true, then remove the header from the list of headers to
848 mgr = modest_runtime_get_window_mgr ();
849 iter = tny_list_create_iterator (headers);
850 not_opened_headers = tny_simple_list_new ();
851 not_opened_cached_headers = tny_simple_list_new ();
852 while (!tny_iterator_is_done (iter)) {
854 ModestWindow *window;
858 header = TNY_HEADER (tny_iterator_get_current (iter));
859 flags = tny_header_get_flags (header);
862 found = modest_window_mgr_find_registered_header (mgr, header, &window);
864 /* Do not open again the message and present the
865 window to the user */
868 gtk_window_present (GTK_WINDOW (window));
870 /* the header has been registered already, we don't do
871 * anything but wait for the window to come up*/
872 g_warning ("debug: header %p already registered, waiting for window",
875 if (!(flags & TNY_HEADER_FLAG_CACHED))
876 tny_list_append (not_opened_headers, G_OBJECT (header));
877 /* Check if msg has already been retreived */
879 tny_list_append (not_opened_cached_headers, G_OBJECT (header));
881 g_object_unref (header);
882 tny_iterator_next (iter);
884 g_object_unref (iter);
887 /* If some messages would have to be downloaded, ask the user to
888 * make a connection. It's generally easier to do this here (in the mainloop)
889 * than later in a thread:
891 if (tny_list_get_length (not_opened_cached_headers) > 0) {
892 gboolean connected = modest_platform_connect_and_wait (GTK_WINDOW (win), NULL);
894 /* Don't go further if a connection would be necessary but none is available: */
896 g_object_unref (not_opened_headers);
897 g_object_unref (not_opened_cached_headers);
902 /* Register the headers before actually creating the windows: */
903 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
904 while (!tny_iterator_is_done (iter_not_opened)) {
905 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
906 modest_window_mgr_register_header (mgr, header);
907 g_object_unref (header);
909 tny_iterator_next (iter_not_opened);
911 g_object_unref (iter_not_opened);
912 iter_not_opened = NULL;
914 TnyIterator *iter_cached = tny_list_create_iterator (not_opened_cached_headers);
915 while (!tny_iterator_is_done (iter_cached)) {
916 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_cached));
917 modest_window_mgr_register_header (mgr, header);
918 g_object_unref (header);
920 tny_iterator_next (iter_cached);
922 g_object_unref (iter_cached);
926 /* Open each uncached message */
927 if (tny_list_get_length (not_opened_headers) > 0) {
928 mail_op1 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
930 modest_ui_actions_get_msgs_full_error_handler,
932 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op1);
933 if (tny_list_get_length (not_opened_headers) > 1) {
934 modest_mail_operation_get_msgs_full (mail_op1,
940 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
941 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
942 modest_mail_operation_get_msg (mail_op1, header, open_msg_cb, NULL);
943 g_object_unref (header);
944 g_object_unref (iter);
948 /* Open each cached message */
949 if (tny_list_get_length (not_opened_cached_headers) > 0) {
950 mail_op2 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
952 modest_ui_actions_get_msgs_full_error_handler,
954 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op2);
955 if (tny_list_get_length (not_opened_cached_headers) > 1) {
956 modest_mail_operation_get_msgs_full (mail_op2,
962 TnyIterator *iter = tny_list_create_iterator (not_opened_cached_headers);
963 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
964 modest_mail_operation_get_msg (mail_op2, header, open_msg_cb, NULL);
965 g_object_unref (header);
966 g_object_unref (iter);
971 if (not_opened_headers != NULL)
972 g_object_unref (not_opened_headers);
973 if (not_opened_cached_headers != NULL)
974 g_object_unref (not_opened_cached_headers);
976 g_object_unref (iter);
977 if (mail_op1 != NULL)
978 g_object_unref (mail_op1);
979 if (mail_op2 != NULL)
980 g_object_unref (mail_op2);
984 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
989 headers = get_selected_headers (win);
994 _modest_ui_actions_open (headers, win);
996 g_object_unref(headers);
1001 free_reply_forward_helper (gpointer data)
1003 ReplyForwardHelper *helper;
1005 helper = (ReplyForwardHelper *) data;
1006 g_free (helper->account_name);
1007 g_slice_free (ReplyForwardHelper, helper);
1011 reply_forward_cb (ModestMailOperation *mail_op,
1017 ReplyForwardHelper *rf_helper;
1018 ModestWindow *msg_win = NULL;
1019 ModestEditType edit_type;
1021 TnyAccount *account = NULL;
1022 ModestWindowMgr *mgr = NULL;
1023 gchar *signature = NULL;
1025 /* If there was any error. The mail operation could be NULL,
1026 this means that we already have the message downloaded and
1027 that we didn't do a mail operation to retrieve it */
1028 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1031 g_return_if_fail (user_data != NULL);
1032 rf_helper = (ReplyForwardHelper *) user_data;
1034 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1035 rf_helper->account_name);
1036 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1037 rf_helper->account_name,
1038 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1039 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1040 rf_helper->account_name,
1041 MODEST_ACCOUNT_SIGNATURE, FALSE);
1044 /* Create reply mail */
1045 switch (rf_helper->action) {
1048 modest_tny_msg_create_reply_msg (msg, from, signature,
1049 rf_helper->reply_forward_type,
1050 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1052 case ACTION_REPLY_TO_ALL:
1054 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
1055 MODEST_TNY_MSG_REPLY_MODE_ALL);
1056 edit_type = MODEST_EDIT_TYPE_REPLY;
1058 case ACTION_FORWARD:
1060 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1061 edit_type = MODEST_EDIT_TYPE_FORWARD;
1064 g_return_if_reached ();
1071 g_printerr ("modest: failed to create message\n");
1075 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1076 rf_helper->account_name,
1077 TNY_ACCOUNT_TYPE_STORE);
1079 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1083 /* Create and register the windows */
1084 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
1085 mgr = modest_runtime_get_window_mgr ();
1086 modest_window_mgr_register_window (mgr, msg_win);
1088 if (rf_helper->parent_window != NULL) {
1089 gdouble parent_zoom;
1091 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1092 modest_window_set_zoom (msg_win, parent_zoom);
1095 /* Show edit window */
1096 gtk_widget_show_all (GTK_WIDGET (msg_win));
1100 g_object_unref (msg_win);
1102 g_object_unref (G_OBJECT (new_msg));
1104 g_object_unref (G_OBJECT (account));
1105 /* g_object_unref (msg); */
1106 g_object_unref (header);
1107 free_reply_forward_helper (rf_helper);
1111 * Checks a list of headers. If any of them are not currently
1112 * downloaded (CACHED) then it asks the user for permission to
1115 * Returns FALSE if the user does not want to download the
1116 * messages. Returns TRUE if the user allowed the download or if all
1117 * of them are currently downloaded
1120 download_uncached_messages (TnyList *header_list, GtkWindow *win,
1125 gint uncached_messages = 0;
1127 iter = tny_list_create_iterator (header_list);
1128 while (!tny_iterator_is_done (iter)) {
1130 TnyHeaderFlags flags;
1132 header = TNY_HEADER (tny_iterator_get_current (iter));
1133 flags = tny_header_get_flags (header);
1134 /* TODO: is this the right flag?, it seems that some
1135 headers that have been previously downloaded do not
1137 if (! (flags & TNY_HEADER_FLAG_CACHED))
1138 uncached_messages ++;
1139 g_object_unref (header);
1140 tny_iterator_next (iter);
1142 g_object_unref (iter);
1144 /* Ask for user permission to download the messages */
1146 if (uncached_messages > 0) {
1147 GtkResponseType response;
1149 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1150 _("emev_nc_include_original"));
1153 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1154 ngettext("mcen_nc_get_msg",
1156 uncached_messages));
1157 if (response == GTK_RESPONSE_CANCEL)
1160 /* If a download will be necessary, make sure that we have a connection: */
1161 retval = modest_platform_connect_and_wait(win, NULL);
1169 * Common code for the reply and forward actions
1172 reply_forward (ReplyForwardAction action, ModestWindow *win)
1174 ModestMailOperation *mail_op = NULL;
1175 TnyList *header_list = NULL;
1176 ReplyForwardHelper *rf_helper = NULL;
1177 guint reply_forward_type;
1178 gboolean continue_download;
1180 g_return_if_fail (MODEST_IS_WINDOW(win));
1182 /* we need an account when editing */
1183 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1184 run_account_setup_wizard (win);
1188 header_list = get_selected_headers (win);
1192 /* Check that the messages have been previously downloaded */
1193 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win), TRUE);
1194 if (!continue_download) {
1195 g_object_unref (header_list);
1199 reply_forward_type =
1200 modest_conf_get_int (modest_runtime_get_conf (),
1201 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1203 /* We assume that we can only select messages of the
1204 same folder and that we reply all of them from the
1205 same account. In fact the interface currently only
1206 allows single selection */
1209 rf_helper = g_slice_new0 (ReplyForwardHelper);
1210 rf_helper->reply_forward_type = reply_forward_type;
1211 rf_helper->action = action;
1212 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1214 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1215 rf_helper->parent_window = GTK_WIDGET (win);
1216 if (!rf_helper->account_name)
1217 rf_helper->account_name =
1218 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1220 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1223 /* Get header and message. Do not free them here, the
1224 reply_forward_cb must do it */
1225 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1226 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1227 if (!msg || !header) {
1229 g_object_unref (msg);
1231 g_object_unref (header);
1232 g_printerr ("modest: no message found\n");
1235 reply_forward_cb (NULL, header, msg, rf_helper);
1241 /* Retrieve messages */
1242 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1244 modest_ui_actions_get_msgs_full_error_handler,
1246 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1248 /* Only reply/forward to one message */
1249 iter = tny_list_create_iterator (header_list);
1250 header = TNY_HEADER (tny_iterator_get_current (iter));
1251 g_object_unref (iter);
1253 modest_mail_operation_get_msg (mail_op,
1258 /* modest_mail_operation_get_msgs_full (mail_op, */
1260 /* reply_forward_cb, */
1262 /* free_reply_forward_helper); */
1265 g_object_unref(mail_op);
1269 g_object_unref (header_list);
1273 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1275 g_return_if_fail (MODEST_IS_WINDOW(win));
1277 reply_forward (ACTION_REPLY, win);
1281 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1283 g_return_if_fail (MODEST_IS_WINDOW(win));
1285 reply_forward (ACTION_FORWARD, win);
1289 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1291 g_return_if_fail (MODEST_IS_WINDOW(win));
1293 reply_forward (ACTION_REPLY_TO_ALL, win);
1297 modest_ui_actions_on_next (GtkAction *action,
1298 ModestWindow *window)
1300 if (MODEST_IS_MAIN_WINDOW (window)) {
1301 GtkWidget *header_view;
1303 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1304 MODEST_WIDGET_TYPE_HEADER_VIEW);
1308 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1309 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1310 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1312 g_return_if_reached ();
1317 modest_ui_actions_on_prev (GtkAction *action,
1318 ModestWindow *window)
1320 g_return_if_fail (MODEST_IS_WINDOW(window));
1322 if (MODEST_IS_MAIN_WINDOW (window)) {
1323 GtkWidget *header_view;
1324 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1325 MODEST_WIDGET_TYPE_HEADER_VIEW);
1329 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1330 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1331 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1333 g_return_if_reached ();
1338 modest_ui_actions_on_sort (GtkAction *action,
1339 ModestWindow *window)
1341 g_return_if_fail (MODEST_IS_WINDOW(window));
1343 if (MODEST_IS_MAIN_WINDOW (window)) {
1344 GtkWidget *header_view;
1345 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1346 MODEST_WIDGET_TYPE_HEADER_VIEW);
1348 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1353 /* Show sorting dialog */
1354 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1359 new_messages_arrived (ModestMailOperation *self,
1363 if (new_messages == 0)
1366 modest_platform_on_new_msg ();
1370 * This function performs the send & receive required actions. The
1371 * window is used to create the mail operation. Typically it should
1372 * always be the main window, but we pass it as argument in order to
1376 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1378 gchar *acc_name = NULL;
1379 ModestMailOperation *mail_op;
1381 /* If no account name was provided then get the current account, and if
1382 there is no current account then pick the default one: */
1383 if (!account_name) {
1384 acc_name = g_strdup (modest_window_get_active_account(win));
1386 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1388 g_printerr ("modest: cannot get default account\n");
1392 acc_name = g_strdup (account_name);
1395 /* Set send/receive operation in progress */
1396 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1398 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1400 modest_ui_actions_send_receive_error_handler,
1403 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1404 G_CALLBACK (_on_send_receive_progress_changed),
1407 /* Send & receive. */
1408 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1409 /* Receive and then send. The operation is tagged initially as
1410 a receive operation because the account update performs a
1411 receive and then a send. The operation changes its type
1412 internally, so the progress objects will receive the proper
1413 progress information */
1414 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1415 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1416 g_object_unref (G_OBJECT (mail_op));
1424 modest_ui_actions_do_cancel_send (const gchar *account_name,
1427 TnyTransportAccount *transport_account;
1428 TnySendQueue *send_queue = NULL;
1429 GError *error = NULL;
1431 /* Get transport account */
1433 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1434 (modest_runtime_get_account_store(),
1436 TNY_ACCOUNT_TYPE_TRANSPORT));
1437 if (!transport_account) {
1438 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1443 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1444 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1445 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1446 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1447 "modest: could not find send queue for account\n");
1449 /* Keeep messages in outbox folder */
1450 tny_send_queue_cancel (send_queue, FALSE, &error);
1454 if (transport_account != NULL)
1455 g_object_unref (G_OBJECT (transport_account));
1459 modest_ui_actions_cancel_send_all (ModestWindow *win)
1461 GSList *account_names, *iter;
1463 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1466 iter = account_names;
1468 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1469 iter = g_slist_next (iter);
1472 modest_account_mgr_free_account_names (account_names);
1473 account_names = NULL;
1477 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1480 /* Check if accounts exist */
1481 gboolean accounts_exist =
1482 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1484 /* If not, allow the user to create an account before trying to send/receive. */
1485 if (!accounts_exist)
1486 modest_ui_actions_on_accounts (NULL, win);
1488 /* Cancel all sending operaitons */
1489 modest_ui_actions_cancel_send_all (win);
1493 * Refreshes all accounts. This function will be used by automatic
1497 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1499 GSList *account_names, *iter;
1501 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1504 iter = account_names;
1506 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1507 iter = g_slist_next (iter);
1510 modest_account_mgr_free_account_names (account_names);
1511 account_names = NULL;
1515 * Handler of the click on Send&Receive button in the main toolbar
1518 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1520 /* Check if accounts exist */
1521 gboolean accounts_exist =
1522 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1524 /* If not, allow the user to create an account before trying to send/receive. */
1525 if (!accounts_exist)
1526 modest_ui_actions_on_accounts (NULL, win);
1528 /* Refresh currently selected folder. Note that if we only
1529 want to retrive the headers, then the refresh only will
1530 invoke a poke_status over all folders, i.e., only the
1531 total/unread count will be updated */
1532 if (MODEST_IS_MAIN_WINDOW (win)) {
1533 GtkWidget *header_view, *folder_view;
1534 TnyFolderStore *folder_store;
1536 /* Get folder and header view */
1538 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1539 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1541 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1543 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1545 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1546 MODEST_WIDGET_TYPE_HEADER_VIEW);
1548 /* We do not need to set the contents style
1549 because it hasn't changed. We also do not
1550 need to save the widget status. Just force
1552 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1553 TNY_FOLDER (folder_store),
1554 folder_refreshed_cb,
1555 MODEST_MAIN_WINDOW (win));
1559 g_object_unref (folder_store);
1562 /* Refresh the active account */
1563 modest_ui_actions_do_send_receive (NULL, win);
1568 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1571 GtkWidget *header_view;
1573 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1575 header_view = modest_main_window_get_child_widget (main_window,
1576 MODEST_WIDGET_TYPE_HEADER_VIEW);
1580 conf = modest_runtime_get_conf ();
1582 /* what is saved/restored is depending on the style; thus; we save with
1583 * old style, then update the style, and restore for this new style
1585 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1587 if (modest_header_view_get_style
1588 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1589 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1590 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1592 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1593 MODEST_HEADER_VIEW_STYLE_DETAILS);
1595 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1596 MODEST_CONF_HEADER_VIEW_KEY);
1601 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1603 ModestMainWindow *main_window)
1605 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1606 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1608 /* If no header has been selected then exit */
1613 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1614 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1616 /* Update Main window title */
1617 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1618 const gchar *subject = tny_header_get_subject (header);
1619 if (subject && strlen(subject) > 0)
1620 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1622 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1625 /* Update toolbar dimming state */
1626 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1630 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1632 ModestMainWindow *main_window)
1636 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1641 headers = tny_simple_list_new ();
1642 tny_list_prepend (headers, G_OBJECT (header));
1644 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1646 g_object_unref (headers);
1650 set_active_account_from_tny_account (TnyAccount *account,
1651 ModestWindow *window)
1653 const gchar *server_acc_name = tny_account_get_id (account);
1655 /* We need the TnyAccount provided by the
1656 account store because that is the one that
1657 knows the name of the Modest account */
1658 TnyAccount *modest_server_account = modest_server_account =
1659 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1660 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1663 const gchar *modest_acc_name =
1664 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1665 modest_window_set_active_account (window, modest_acc_name);
1666 g_object_unref (modest_server_account);
1671 folder_refreshed_cb (ModestMailOperation *mail_op,
1675 ModestMainWindow *win = NULL;
1676 GtkWidget *header_view;
1677 TnyFolder *current_folder;
1679 g_return_if_fail (TNY_IS_FOLDER (folder));
1681 win = MODEST_MAIN_WINDOW (user_data);
1683 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1686 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
1687 if (current_folder != NULL && folder != current_folder) {
1692 /* Check if folder is empty and set headers view contents style */
1693 if (tny_folder_get_all_count (folder) == 0) {
1694 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1695 modest_main_window_set_contents_style (win,
1696 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1698 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1703 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1704 TnyFolderStore *folder_store,
1706 ModestMainWindow *main_window)
1709 GtkWidget *header_view;
1711 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1713 header_view = modest_main_window_get_child_widget(main_window,
1714 MODEST_WIDGET_TYPE_HEADER_VIEW);
1718 conf = modest_runtime_get_conf ();
1720 if (TNY_IS_ACCOUNT (folder_store)) {
1722 /* Update active account */
1723 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1724 /* Show account details */
1725 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1728 if (TNY_IS_FOLDER (folder_store) && selected) {
1730 /* Update the active account */
1731 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1733 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1734 g_object_unref (account);
1738 /* Set the header style by default, it could
1739 be changed later by the refresh callback to
1741 modest_main_window_set_contents_style (main_window,
1742 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1744 /* Set folder on header view. This function
1745 will call tny_folder_refresh_async so we
1746 pass a callback that will be called when
1747 finished. We use that callback to set the
1748 empty view if there are no messages */
1749 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1750 TNY_FOLDER (folder_store),
1751 folder_refreshed_cb,
1754 /* Restore configuration. We need to do this
1755 *after* the set_folder because the widget
1756 memory asks the header view about its
1758 modest_widget_memory_restore (modest_runtime_get_conf (),
1759 G_OBJECT(header_view),
1760 MODEST_CONF_HEADER_VIEW_KEY);
1762 /* Update the active account */
1763 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1764 /* Save only if we're seeing headers */
1765 if (modest_main_window_get_contents_style (main_window) ==
1766 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1767 modest_widget_memory_save (conf, G_OBJECT (header_view),
1768 MODEST_CONF_HEADER_VIEW_KEY);
1769 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1773 /* Update toolbar dimming state */
1774 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1778 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1785 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1787 online = tny_device_is_online (modest_runtime_get_device());
1790 /* already online -- the item is simply not there... */
1791 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1793 GTK_MESSAGE_WARNING,
1795 _("The %s you selected cannot be found"),
1797 gtk_dialog_run (GTK_DIALOG(dialog));
1799 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1803 GTK_RESPONSE_REJECT,
1805 GTK_RESPONSE_ACCEPT,
1807 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1808 "Do you want to get online?"), item);
1809 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1810 gtk_label_new (txt), FALSE, FALSE, 0);
1811 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1814 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1815 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1816 // modest_platform_connect_and_wait ();
1819 gtk_widget_destroy (dialog);
1823 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1826 /* g_message ("%s %s", __FUNCTION__, link); */
1831 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1834 modest_platform_activate_uri (link);
1838 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1841 modest_platform_show_uri_popup (link);
1845 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1848 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1852 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1853 const gchar *address,
1856 /* g_message ("%s %s", __FUNCTION__, address); */
1860 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1862 TnyTransportAccount *transport_account;
1863 ModestMailOperation *mail_operation;
1865 gchar *account_name, *from;
1866 ModestAccountMgr *account_mgr;
1867 gchar *info_text = NULL;
1869 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1871 data = modest_msg_edit_window_get_msg_data (edit_window);
1873 account_mgr = modest_runtime_get_account_mgr();
1874 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1876 account_name = modest_account_mgr_get_default_account (account_mgr);
1877 if (!account_name) {
1878 g_printerr ("modest: no account found\n");
1879 modest_msg_edit_window_free_msg_data (edit_window, data);
1883 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1884 account_name = g_strdup (data->account_name);
1888 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1889 (modest_runtime_get_account_store(),
1891 TNY_ACCOUNT_TYPE_TRANSPORT));
1892 if (!transport_account) {
1893 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1894 g_free (account_name);
1895 modest_msg_edit_window_free_msg_data (edit_window, data);
1898 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1900 /* Create the mail operation */
1901 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1902 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1904 modest_mail_operation_save_to_drafts (mail_operation,
1916 data->priority_flags);
1919 g_free (account_name);
1920 g_object_unref (G_OBJECT (transport_account));
1921 g_object_unref (G_OBJECT (mail_operation));
1923 modest_msg_edit_window_free_msg_data (edit_window, data);
1925 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1926 modest_platform_information_banner (NULL, NULL, info_text);
1930 /* For instance, when clicking the Send toolbar button when editing a message: */
1932 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1934 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1936 if (!modest_msg_edit_window_check_names (edit_window))
1939 /* Offer the connection dialog, if necessary: */
1940 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window), NULL))
1943 /* FIXME: Code added just for testing. The final version will
1944 use the send queue provided by tinymail and some
1946 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1947 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1949 account_name = modest_account_mgr_get_default_account (account_mgr);
1951 if (!account_name) {
1952 g_printerr ("modest: no account found\n");
1956 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1958 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1959 account_name = g_strdup (data->account_name);
1962 /* Get the currently-active transport account for this modest account: */
1963 TnyTransportAccount *transport_account =
1964 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1965 (modest_runtime_get_account_store(),
1967 if (!transport_account) {
1968 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1969 g_free (account_name);
1970 modest_msg_edit_window_free_msg_data (edit_window, data);
1974 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1976 /* mail content checks and dialogs */
1977 if (data->subject == NULL || data->subject[0] == '\0') {
1978 GtkResponseType response;
1979 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1980 _("mcen_nc_subject_is_empty_send"));
1981 if (response == GTK_RESPONSE_CANCEL) {
1982 g_free (account_name);
1987 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1988 GtkResponseType response;
1989 gchar *note_message;
1990 gchar *note_subject = data->subject;
1991 if (note_subject == NULL || note_subject[0] == '\0')
1992 note_subject = _("mail_va_no_subject");
1993 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1994 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1996 g_free (note_message);
1997 if (response == GTK_RESPONSE_CANCEL) {
1998 g_free (account_name);
2003 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
2005 /* Create the mail operation */
2006 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
2007 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2009 modest_mail_operation_send_new_mail (mail_operation,
2020 data->priority_flags);
2024 g_free (account_name);
2025 g_object_unref (G_OBJECT (transport_account));
2026 g_object_unref (G_OBJECT (mail_operation));
2028 modest_msg_edit_window_free_msg_data (edit_window, data);
2029 modest_msg_edit_window_set_sent (edit_window, TRUE);
2031 /* Save settings and close the window: */
2032 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2036 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2037 ModestMsgEditWindow *window)
2039 ModestMsgEditFormatState *format_state = NULL;
2041 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2042 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2044 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2047 format_state = modest_msg_edit_window_get_format_state (window);
2048 g_return_if_fail (format_state != NULL);
2050 format_state->bold = gtk_toggle_action_get_active (action);
2051 modest_msg_edit_window_set_format_state (window, format_state);
2052 g_free (format_state);
2057 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2058 ModestMsgEditWindow *window)
2060 ModestMsgEditFormatState *format_state = NULL;
2062 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2063 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2065 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2068 format_state = modest_msg_edit_window_get_format_state (window);
2069 g_return_if_fail (format_state != NULL);
2071 format_state->italics = gtk_toggle_action_get_active (action);
2072 modest_msg_edit_window_set_format_state (window, format_state);
2073 g_free (format_state);
2078 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2079 ModestMsgEditWindow *window)
2081 ModestMsgEditFormatState *format_state = NULL;
2083 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2084 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2086 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2089 format_state = modest_msg_edit_window_get_format_state (window);
2090 g_return_if_fail (format_state != NULL);
2092 format_state->bullet = gtk_toggle_action_get_active (action);
2093 modest_msg_edit_window_set_format_state (window, format_state);
2094 g_free (format_state);
2099 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2100 GtkRadioAction *selected,
2101 ModestMsgEditWindow *window)
2103 ModestMsgEditFormatState *format_state = NULL;
2104 GtkJustification value;
2106 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2108 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2111 value = gtk_radio_action_get_current_value (selected);
2113 format_state = modest_msg_edit_window_get_format_state (window);
2114 g_return_if_fail (format_state != NULL);
2116 format_state->justification = value;
2117 modest_msg_edit_window_set_format_state (window, format_state);
2118 g_free (format_state);
2122 modest_ui_actions_on_select_editor_color (GtkAction *action,
2123 ModestMsgEditWindow *window)
2125 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2126 g_return_if_fail (GTK_IS_ACTION (action));
2128 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2131 modest_msg_edit_window_select_color (window);
2135 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2136 ModestMsgEditWindow *window)
2138 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2139 g_return_if_fail (GTK_IS_ACTION (action));
2141 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2144 modest_msg_edit_window_select_background_color (window);
2148 modest_ui_actions_on_insert_image (GtkAction *action,
2149 ModestMsgEditWindow *window)
2151 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2152 g_return_if_fail (GTK_IS_ACTION (action));
2154 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2157 modest_msg_edit_window_insert_image (window);
2161 modest_ui_actions_on_attach_file (GtkAction *action,
2162 ModestMsgEditWindow *window)
2164 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2165 g_return_if_fail (GTK_IS_ACTION (action));
2167 modest_msg_edit_window_attach_file (window);
2171 modest_ui_actions_on_remove_attachments (GtkAction *action,
2172 ModestMsgEditWindow *window)
2174 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2175 g_return_if_fail (GTK_IS_ACTION (action));
2177 modest_msg_edit_window_remove_attachments (window, NULL);
2181 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2184 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2185 const GError *error = modest_mail_operation_get_error (mail_op);
2189 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2190 modest_mail_operation_get_error (mail_op)->message);
2195 modest_ui_actions_create_folder(GtkWidget *parent_window,
2196 GtkWidget *folder_view)
2198 TnyFolderStore *parent_folder;
2200 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2202 if (parent_folder) {
2203 gboolean finished = FALSE;
2205 gchar *folder_name = NULL, *suggested_name = NULL;
2207 /* Run the new folder dialog */
2209 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2214 g_free (suggested_name);
2215 suggested_name = NULL;
2217 if (result == GTK_RESPONSE_REJECT) {
2220 ModestMailOperation *mail_op;
2221 TnyFolder *new_folder = NULL;
2223 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2224 G_OBJECT(parent_window),
2225 modest_ui_actions_new_folder_error_handler,
2228 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2230 new_folder = modest_mail_operation_create_folder (mail_op,
2232 (const gchar *) folder_name);
2234 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2237 g_object_unref (new_folder);
2240 g_object_unref (mail_op);
2243 suggested_name = folder_name;
2247 g_object_unref (parent_folder);
2252 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2254 GtkWidget *folder_view;
2256 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2258 folder_view = modest_main_window_get_child_widget (main_window,
2259 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2263 modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2267 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2270 GObject *win = modest_mail_operation_get_source (mail_op);
2271 const GError *error = NULL;
2272 const gchar *message = NULL;
2274 /* Get error message */
2275 error = modest_mail_operation_get_error (mail_op);
2276 if (error != NULL && error->message != NULL) {
2277 message = error->message;
2279 message = _("!!! FIXME: Unable to rename");
2282 /* Show notification dialog */
2283 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
2284 g_object_unref (win);
2288 modest_ui_actions_on_rename_folder (GtkAction *action,
2289 ModestMainWindow *main_window)
2291 TnyFolderStore *folder;
2292 GtkWidget *folder_view;
2293 GtkWidget *header_view;
2295 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2297 folder_view = modest_main_window_get_child_widget (main_window,
2298 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2302 header_view = modest_main_window_get_child_widget (main_window,
2303 MODEST_WIDGET_TYPE_HEADER_VIEW);
2308 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2312 /* Offer the connection dialog if necessary: */
2313 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2314 g_object_unref (G_OBJECT (folder));
2319 if (TNY_IS_FOLDER (folder)) {
2322 const gchar *current_name;
2324 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2325 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2326 current_name, &folder_name);
2328 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2329 ModestMailOperation *mail_op;
2332 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2333 G_OBJECT(main_window),
2334 modest_ui_actions_rename_folder_error_handler,
2338 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2341 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2343 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2344 TNY_FOLDER(folder), TRUE);
2347 modest_header_view_clear ((ModestHeaderView *) header_view);
2349 modest_mail_operation_rename_folder (mail_op,
2350 TNY_FOLDER (folder),
2351 (const gchar *) folder_name);
2353 g_object_unref (mail_op);
2354 g_free (folder_name);
2357 g_object_unref (folder);
2361 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2364 GObject *win = modest_mail_operation_get_source (mail_op);
2366 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2367 _("mail_in_ui_folder_delete_error"));
2368 g_object_unref (win);
2372 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2374 TnyFolderStore *folder;
2375 GtkWidget *folder_view;
2379 g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2381 folder_view = modest_main_window_get_child_widget (main_window,
2382 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2386 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2388 /* Show an error if it's an account */
2389 if (!TNY_IS_FOLDER (folder)) {
2390 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2391 _("mail_in_ui_folder_delete_error"));
2392 g_object_unref (G_OBJECT (folder));
2396 /* Offer the connection dialog if necessary: */
2397 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2398 g_object_unref (G_OBJECT (folder));
2403 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2404 tny_folder_get_name (TNY_FOLDER (folder)));
2405 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2406 (const gchar *) message);
2409 if (response == GTK_RESPONSE_OK) {
2410 ModestMailOperation *mail_op =
2411 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2412 G_OBJECT(main_window),
2413 modest_ui_actions_delete_folder_error_handler,
2416 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2418 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2419 g_object_unref (G_OBJECT (mail_op));
2422 g_object_unref (G_OBJECT (folder));
2426 modest_ui_actions_on_delete_folder (GtkAction *action,
2427 ModestMainWindow *main_window)
2429 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2431 delete_folder (main_window, FALSE);
2435 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2437 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2439 delete_folder (main_window, TRUE);
2443 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2444 const gchar* server_account_name,
2449 ModestMainWindow *main_window)
2451 g_return_if_fail(server_account_name);
2452 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2454 /* Initalize output parameters: */
2461 #ifdef MODEST_PLATFORM_MAEMO
2462 /* Maemo uses a different (awkward) button order,
2463 * It should probably just use gtk_alternative_dialog_button_order ().
2465 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2469 GTK_RESPONSE_ACCEPT,
2471 GTK_RESPONSE_REJECT,
2474 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2478 GTK_RESPONSE_REJECT,
2480 GTK_RESPONSE_ACCEPT,
2482 #endif /* MODEST_PLATFORM_MAEMO */
2484 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2486 gchar *server_name = modest_server_account_get_hostname (
2487 modest_runtime_get_account_mgr(), server_account_name);
2488 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2489 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2494 /* This causes a warning because the logical ID has no %s in it,
2495 * though the translation does, but there is not much we can do about that: */
2496 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2497 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2500 g_free (server_name);
2504 gchar *initial_username = modest_server_account_get_username (
2505 modest_runtime_get_account_mgr(), server_account_name);
2507 GtkWidget *entry_username = gtk_entry_new ();
2508 if (initial_username)
2509 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2510 /* Dim this if a connection has ever succeeded with this username,
2511 * as per the UI spec: */
2512 const gboolean username_known =
2513 modest_server_account_get_username_has_succeeded(
2514 modest_runtime_get_account_mgr(), server_account_name);
2515 gtk_widget_set_sensitive (entry_username, !username_known);
2517 #ifdef MODEST_PLATFORM_MAEMO
2518 /* Auto-capitalization is the default, so let's turn it off: */
2519 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2521 /* Create a size group to be used by all captions.
2522 * Note that HildonCaption does not create a default size group if we do not specify one.
2523 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2524 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2526 GtkWidget *caption = hildon_caption_new (sizegroup,
2527 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2528 gtk_widget_show (entry_username);
2529 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2530 FALSE, FALSE, MODEST_MARGIN_HALF);
2531 gtk_widget_show (caption);
2533 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2535 #endif /* MODEST_PLATFORM_MAEMO */
2538 GtkWidget *entry_password = gtk_entry_new ();
2539 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2540 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2542 #ifdef MODEST_PLATFORM_MAEMO
2543 /* Auto-capitalization is the default, so let's turn it off: */
2544 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2545 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2547 caption = hildon_caption_new (sizegroup,
2548 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2549 gtk_widget_show (entry_password);
2550 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2551 FALSE, FALSE, MODEST_MARGIN_HALF);
2552 gtk_widget_show (caption);
2553 g_object_unref (sizegroup);
2555 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2557 #endif /* MODEST_PLATFORM_MAEMO */
2559 /* This is not in the Maemo UI spec:
2560 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2561 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2565 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2567 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2569 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2571 modest_server_account_set_username (
2572 modest_runtime_get_account_mgr(), server_account_name,
2575 const gboolean username_was_changed =
2576 (strcmp (*username, initial_username) != 0);
2577 if (username_was_changed) {
2578 g_warning ("%s: tinymail does not yet support changing the "
2579 "username in the get_password() callback.\n", __FUNCTION__);
2584 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2586 /* We do not save the password in the configuration,
2587 * because this function is only called for passwords that should
2588 * not be remembered:
2589 modest_server_account_set_password (
2590 modest_runtime_get_account_mgr(), server_account_name,
2609 /* This is not in the Maemo UI spec:
2610 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2616 gtk_widget_destroy (dialog);
2618 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2622 modest_ui_actions_on_cut (GtkAction *action,
2623 ModestWindow *window)
2625 GtkWidget *focused_widget;
2627 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2628 if (GTK_IS_EDITABLE (focused_widget)) {
2629 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2630 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2631 GtkTextBuffer *buffer;
2632 GtkClipboard *clipboard;
2634 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2635 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2636 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2637 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2638 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2639 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2640 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2641 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2646 modest_ui_actions_on_copy (GtkAction *action,
2647 ModestWindow *window)
2649 GtkClipboard *clipboard;
2650 GtkWidget *focused_widget;
2652 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2653 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2655 if (GTK_IS_LABEL (focused_widget)) {
2656 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2657 } else if (GTK_IS_EDITABLE (focused_widget)) {
2658 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2659 } else if (GTK_IS_HTML (focused_widget)) {
2660 gtk_html_copy (GTK_HTML (focused_widget));
2661 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2662 GtkTextBuffer *buffer;
2663 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2664 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2665 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2666 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2667 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2668 TnyIterator *iter = tny_list_create_iterator (header_list);
2669 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2670 TnyFolder *folder = tny_header_get_folder (header);
2671 TnyAccount *account = tny_folder_get_account (folder);
2672 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2673 /* If it's POP then ask */
2674 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2675 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2676 g_object_unref (account);
2677 g_object_unref (folder);
2678 g_object_unref (header);
2679 g_object_unref (iter);
2681 /* Check that the messages have been previously downloaded */
2682 gboolean continue_download = TRUE;
2684 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window), FALSE);
2685 if (continue_download)
2686 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2687 g_object_unref (header_list);
2688 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2689 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2692 /* Show information banner */
2693 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2698 modest_ui_actions_on_undo (GtkAction *action,
2699 ModestWindow *window)
2701 ModestEmailClipboard *clipboard = NULL;
2703 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2704 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2705 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2706 /* Clear clipboard source */
2707 clipboard = modest_runtime_get_email_clipboard ();
2708 modest_email_clipboard_clear (clipboard);
2711 g_return_if_reached ();
2716 modest_ui_actions_on_redo (GtkAction *action,
2717 ModestWindow *window)
2719 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2720 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2723 g_return_if_reached ();
2729 paste_msgs_cb (const GObject *object, gpointer user_data)
2731 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2732 g_return_if_fail (GTK_IS_WIDGET (user_data));
2734 /* destroy information note */
2735 gtk_widget_destroy (GTK_WIDGET(user_data));
2739 modest_ui_actions_on_paste (GtkAction *action,
2740 ModestWindow *window)
2742 GtkWidget *focused_widget = NULL;
2743 GtkWidget *inf_note = NULL;
2744 ModestMailOperation *mail_op = NULL;
2746 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2747 if (GTK_IS_EDITABLE (focused_widget)) {
2748 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2749 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2750 GtkTextBuffer *buffer;
2751 GtkClipboard *clipboard;
2753 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2754 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2755 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2756 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2757 ModestEmailClipboard *clipboard = NULL;
2758 TnyFolder *src_folder = NULL;
2759 TnyFolderStore *folder_store = NULL;
2760 TnyList *data = NULL;
2761 gboolean delete = FALSE;
2763 /* Check clipboard source */
2764 clipboard = modest_runtime_get_email_clipboard ();
2765 if (modest_email_clipboard_cleared (clipboard))
2768 /* Get elements to paste */
2769 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2771 /* Create a new mail operation */
2772 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2773 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2776 /* Get destination folder */
2777 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2779 /* Launch notification */
2780 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2781 _CS("ckct_nw_pasting"));
2782 if (inf_note != NULL) {
2783 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
2784 gtk_widget_show (GTK_WIDGET(inf_note));
2787 /* transfer messages */
2789 modest_mail_operation_xfer_msgs (mail_op,
2791 TNY_FOLDER (folder_store),
2796 } else if (src_folder != NULL) {
2797 modest_mail_operation_xfer_folder (mail_op,
2807 g_object_unref (data);
2808 if (src_folder != NULL)
2809 g_object_unref (src_folder);
2810 if (folder_store != NULL)
2811 g_object_unref (folder_store);
2817 modest_ui_actions_on_select_all (GtkAction *action,
2818 ModestWindow *window)
2820 GtkWidget *focused_widget;
2822 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2823 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2824 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2825 } else if (GTK_IS_LABEL (focused_widget)) {
2826 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2827 } else if (GTK_IS_EDITABLE (focused_widget)) {
2828 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2829 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2830 GtkTextBuffer *buffer;
2831 GtkTextIter start, end;
2833 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2834 gtk_text_buffer_get_start_iter (buffer, &start);
2835 gtk_text_buffer_get_end_iter (buffer, &end);
2836 gtk_text_buffer_select_range (buffer, &start, &end);
2837 } else if (GTK_IS_HTML (focused_widget)) {
2838 gtk_html_select_all (GTK_HTML (focused_widget));
2839 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2840 GtkWidget *header_view = focused_widget;
2841 GtkTreeSelection *selection = NULL;
2843 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2844 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2845 MODEST_WIDGET_TYPE_HEADER_VIEW);
2847 /* Select all messages */
2848 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2849 gtk_tree_selection_select_all (selection);
2851 /* Set focuse on header view */
2852 gtk_widget_grab_focus (header_view);
2858 modest_ui_actions_on_mark_as_read (GtkAction *action,
2859 ModestWindow *window)
2861 g_return_if_fail (MODEST_IS_WINDOW(window));
2863 /* Mark each header as read */
2864 do_headers_action (window, headers_action_mark_as_read, NULL);
2868 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2869 ModestWindow *window)
2871 g_return_if_fail (MODEST_IS_WINDOW(window));
2873 /* Mark each header as read */
2874 do_headers_action (window, headers_action_mark_as_unread, NULL);
2878 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2879 GtkRadioAction *selected,
2880 ModestWindow *window)
2884 value = gtk_radio_action_get_current_value (selected);
2885 if (MODEST_IS_WINDOW (window)) {
2886 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2890 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2891 GtkRadioAction *selected,
2892 ModestWindow *window)
2894 TnyHeaderFlags flags;
2895 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2897 flags = gtk_radio_action_get_current_value (selected);
2898 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2901 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2902 GtkRadioAction *selected,
2903 ModestWindow *window)
2907 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2909 file_format = gtk_radio_action_get_current_value (selected);
2910 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2915 modest_ui_actions_on_zoom_plus (GtkAction *action,
2916 ModestWindow *window)
2918 g_return_if_fail (MODEST_IS_WINDOW (window));
2920 modest_window_zoom_plus (MODEST_WINDOW (window));
2924 modest_ui_actions_on_zoom_minus (GtkAction *action,
2925 ModestWindow *window)
2927 g_return_if_fail (MODEST_IS_WINDOW (window));
2929 modest_window_zoom_minus (MODEST_WINDOW (window));
2933 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2934 ModestWindow *window)
2936 ModestWindowMgr *mgr;
2937 gboolean fullscreen, active;
2938 g_return_if_fail (MODEST_IS_WINDOW (window));
2940 mgr = modest_runtime_get_window_mgr ();
2942 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2943 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2945 if (active != fullscreen) {
2946 modest_window_mgr_set_fullscreen_mode (mgr, active);
2947 gtk_window_present (GTK_WINDOW (window));
2952 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2953 ModestWindow *window)
2955 ModestWindowMgr *mgr;
2956 gboolean fullscreen;
2958 g_return_if_fail (MODEST_IS_WINDOW (window));
2960 mgr = modest_runtime_get_window_mgr ();
2961 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2962 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2964 gtk_window_present (GTK_WINDOW (window));
2968 * Used by modest_ui_actions_on_details to call do_headers_action
2971 headers_action_show_details (TnyHeader *header,
2972 ModestWindow *window,
2979 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2982 gtk_widget_show_all (dialog);
2983 gtk_dialog_run (GTK_DIALOG (dialog));
2985 gtk_widget_destroy (dialog);
2989 * Show the folder details in a ModestDetailsDialog widget
2992 show_folder_details (TnyFolder *folder,
2998 dialog = modest_details_dialog_new_with_folder (window, folder);
3001 gtk_widget_show_all (dialog);
3002 gtk_dialog_run (GTK_DIALOG (dialog));
3004 gtk_widget_destroy (dialog);
3008 * Show the header details in a ModestDetailsDialog widget
3011 modest_ui_actions_on_details (GtkAction *action,
3014 TnyList * headers_list;
3018 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3021 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3024 g_object_unref (msg);
3026 headers_list = get_selected_headers (win);
3030 iter = tny_list_create_iterator (headers_list);
3032 header = TNY_HEADER (tny_iterator_get_current (iter));
3033 headers_action_show_details (header, win, NULL);
3034 g_object_unref (header);
3036 g_object_unref (iter);
3037 g_object_unref (headers_list);
3039 } else if (MODEST_IS_MAIN_WINDOW (win)) {
3040 GtkWidget *folder_view, *header_view;
3042 /* Check which widget has the focus */
3043 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3044 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3045 if (gtk_widget_is_focus (folder_view)) {
3046 TnyFolderStore *folder_store
3047 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3048 if (!folder_store) {
3049 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3052 /* Show only when it's a folder */
3053 /* This function should not be called for account items,
3054 * because we dim the menu item for them. */
3055 if (TNY_IS_FOLDER (folder_store)) {
3056 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3059 g_object_unref (folder_store);
3062 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3063 MODEST_WIDGET_TYPE_HEADER_VIEW);
3064 /* Show details of each header */
3065 do_headers_action (win, headers_action_show_details, header_view);
3071 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3072 ModestMsgEditWindow *window)
3074 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3076 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3080 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3081 ModestMsgEditWindow *window)
3083 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3085 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3089 modest_ui_actions_toggle_folders_view (GtkAction *action,
3090 ModestMainWindow *main_window)
3092 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3094 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3095 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3097 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3101 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3102 ModestWindow *window)
3104 gboolean active, fullscreen = FALSE;
3105 ModestWindowMgr *mgr;
3107 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3109 /* Check if we want to toggle the toolbar vuew in fullscreen
3111 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3112 "ViewShowToolbarFullScreen")) {
3116 /* Toggle toolbar */
3117 mgr = modest_runtime_get_window_mgr ();
3118 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3122 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3123 ModestMsgEditWindow *window)
3125 modest_msg_edit_window_select_font (window);
3129 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3130 const gchar *display_name,
3133 /* Do not change the application name if the widget has not
3134 the focus. This callback could be called even if the folder
3135 view has not the focus, because the handled signal could be
3136 emitted when the folder view is redrawn */
3137 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3139 gtk_window_set_title (window, display_name);
3141 gtk_window_set_title (window, " ");
3146 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3148 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3149 modest_msg_edit_window_select_contacts (window);
3153 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3155 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3156 modest_msg_edit_window_check_names (window);
3160 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3162 modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3163 GTK_WIDGET (user_data));
3167 create_move_to_dialog (GtkWindow *win,
3168 GtkWidget *folder_view,
3169 GtkWidget **tree_view)
3171 GtkWidget *dialog, *scroll;
3172 GtkWidget *new_button;
3174 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3176 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3179 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
3180 /* We do this manually so GTK+ does not associate a response ID for
3182 new_button = gtk_button_new_from_stock (GTK_STOCK_NEW);
3183 gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3184 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
3186 /* Create scrolled window */
3187 scroll = gtk_scrolled_window_new (NULL, NULL);
3188 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3189 GTK_POLICY_AUTOMATIC,
3190 GTK_POLICY_AUTOMATIC);
3192 /* Create folder view */
3193 *tree_view = modest_platform_create_folder_view (NULL);
3195 g_signal_connect (G_OBJECT (new_button), "clicked", G_CALLBACK(create_move_to_dialog_on_new_folder), *tree_view);
3197 /* It could happen that we're trying to move a message from a
3198 window (msg window for example) after the main window was
3199 closed, so we can not just get the model of the folder
3201 if (MODEST_IS_FOLDER_VIEW (folder_view))
3202 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3203 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3205 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3206 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3208 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3210 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3212 /* Add scroll to dialog */
3213 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3214 scroll, TRUE, TRUE, 0);
3216 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3217 gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3223 * Returns TRUE if at least one of the headers of the list belongs to
3224 * a message that has been fully retrieved.
3227 has_retrieved_msgs (TnyList *list)
3230 gboolean found = FALSE;
3232 iter = tny_list_create_iterator (list);
3233 while (tny_iterator_is_done (iter) && !found) {
3235 TnyHeaderFlags flags;
3237 header = TNY_HEADER (tny_iterator_get_current (iter));
3238 flags = tny_header_get_flags (header);
3239 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
3243 tny_iterator_next (iter);
3245 g_object_unref (iter);
3251 * Shows a confirmation dialog to the user when we're moving messages
3252 * from a remote server to the local storage. Returns the dialog
3253 * response. If it's other kind of movement the it always returns
3257 msgs_move_to_confirmation (GtkWindow *win,
3258 TnyFolder *dest_folder,
3261 gint response = GTK_RESPONSE_OK;
3263 /* If the destination is a local folder */
3264 if (modest_tny_folder_is_local_folder (dest_folder)) {
3265 TnyFolder *src_folder;
3269 /* Get source folder */
3270 iter = tny_list_create_iterator (headers);
3271 header = TNY_HEADER (tny_iterator_get_current (iter));
3272 src_folder = tny_header_get_folder (header);
3273 g_object_unref (header);
3274 g_object_unref (iter);
3276 /* if no src_folder, message may be an attahcment */
3277 if (src_folder == NULL)
3278 return GTK_RESPONSE_CANCEL;
3280 /* If the source is a remote folder */
3281 if (!modest_tny_folder_is_local_folder (src_folder)) {
3282 const gchar *message;
3284 if (has_retrieved_msgs (headers))
3285 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3286 tny_list_get_length (headers));
3288 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3289 tny_list_get_length (headers));
3291 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3292 (const gchar *) message);
3294 g_object_unref (src_folder);
3302 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3304 ModestMsgViewWindow *self = NULL;
3306 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3307 self = MODEST_MSG_VIEW_WINDOW (object);
3309 if (!modest_msg_view_window_select_next_message (self))
3310 if (!modest_msg_view_window_select_previous_message (self))
3311 /* No more messages to view, so close this window */
3312 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3316 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3319 GObject *win = modest_mail_operation_get_source (mail_op);
3320 const GError *error = NULL;
3321 const gchar *message = NULL;
3323 /* Get error message */
3324 error = modest_mail_operation_get_error (mail_op);
3325 if (error != NULL && error->message != NULL) {
3326 message = error->message;
3328 message = _("mail_in_ui_folder_move_target_error");
3331 /* Show notification dialog */
3332 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3333 g_object_unref (win);
3337 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3340 GObject *win = modest_mail_operation_get_source (mail_op);
3341 const GError *error = modest_mail_operation_get_error (mail_op);
3343 g_return_if_fail (error != NULL);
3344 if (error->message != NULL)
3345 g_printerr ("modest: %s\n", error->message);
3347 g_printerr ("modest: unkonw error on send&receive operation");
3349 /* Show error message */
3350 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3351 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3352 /* _CS("sfil_ib_unable_to_receive")); */
3354 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3355 /* _CS("sfil_ib_unable_to_send")); */
3356 g_object_unref (win);
3360 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3367 gint pending_purges = 0;
3368 gboolean some_purged = FALSE;
3369 ModestWindow *win = MODEST_WINDOW (user_data);
3370 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
3372 /* If there was any error */
3373 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
3374 modest_window_mgr_unregister_header (mgr, header);
3378 /* Once the message has been retrieved for purging, we check if
3379 * it's all ok for purging */
3381 parts = tny_simple_list_new ();
3382 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3383 iter = tny_list_create_iterator (parts);
3385 while (!tny_iterator_is_done (iter)) {
3387 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3388 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)) {
3389 if (tny_mime_part_is_purged (part))
3394 tny_iterator_next (iter);
3397 if (pending_purges>0) {
3399 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3401 if (response == GTK_RESPONSE_OK) {
3402 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3403 tny_iterator_first (iter);
3404 while (!tny_iterator_is_done (iter)) {
3407 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3408 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))
3409 tny_mime_part_set_purged (part);
3410 tny_iterator_next (iter);
3413 tny_msg_rewrite_cache (msg);
3416 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3419 /* remove attachments */
3420 tny_iterator_first (iter);
3421 while (!tny_iterator_is_done (iter)) {
3424 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3425 g_object_unref (part);
3426 tny_iterator_next (iter);
3428 modest_window_mgr_unregister_header (mgr, header);
3430 g_object_unref (iter);
3431 g_object_unref (parts);
3435 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3436 ModestMainWindow *win)
3438 GtkWidget *header_view;
3439 TnyList *header_list;
3442 TnyHeaderFlags flags;
3443 ModestWindow *msg_view_window = NULL;
3446 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3448 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3449 MODEST_WIDGET_TYPE_HEADER_VIEW);
3451 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3453 if (tny_list_get_length (header_list) == 1) {
3454 iter = tny_list_create_iterator (header_list);
3455 header = TNY_HEADER (tny_iterator_get_current (iter));
3456 g_object_unref (iter);
3461 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3462 header, &msg_view_window);
3463 flags = tny_header_get_flags (header);
3464 if (!(flags & TNY_HEADER_FLAG_CACHED))
3467 if (msg_view_window != NULL)
3468 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3470 /* do nothing; uid was registered before, so window is probably on it's way */
3471 g_warning ("debug: header %p has already been registered", header);
3474 ModestMailOperation *mail_op = NULL;
3475 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3476 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3478 modest_ui_actions_get_msgs_full_error_handler,
3480 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3481 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3483 g_object_unref (mail_op);
3486 g_object_unref (header);
3488 g_object_unref (header_list);
3492 * Utility function that transfer messages from both the main window
3493 * and the msg view window when using the "Move to" dialog
3496 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
3499 TnyList *headers = NULL;
3502 if (!TNY_IS_FOLDER (dst_folder)) {
3503 modest_platform_information_banner (GTK_WIDGET (win),
3505 _CS("ckdg_ib_unable_to_move_to_current_location"));
3509 /* Get selected headers */
3510 headers = get_selected_headers (MODEST_WINDOW (win));
3512 /* Ask for user confirmation */
3513 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3514 TNY_FOLDER (dst_folder),
3517 /* Transfer messages */
3518 if (response == GTK_RESPONSE_OK) {
3519 ModestMailOperation *mail_op =
3520 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3522 modest_ui_actions_move_folder_error_handler,
3524 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3527 modest_mail_operation_xfer_msgs (mail_op,
3529 TNY_FOLDER (dst_folder),
3531 (MODEST_IS_MSG_VIEW_WINDOW (win)) ? transfer_msgs_from_viewer_cb : NULL,
3534 g_object_unref (G_OBJECT (mail_op));
3536 g_object_unref (headers);
3541 * UI handler for the "Move to" action when invoked from the
3545 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3546 GtkWidget *folder_view,
3547 TnyFolderStore *dst_folder,
3548 ModestMainWindow *win)
3550 GtkWidget *header_view = NULL;
3551 ModestMailOperation *mail_op = NULL;
3552 TnyFolderStore *src_folder;
3554 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3556 /* Get the source folder */
3557 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3559 /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3560 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3564 /* Get header view */
3566 modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW);
3568 /* Get folder or messages to transfer */
3569 if (gtk_widget_is_focus (folder_view)) {
3571 /* Allow only to transfer folders to the local root folder */
3572 if (TNY_IS_ACCOUNT (dst_folder) &&
3573 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder))
3576 /* Clean folder on header view before moving it */
3577 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3579 if (TNY_IS_FOLDER (src_folder)) {
3581 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3583 modest_ui_actions_move_folder_error_handler,
3585 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3588 modest_mail_operation_xfer_folder (mail_op,
3589 TNY_FOLDER (src_folder),
3592 /* Unref mail operation */
3593 g_object_unref (G_OBJECT (mail_op));
3595 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3597 } else if (gtk_widget_is_focus (header_view)) {
3598 /* Transfer messages */
3599 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3604 g_object_unref (src_folder);
3609 * UI handler for the "Move to" action when invoked from the
3610 * ModestMsgViewWindow
3613 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3614 TnyFolderStore *dst_folder,
3615 ModestMsgViewWindow *win)
3617 TnyHeader *header = NULL;
3618 TnyFolder *src_folder;
3620 /* Create header list */
3621 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3622 src_folder = tny_header_get_folder(header);
3623 g_object_unref (header);
3625 /* Transfer the message */
3626 if (modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (src_folder)))
3627 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3629 g_object_unref (src_folder);
3633 modest_ui_actions_on_move_to (GtkAction *action,
3636 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3638 TnyFolderStore *dst_folder = NULL;
3639 ModestMainWindow *main_window;
3641 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3642 MODEST_IS_MSG_VIEW_WINDOW (win));
3644 /* Get the main window if exists */
3645 if (MODEST_IS_MAIN_WINDOW (win))
3646 main_window = MODEST_MAIN_WINDOW (win);
3649 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3651 /* Get the folder view widget if exists */
3653 folder_view = modest_main_window_get_child_widget (main_window,
3654 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3658 /* Create and run the dialog */
3659 dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
3660 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3661 result = gtk_dialog_run (GTK_DIALOG(dialog));
3662 g_object_ref (tree_view);
3663 gtk_widget_destroy (dialog);
3665 if (result != GTK_RESPONSE_ACCEPT)
3668 dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3669 /* Offer the connection dialog if necessary: */
3670 if (modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3673 /* Do window specific stuff */
3674 if (MODEST_IS_MAIN_WINDOW (win))
3675 modest_ui_actions_on_main_window_move_to (action,
3678 MODEST_MAIN_WINDOW (win));
3680 modest_ui_actions_on_msg_view_window_move_to (action,
3682 MODEST_MSG_VIEW_WINDOW (win));
3685 g_object_unref (dst_folder);
3689 * Calls #HeadersFunc for each header already selected in the main
3690 * window or the message currently being shown in the msg view window
3693 do_headers_action (ModestWindow *win,
3697 TnyList *headers_list;
3703 headers_list = get_selected_headers (win);
3707 /* Get the folder */
3708 iter = tny_list_create_iterator (headers_list);
3709 header = TNY_HEADER (tny_iterator_get_current (iter));
3710 folder = tny_header_get_folder (header);
3711 g_object_unref (header);
3713 /* Call the function for each header */
3714 while (!tny_iterator_is_done (iter)) {
3715 header = TNY_HEADER (tny_iterator_get_current (iter));
3716 func (header, win, user_data);
3717 g_object_unref (header);
3718 tny_iterator_next (iter);
3721 /* Trick: do a poke status in order to speed up the signaling
3723 tny_folder_poke_status (folder);
3726 g_object_unref (folder);
3727 g_object_unref (iter);
3728 g_object_unref (headers_list);
3732 modest_ui_actions_view_attachment (GtkAction *action,
3733 ModestWindow *window)
3735 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3736 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3738 /* not supported window for this action */
3739 g_return_if_reached ();
3744 modest_ui_actions_save_attachments (GtkAction *action,
3745 ModestWindow *window)
3747 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3748 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3750 /* not supported window for this action */
3751 g_return_if_reached ();
3756 modest_ui_actions_remove_attachments (GtkAction *action,
3757 ModestWindow *window)
3759 if (MODEST_IS_MAIN_WINDOW (window)) {
3760 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
3761 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3762 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
3764 /* not supported window for this action */
3765 g_return_if_reached ();
3770 modest_ui_actions_on_settings (GtkAction *action,
3775 dialog = modest_platform_get_global_settings_dialog ();
3776 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3777 gtk_widget_show_all (dialog);
3779 gtk_dialog_run (GTK_DIALOG (dialog));
3781 gtk_widget_destroy (dialog);
3785 modest_ui_actions_on_help (GtkAction *action,
3788 const gchar *help_id = NULL;
3790 if (MODEST_IS_MAIN_WINDOW (win)) {
3791 const gchar *action_name;
3792 action_name = gtk_action_get_name (action);
3794 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3795 !strcmp (action_name, "HeaderViewCSMHelp")) {
3796 GtkWidget *folder_view;
3797 TnyFolderStore *folder_store;
3798 /* Get selected folder */
3799 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3800 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3801 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3803 /* Switch help_id */
3804 if (TNY_IS_FOLDER (folder_store)) {
3805 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
3806 case TNY_FOLDER_TYPE_NORMAL:
3807 help_id = "applications_email_managefolders";
3809 case TNY_FOLDER_TYPE_INBOX:
3810 help_id = "applications_email_inbox";
3812 case TNY_FOLDER_TYPE_OUTBOX:
3813 help_id = "applications_email_outbox";
3815 case TNY_FOLDER_TYPE_SENT:
3816 help_id = "applications_email_sent";
3818 case TNY_FOLDER_TYPE_DRAFTS:
3819 help_id = "applications_email_drafts";
3821 case TNY_FOLDER_TYPE_ARCHIVE:
3822 help_id = "applications_email_managefolders";
3825 help_id = "applications_email_managefolders";
3828 help_id = "applications_email_mainview";
3830 g_object_unref (folder_store);
3832 help_id = "applications_email_mainview";
3834 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3835 help_id = "applications_email_viewer";
3836 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3837 help_id = "applications_email_editor";
3839 modest_platform_show_help (GTK_WINDOW (win), help_id);
3843 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3844 ModestWindow *window)
3846 ModestMailOperation *mail_op;
3850 headers = get_selected_headers (window);
3854 /* Create mail operation */
3855 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3857 modest_ui_actions_get_msgs_full_error_handler,
3859 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3860 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3863 g_object_unref (headers);
3864 g_object_unref (mail_op);
3868 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3869 ModestWindow *window)
3871 g_return_if_fail (MODEST_IS_WINDOW (window));
3874 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3878 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3879 ModestWindow *window)
3881 g_return_if_fail (MODEST_IS_WINDOW (window));
3884 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3888 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3889 ModestWindow *window)
3891 g_return_if_fail (MODEST_IS_WINDOW (window));
3894 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3898 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3899 ModestWindow *window)
3901 g_return_if_fail (MODEST_IS_WINDOW (window));
3904 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3908 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3909 ModestWindow *window)
3911 g_return_if_fail (MODEST_IS_WINDOW (window));
3914 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3918 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3919 ModestWindow *window)
3921 g_return_if_fail (MODEST_IS_WINDOW (window));
3924 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3928 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3929 ModestWindow *window)
3931 g_return_if_fail (MODEST_IS_WINDOW (window));
3934 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3938 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3939 ModestWindow *window)
3941 g_return_if_fail (MODEST_IS_WINDOW (window));
3944 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3948 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3950 g_return_if_fail (MODEST_IS_WINDOW (window));
3953 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3957 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3959 g_return_if_fail (MODEST_IS_WINDOW (window));
3961 modest_platform_show_search_messages (GTK_WINDOW (window));
3965 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3967 g_return_if_fail (MODEST_IS_WINDOW (win));
3968 modest_platform_show_addressbook (GTK_WINDOW (win));
3973 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3974 ModestWindow *window)
3976 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3978 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3982 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3983 ModestMailOperationState *state,
3986 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3988 /* Set send/receive operation finished */
3989 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3990 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));