1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #endif /*HAVE_CONFIG_H*/
34 #include <glib/gi18n.h>
35 #include <glib/gprintf.h>
37 #include <modest-runtime.h>
38 #include <modest-tny-folder.h>
39 #include <modest-tny-msg.h>
40 #include <modest-tny-account.h>
41 #include <modest-address-book.h>
42 #include "modest-error.h"
43 #include "modest-ui-actions.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
47 #include <tny-mime-part.h>
49 #ifdef MODEST_PLATFORM_MAEMO
50 #include "maemo/modest-osso-state-saving.h"
51 #include "maemo/modest-maemo-utils.h"
52 #include "maemo/modest-hildon-includes.h"
53 #endif /* MODEST_PLATFORM_MAEMO */
55 #include "widgets/modest-ui-constants.h"
56 #include <widgets/modest-main-window.h>
57 #include <widgets/modest-msg-view-window.h>
58 #include <widgets/modest-account-view-window.h>
59 #include <widgets/modest-details-dialog.h>
60 #include <widgets/modest-attachments-view.h>
61 #include "widgets/modest-folder-view.h"
62 #include "widgets/modest-global-settings-dialog.h"
63 #include "modest-connection-specific-smtp-window.h"
64 #include "modest-account-mgr-helpers.h"
65 #include "modest-mail-operation.h"
66 #include "modest-text-utils.h"
68 #ifdef MODEST_HAVE_EASYSETUP
69 #include "easysetup/modest-easysetup-wizard.h"
70 #endif /* MODEST_HAVE_EASYSETUP */
72 #include <modest-widget-memory.h>
73 #include <tny-error.h>
74 #include <tny-simple-list.h>
75 #include <tny-msg-view.h>
76 #include <tny-device.h>
77 #include <tny-merge-folder.h>
79 #include <gtkhtml/gtkhtml.h>
81 typedef struct _GetMsgAsyncHelper {
83 ModestMailOperation *mail_op;
90 typedef enum _ReplyForwardAction {
96 typedef struct _ReplyForwardHelper {
97 guint reply_forward_type;
98 ReplyForwardAction action;
100 GtkWidget *parent_window;
101 } ReplyForwardHelper;
105 * The do_headers_action uses this kind of functions to perform some
106 * action to each member of a list of headers
108 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
110 static void do_headers_action (ModestWindow *win,
114 static void open_msg_cb (ModestMailOperation *mail_op,
119 static void reply_forward_cb (ModestMailOperation *mail_op,
124 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
126 static void folder_refreshed_cb (ModestMailOperation *mail_op,
130 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
131 ModestMailOperationState *state,
137 run_account_setup_wizard (ModestWindow *win)
139 ModestEasysetupWizardDialog *wizard;
141 g_return_if_fail (MODEST_IS_WINDOW(win));
143 wizard = modest_easysetup_wizard_dialog_new ();
144 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
145 gtk_dialog_run (GTK_DIALOG (wizard));
146 gtk_widget_destroy (GTK_WIDGET (wizard));
151 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
154 const gchar *authors[] = {
155 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
158 about = gtk_about_dialog_new ();
159 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
160 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
161 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
162 _("Copyright (c) 2006, Nokia Corporation\n"
163 "All rights reserved."));
164 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
165 _("a modest e-mail client\n\n"
166 "design and implementation: Dirk-Jan C. Binnema\n"
167 "contributions from the fine people at KC and Ig\n"
168 "uses the tinymail email framework written by Philip van Hoof"));
169 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
170 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
172 gtk_dialog_run (GTK_DIALOG (about));
173 gtk_widget_destroy(about);
177 * Gets the list of currently selected messages. If the win is the
178 * main window, then it returns a newly allocated list of the headers
179 * selected in the header view. If win is the msg view window, then
180 * the value returned is a list with just a single header.
182 * The caller of this funcion must free the list.
185 get_selected_headers (ModestWindow *win)
187 if (MODEST_IS_MAIN_WINDOW(win)) {
188 GtkWidget *header_view;
190 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
191 MODEST_WIDGET_TYPE_HEADER_VIEW);
192 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
194 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
195 /* for MsgViewWindows, we simply return a list with one element */
197 TnyList *list = NULL;
199 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
200 if (header != NULL) {
201 list = tny_simple_list_new ();
202 tny_list_prepend (list, G_OBJECT(header));
203 g_object_unref (G_OBJECT(header));
213 headers_action_mark_as_read (TnyHeader *header,
217 TnyHeaderFlags flags;
219 g_return_if_fail (TNY_IS_HEADER(header));
221 flags = tny_header_get_flags (header);
222 if (flags & TNY_HEADER_FLAG_SEEN) return;
223 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
227 headers_action_mark_as_unread (TnyHeader *header,
231 TnyHeaderFlags flags;
233 g_return_if_fail (TNY_IS_HEADER(header));
235 flags = tny_header_get_flags (header);
236 if (flags & TNY_HEADER_FLAG_SEEN) {
237 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
241 /** A convenience method, because deleting a message is
242 * otherwise complicated, and it's best to change it in one place
245 void modest_do_message_delete (TnyHeader *header, ModestWindow *win)
247 ModestMailOperation *mail_op = NULL;
248 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
249 win ? G_OBJECT(win) : NULL);
250 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
253 /* Always delete. TODO: Move to trash still not supported */
254 modest_mail_operation_remove_msg (mail_op, header, FALSE);
255 g_object_unref (G_OBJECT (mail_op));
259 headers_action_delete (TnyHeader *header,
263 modest_do_message_delete (header, win);
265 /* refilter treemodel to hide marked-as-deleted rows */
266 /* if (MODEST_IS_HEADER_VIEW (user_data)) */
267 /* modest_header_view_refilter (MODEST_HEADER_VIEW (user_data)); */
270 /** After deleing a message that is currently visible in a window,
271 * show the next message from the list, or close the window if there are no more messages.
273 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
275 /* Close msg view window or select next */
276 if (modest_msg_view_window_last_message_selected (win) &&
277 modest_msg_view_window_first_message_selected (win)) {
278 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
280 modest_msg_view_window_select_next_message (win);
285 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
287 TnyList *header_list = NULL;
288 TnyIterator *iter = NULL;
289 TnyHeader *header = NULL;
290 gchar *message = NULL;
293 ModestWindowMgr *mgr;
294 GtkWidget *header_view = NULL;
296 g_return_if_fail (MODEST_IS_WINDOW(win));
298 /* Check first if the header view has the focus */
299 if (MODEST_IS_MAIN_WINDOW (win)) {
301 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
302 MODEST_WIDGET_TYPE_HEADER_VIEW);
303 if (!gtk_widget_is_focus (header_view))
307 header_list = get_selected_headers (win);
308 if (!header_list) return;
310 /* Check if any of the headers are already opened, or in the process of being opened */
311 if (MODEST_IS_MAIN_WINDOW (win)) {
313 iter = tny_list_create_iterator (header_list);
315 mgr = modest_runtime_get_window_mgr ();
316 while (!tny_iterator_is_done (iter) && !found) {
317 header = TNY_HEADER (tny_iterator_get_current (iter));
319 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
320 g_object_unref (header);
323 tny_iterator_next (iter);
325 g_object_unref (iter);
330 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
331 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
333 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
337 g_object_unref (header_list);
343 if (tny_list_get_length(header_list) == 1) {
344 iter = tny_list_create_iterator (header_list);
345 header = TNY_HEADER (tny_iterator_get_current (iter));
347 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
348 g_object_unref (header);
351 g_object_unref (iter);
353 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
354 tny_list_get_length(header_list)), desc);
356 /* Confirmation dialog */
357 printf("DEBUG: %s\n", __FUNCTION__);
358 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
362 if (response == GTK_RESPONSE_OK) {
363 ModestWindow *main_window = NULL;
364 ModestWindowMgr *mgr = NULL;
365 GtkTreeModel *model = NULL;
366 GtkTreeSelection *sel = NULL;
367 GList *sel_list = NULL, *tmp = NULL;
368 GtkTreeRowReference *row_reference = NULL;
369 GtkTreePath *next_path = NULL;
371 /* Find last selected row */
372 if (MODEST_IS_MAIN_WINDOW (win)) {
373 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
374 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
375 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
376 for (tmp=sel_list; tmp; tmp=tmp->next) {
377 if (tmp->next == NULL) {
378 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
379 gtk_tree_path_next (next_path);
380 row_reference = gtk_tree_row_reference_new (model, next_path);
381 gtk_tree_path_free (next_path);
386 /* Remove each header. If it's a view window header_view == NULL */
387 do_headers_action (win, headers_action_delete, header_view);
389 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
390 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
392 /* Get main window */
393 mgr = modest_runtime_get_window_mgr ();
394 main_window = modest_window_mgr_get_main_window (mgr);
397 /* Move cursor to next row */
400 /* Select next row */
401 if (gtk_tree_row_reference_valid (row_reference)) {
402 next_path = gtk_tree_row_reference_get_path (row_reference);
403 gtk_tree_selection_select_path (sel, next_path);
404 gtk_tree_path_free (next_path);
406 if (row_reference != NULL)
407 gtk_tree_row_reference_free (row_reference);
410 /* Update toolbar dimming state */
411 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
414 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
415 g_list_free (sel_list);
421 g_object_unref (header_list);
427 /* delete either message or folder, based on where we are */
429 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
431 g_return_if_fail (MODEST_IS_WINDOW(win));
433 /* Check first if the header view has the focus */
434 if (MODEST_IS_MAIN_WINDOW (win)) {
436 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
437 MODEST_WIDGET_TYPE_FOLDER_VIEW);
438 if (gtk_widget_is_focus (w)) {
439 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
443 modest_ui_actions_on_delete_message (action, win);
449 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
451 #ifdef MODEST_PLATFORM_MAEMO
452 modest_osso_save_state();
453 #endif /* MODEST_PLATFORM_MAEMO */
455 g_debug ("closing down, clearing %d item(s) from operation queue",
456 modest_mail_operation_queue_num_elements
457 (modest_runtime_get_mail_operation_queue()));
459 /* cancel all outstanding operations */
460 modest_mail_operation_queue_cancel_all
461 (modest_runtime_get_mail_operation_queue());
463 g_debug ("queue has been cleared");
465 /* note: when modest-tny-account-store is finalized,
466 it will automatically set all network connections
473 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
477 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
479 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
480 /* gtk_widget_destroy (GTK_WIDGET (win)); */
481 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
482 /* gboolean ret_value; */
483 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
484 /* } else if (MODEST_IS_WINDOW (win)) { */
485 /* gtk_widget_destroy (GTK_WIDGET (win)); */
487 /* g_return_if_reached (); */
492 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
494 GtkClipboard *clipboard = NULL;
495 gchar *selection = NULL;
497 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
498 selection = gtk_clipboard_wait_for_text (clipboard);
500 /* Question: why is the clipboard being used here?
501 * It doesn't really make a lot of sense. */
505 modest_address_book_add_address (selection);
511 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
513 /* This is currently only implemented for Maemo */
514 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
515 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
516 run_account_setup_wizard (win);
519 /* Show the list of accounts: */
520 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
521 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
524 GtkWidget *dialog, *label;
526 /* Create the widgets */
528 dialog = gtk_dialog_new_with_buttons ("Message",
530 GTK_DIALOG_DESTROY_WITH_PARENT,
534 label = gtk_label_new ("Hello World!");
536 /* Ensure that the dialog box is destroyed when the user responds. */
538 g_signal_connect_swapped (dialog, "response",
539 G_CALLBACK (gtk_widget_destroy),
542 /* Add the label, and show everything we've added to the dialog. */
544 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
546 gtk_widget_show_all (dialog);
547 #endif /* MODEST_PLATFORM_MAEMO */
551 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
553 ModestWindow *main_window = MODEST_WINDOW (user_data);
555 /* Save any changes. */
556 modest_connection_specific_smtp_window_save_server_accounts (
557 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
558 modest_window_get_active_account (main_window));
559 gtk_widget_destroy (GTK_WIDGET (window));
565 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
567 /* This is currently only implemented for Maemo,
568 * because it requires an API (libconic) to detect different connection
571 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
573 /* Create the window if necessary: */
574 const gchar *active_account_name = modest_window_get_active_account (win);
576 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
577 * or show the default account?
578 * If we show the default account then the account name should be shown in
579 * the window when we show it. */
580 if (!active_account_name) {
581 g_warning ("%s: No account is active.", __FUNCTION__);
585 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
586 modest_connection_specific_smtp_window_fill_with_connections (
587 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
588 modest_runtime_get_account_mgr(),
589 active_account_name);
591 /* Show the window: */
592 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
593 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
594 gtk_widget_show (specific_window);
596 /* Save changes when the window is hidden: */
597 g_signal_connect (specific_window, "hide",
598 G_CALLBACK (on_smtp_servers_window_hide), win);
599 #endif /* MODEST_PLATFORM_MAEMO */
603 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
605 ModestWindow *msg_win = NULL;
607 TnyFolder *folder = NULL;
608 gchar *account_name = NULL;
609 gchar *from_str = NULL;
610 /* GError *err = NULL; */
611 TnyAccount *account = NULL;
612 ModestWindowMgr *mgr;
613 gchar *signature = NULL, *blank_and_signature = NULL;
615 /* if there are no accounts yet, just show the wizard */
616 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
617 run_account_setup_wizard (win);
621 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
623 account_name = g_strdup (modest_window_get_active_account (win));
625 g_printerr ("modest: no account found\n");
629 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
631 TNY_ACCOUNT_TYPE_STORE);
633 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
637 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
639 g_printerr ("modest: failed get from string for '%s'\n", account_name);
643 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
644 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
645 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
646 MODEST_ACCOUNT_SIGNATURE, FALSE);
647 blank_and_signature = g_strconcat ("\n", signature, NULL);
650 blank_and_signature = g_strdup ("");
653 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
655 g_printerr ("modest: failed to create new msg\n");
659 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
661 g_printerr ("modest: failed to find Drafts folder\n");
666 /* Create and register edit window */
667 /* This is destroyed by TOOD. */
668 msg_win = modest_msg_edit_window_new (msg, account_name);
669 mgr = modest_runtime_get_window_mgr ();
670 modest_window_mgr_register_window (mgr, msg_win);
673 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
675 gtk_widget_show_all (GTK_WIDGET (msg_win));
678 g_free (account_name);
680 g_free (blank_and_signature);
682 g_object_unref (msg_win);
684 g_object_unref (G_OBJECT(account));
686 g_object_unref (G_OBJECT(msg));
688 g_object_unref (G_OBJECT(folder));
692 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
696 ModestMailOperationStatus status;
698 /* If there is no message or the operation was not successful */
699 status = modest_mail_operation_get_status (mail_op);
700 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
702 /* Remove the header from the preregistered uids */
703 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
713 open_msg_cb (ModestMailOperation *mail_op,
718 ModestWindowMgr *mgr = NULL;
719 ModestWindow *parent_win = NULL;
720 ModestWindow *win = NULL;
721 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
722 gchar *account = NULL;
725 /* Do nothing if there was any problem with the mail
726 operation. The error will be shown by the error_handler of
727 the mail operation */
728 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
732 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
733 folder = tny_header_get_folder (header);
735 /* Mark header as read */
736 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
739 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
741 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
743 /* Gets folder type (OUTBOX headers will be opened in edit window */
744 if (modest_tny_folder_is_local_folder (folder))
745 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
747 /* If the header is in the drafts folder then open the editor,
748 else the message view window */
749 if ((folder_type == TNY_FOLDER_TYPE_DRAFTS) ||
750 (folder_type == TNY_FOLDER_TYPE_OUTBOX)) {
751 /* we cannot edit without a valid account... */
752 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
753 run_account_setup_wizard(parent_win);
756 win = modest_msg_edit_window_new (msg, account);
758 gchar *uid = modest_tny_folder_get_header_unique_id (header);
760 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
761 GtkWidget *header_view;
762 GtkTreeSelection *sel;
763 GList *sel_list = NULL;
766 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
767 MODEST_WIDGET_TYPE_HEADER_VIEW);
769 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
770 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
772 if (sel_list != NULL) {
773 GtkTreeRowReference *row_reference;
775 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
776 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
777 g_list_free (sel_list);
779 win = modest_msg_view_window_new_with_header_model (msg,
784 gtk_tree_row_reference_free (row_reference);
786 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
789 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
794 /* Register and show new window */
796 mgr = modest_runtime_get_window_mgr ();
797 modest_window_mgr_register_window (mgr, win);
798 g_object_unref (win);
799 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
800 gtk_widget_show_all (GTK_WIDGET(win));
803 /* Update toolbar dimming state */
804 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
805 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
811 g_object_unref (parent_win);
812 g_object_unref (folder);
816 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
820 GObject *win = modest_mail_operation_get_source (mail_op);
822 error = modest_mail_operation_get_error (mail_op);
823 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
825 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
827 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
830 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
831 _("mail_ni_ui_folder_get_msg_folder_error"));
835 g_object_unref (win);
839 * This function is used by both modest_ui_actions_on_open and
840 * modest_ui_actions_on_header_activated. This way we always do the
841 * same when trying to open messages.
844 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
846 ModestWindowMgr *mgr = NULL;
847 TnyIterator *iter = NULL;
848 ModestMailOperation *mail_op = NULL;
849 TnyList *not_opened_headers = NULL;
850 TnyHeaderFlags flags = 0;
852 /* Look if we already have a message view for each header. If
853 true, then remove the header from the list of headers to
855 mgr = modest_runtime_get_window_mgr ();
856 iter = tny_list_create_iterator (headers);
857 not_opened_headers = tny_simple_list_new ();
859 while (!tny_iterator_is_done (iter)) {
861 ModestWindow *window = NULL;
862 TnyHeader *header = NULL;
863 gboolean found = FALSE;
865 header = TNY_HEADER (tny_iterator_get_current (iter));
867 flags = tny_header_get_flags (header);
870 found = modest_window_mgr_find_registered_header (mgr, header, &window);
872 /* Do not open again the message and present the
873 window to the user */
876 gtk_window_present (GTK_WINDOW (window));
878 /* the header has been registered already, we don't do
879 * anything but wait for the window to come up*/
880 g_debug ("header %p already registered, waiting for window", header);
882 tny_list_append (not_opened_headers, G_OBJECT (header));
886 g_object_unref (header);
888 tny_iterator_next (iter);
890 g_object_unref (iter);
893 /* If some messages would have to be downloaded, ask the user to
894 * make a connection. It's generally easier to do this here (in the mainloop)
895 * than later in a thread:
897 if (tny_list_get_length (not_opened_headers) > 0) {
898 gboolean connected = modest_platform_connect_and_wait (GTK_WINDOW (win), NULL);
900 /* Don't go further if a connection would be necessary but none is available: */
902 g_object_unref (not_opened_headers);
907 /* Register the headers before actually creating the windows: */
908 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
909 while (!tny_iterator_is_done (iter_not_opened)) {
910 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
912 modest_window_mgr_register_header (mgr, header);
913 g_object_unref (header);
916 tny_iterator_next (iter_not_opened);
918 g_object_unref (iter_not_opened);
919 iter_not_opened = NULL;
921 /* Open each message */
922 if (tny_list_get_length (not_opened_headers) > 0) {
923 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
925 modest_ui_actions_get_msgs_full_error_handler,
927 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
928 if (tny_list_get_length (not_opened_headers) > 1) {
929 modest_mail_operation_get_msgs_full (mail_op,
935 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
936 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
937 modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
938 g_object_unref (header);
939 g_object_unref (iter);
941 g_object_unref (mail_op);
945 if (not_opened_headers != NULL)
946 g_object_unref (not_opened_headers);
950 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
955 headers = get_selected_headers (win);
960 _modest_ui_actions_open (headers, win);
962 g_object_unref(headers);
967 free_reply_forward_helper (gpointer data)
969 ReplyForwardHelper *helper;
971 helper = (ReplyForwardHelper *) data;
972 g_free (helper->account_name);
973 g_slice_free (ReplyForwardHelper, helper);
977 reply_forward_cb (ModestMailOperation *mail_op,
983 ReplyForwardHelper *rf_helper;
984 ModestWindow *msg_win = NULL;
985 ModestEditType edit_type;
987 TnyAccount *account = NULL;
988 ModestWindowMgr *mgr = NULL;
989 gchar *signature = NULL;
991 /* If there was any error. The mail operation could be NULL,
992 this means that we already have the message downloaded and
993 that we didn't do a mail operation to retrieve it */
994 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
997 g_return_if_fail (user_data != NULL);
998 rf_helper = (ReplyForwardHelper *) user_data;
1000 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1001 rf_helper->account_name);
1002 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1003 rf_helper->account_name,
1004 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1005 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1006 rf_helper->account_name,
1007 MODEST_ACCOUNT_SIGNATURE, FALSE);
1010 /* Create reply mail */
1011 switch (rf_helper->action) {
1014 modest_tny_msg_create_reply_msg (msg, from, signature,
1015 rf_helper->reply_forward_type,
1016 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1018 case ACTION_REPLY_TO_ALL:
1020 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
1021 MODEST_TNY_MSG_REPLY_MODE_ALL);
1022 edit_type = MODEST_EDIT_TYPE_REPLY;
1024 case ACTION_FORWARD:
1026 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1027 edit_type = MODEST_EDIT_TYPE_FORWARD;
1030 g_return_if_reached ();
1037 g_printerr ("modest: failed to create message\n");
1041 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1042 rf_helper->account_name,
1043 TNY_ACCOUNT_TYPE_STORE);
1045 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1049 /* Create and register the windows */
1050 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
1051 mgr = modest_runtime_get_window_mgr ();
1052 modest_window_mgr_register_window (mgr, msg_win);
1054 if (rf_helper->parent_window != NULL) {
1055 gdouble parent_zoom;
1057 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1058 modest_window_set_zoom (msg_win, parent_zoom);
1061 /* Show edit window */
1062 gtk_widget_show_all (GTK_WIDGET (msg_win));
1066 g_object_unref (msg_win);
1068 g_object_unref (G_OBJECT (new_msg));
1070 g_object_unref (G_OBJECT (account));
1071 /* g_object_unref (msg); */
1072 g_object_unref (header);
1073 free_reply_forward_helper (rf_helper);
1077 * Checks a list of headers. If any of them are not currently
1078 * downloaded (CACHED) then it asks the user for permission to
1081 * Returns FALSE if the user does not want to download the
1082 * messages. Returns TRUE if the user allowed the download or if all
1083 * of them are currently downloaded
1086 download_uncached_messages (TnyList *header_list, GtkWindow *win,
1091 gint uncached_messages = 0;
1093 iter = tny_list_create_iterator (header_list);
1094 while (!tny_iterator_is_done (iter)) {
1096 TnyHeaderFlags flags;
1098 header = TNY_HEADER (tny_iterator_get_current (iter));
1100 flags = tny_header_get_flags (header);
1101 /* TODO: is this the right flag?, it seems that some
1102 headers that have been previously downloaded do not
1104 if (! (flags & TNY_HEADER_FLAG_CACHED))
1105 uncached_messages ++;
1106 g_object_unref (header);
1109 tny_iterator_next (iter);
1111 g_object_unref (iter);
1113 /* Ask for user permission to download the messages */
1115 if (uncached_messages > 0) {
1116 GtkResponseType response;
1118 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1119 _("emev_nc_include_original"));
1122 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1123 ngettext("mcen_nc_get_msg",
1125 uncached_messages));
1126 if (response == GTK_RESPONSE_CANCEL)
1129 /* If a download will be necessary, make sure that we have a connection: */
1130 retval = modest_platform_connect_and_wait(win, NULL);
1138 * Common code for the reply and forward actions
1141 reply_forward (ReplyForwardAction action, ModestWindow *win)
1143 ModestMailOperation *mail_op = NULL;
1144 TnyList *header_list = NULL;
1145 ReplyForwardHelper *rf_helper = NULL;
1146 guint reply_forward_type;
1147 gboolean continue_download;
1149 g_return_if_fail (MODEST_IS_WINDOW(win));
1151 /* we need an account when editing */
1152 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1153 run_account_setup_wizard (win);
1157 header_list = get_selected_headers (win);
1161 /* Check that the messages have been previously downloaded */
1162 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win), TRUE);
1163 if (!continue_download) {
1164 g_object_unref (header_list);
1168 reply_forward_type =
1169 modest_conf_get_int (modest_runtime_get_conf (),
1170 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1172 /* We assume that we can only select messages of the
1173 same folder and that we reply all of them from the
1174 same account. In fact the interface currently only
1175 allows single selection */
1178 rf_helper = g_slice_new0 (ReplyForwardHelper);
1179 rf_helper->reply_forward_type = reply_forward_type;
1180 rf_helper->action = action;
1181 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1183 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1184 rf_helper->parent_window = GTK_WIDGET (win);
1185 if (!rf_helper->account_name)
1186 rf_helper->account_name =
1187 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1189 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1192 /* Get header and message. Do not free them here, the
1193 reply_forward_cb must do it */
1194 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1195 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1196 if (!msg || !header) {
1198 g_object_unref (msg);
1200 g_object_unref (header);
1201 g_printerr ("modest: no message found\n");
1204 reply_forward_cb (NULL, header, msg, rf_helper);
1210 /* Retrieve messages */
1211 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1213 modest_ui_actions_get_msgs_full_error_handler,
1215 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1217 /* Only reply/forward to one message */
1218 iter = tny_list_create_iterator (header_list);
1219 header = TNY_HEADER (tny_iterator_get_current (iter));
1220 g_object_unref (iter);
1223 modest_mail_operation_get_msg (mail_op,
1228 /* modest_mail_operation_get_msgs_full (mail_op, */
1230 /* reply_forward_cb, */
1232 /* free_reply_forward_helper); */
1234 g_object_unref (header);
1238 g_object_unref(mail_op);
1242 g_object_unref (header_list);
1246 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1248 g_return_if_fail (MODEST_IS_WINDOW(win));
1250 reply_forward (ACTION_REPLY, win);
1254 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1256 g_return_if_fail (MODEST_IS_WINDOW(win));
1258 reply_forward (ACTION_FORWARD, win);
1262 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1264 g_return_if_fail (MODEST_IS_WINDOW(win));
1266 reply_forward (ACTION_REPLY_TO_ALL, win);
1270 modest_ui_actions_on_next (GtkAction *action,
1271 ModestWindow *window)
1273 if (MODEST_IS_MAIN_WINDOW (window)) {
1274 GtkWidget *header_view;
1276 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1277 MODEST_WIDGET_TYPE_HEADER_VIEW);
1281 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1282 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1283 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1285 g_return_if_reached ();
1290 modest_ui_actions_on_prev (GtkAction *action,
1291 ModestWindow *window)
1293 g_return_if_fail (MODEST_IS_WINDOW(window));
1295 if (MODEST_IS_MAIN_WINDOW (window)) {
1296 GtkWidget *header_view;
1297 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1298 MODEST_WIDGET_TYPE_HEADER_VIEW);
1302 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1303 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1304 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1306 g_return_if_reached ();
1311 modest_ui_actions_on_sort (GtkAction *action,
1312 ModestWindow *window)
1314 g_return_if_fail (MODEST_IS_WINDOW(window));
1316 if (MODEST_IS_MAIN_WINDOW (window)) {
1317 GtkWidget *header_view;
1318 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1319 MODEST_WIDGET_TYPE_HEADER_VIEW);
1321 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1326 /* Show sorting dialog */
1327 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1332 new_messages_arrived (ModestMailOperation *self,
1336 if (new_messages == 0)
1339 modest_platform_on_new_msg ();
1343 * This function performs the send & receive required actions. The
1344 * window is used to create the mail operation. Typically it should
1345 * always be the main window, but we pass it as argument in order to
1349 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1351 gchar *acc_name = NULL;
1352 ModestMailOperation *mail_op;
1354 /* If no account name was provided then get the current account, and if
1355 there is no current account then pick the default one: */
1356 if (!account_name) {
1357 acc_name = g_strdup (modest_window_get_active_account(win));
1359 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1361 g_printerr ("modest: cannot get default account\n");
1365 acc_name = g_strdup (account_name);
1368 /* Set send/receive operation in progress */
1369 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1371 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1373 modest_ui_actions_send_receive_error_handler,
1376 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1377 G_CALLBACK (_on_send_receive_progress_changed),
1380 /* Send & receive. */
1381 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1382 /* Receive and then send. The operation is tagged initially as
1383 a receive operation because the account update performs a
1384 receive and then a send. The operation changes its type
1385 internally, so the progress objects will receive the proper
1386 progress information */
1387 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1388 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1389 g_object_unref (G_OBJECT (mail_op));
1397 modest_ui_actions_do_cancel_send (const gchar *account_name,
1400 TnyTransportAccount *transport_account;
1401 TnySendQueue *send_queue = NULL;
1402 GError *error = NULL;
1404 /* Get transport account */
1406 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1407 (modest_runtime_get_account_store(),
1409 TNY_ACCOUNT_TYPE_TRANSPORT));
1410 if (!transport_account) {
1411 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1416 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1417 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1418 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1419 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1420 "modest: could not find send queue for account\n");
1422 /* Keeep messages in outbox folder */
1423 tny_send_queue_cancel (send_queue, FALSE, &error);
1427 if (transport_account != NULL)
1428 g_object_unref (G_OBJECT (transport_account));
1432 modest_ui_actions_cancel_send_all (ModestWindow *win)
1434 GSList *account_names, *iter;
1436 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1439 iter = account_names;
1441 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1442 iter = g_slist_next (iter);
1445 modest_account_mgr_free_account_names (account_names);
1446 account_names = NULL;
1450 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1453 /* Check if accounts exist */
1454 gboolean accounts_exist =
1455 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1457 /* If not, allow the user to create an account before trying to send/receive. */
1458 if (!accounts_exist)
1459 modest_ui_actions_on_accounts (NULL, win);
1461 /* Cancel all sending operaitons */
1462 modest_ui_actions_cancel_send_all (win);
1466 * Refreshes all accounts. This function will be used by automatic
1470 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1472 GSList *account_names, *iter;
1474 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1477 iter = account_names;
1479 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1480 iter = g_slist_next (iter);
1483 modest_account_mgr_free_account_names (account_names);
1484 account_names = NULL;
1488 modest_do_refresh_current_folder(ModestWindow *win)
1490 /* Refresh currently selected folder. Note that if we only
1491 want to retreive the headers, then the refresh only will
1492 invoke a poke_status over all folders, i.e., only the
1493 total/unread count will be updated */
1494 if (MODEST_IS_MAIN_WINDOW (win)) {
1495 GtkWidget *header_view, *folder_view;
1496 TnyFolderStore *folder_store;
1498 /* Get folder and header view */
1500 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1501 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1503 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1505 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1507 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1508 MODEST_WIDGET_TYPE_HEADER_VIEW);
1510 /* We do not need to set the contents style
1511 because it hasn't changed. We also do not
1512 need to save the widget status. Just force
1514 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1515 TNY_FOLDER (folder_store),
1516 folder_refreshed_cb,
1517 MODEST_MAIN_WINDOW (win));
1521 g_object_unref (folder_store);
1527 * Handler of the click on Send&Receive button in the main toolbar
1530 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1532 /* Check if accounts exist */
1533 gboolean accounts_exist =
1534 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1536 /* If not, allow the user to create an account before trying to send/receive. */
1537 if (!accounts_exist)
1538 modest_ui_actions_on_accounts (NULL, win);
1540 modest_do_refresh_current_folder (win);
1542 /* Refresh the active account */
1543 modest_ui_actions_do_send_receive (NULL, win);
1548 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1551 GtkWidget *header_view;
1553 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1555 header_view = modest_main_window_get_child_widget (main_window,
1556 MODEST_WIDGET_TYPE_HEADER_VIEW);
1560 conf = modest_runtime_get_conf ();
1562 /* what is saved/restored is depending on the style; thus; we save with
1563 * old style, then update the style, and restore for this new style
1565 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1567 if (modest_header_view_get_style
1568 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1569 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1570 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1572 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1573 MODEST_HEADER_VIEW_STYLE_DETAILS);
1575 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1576 MODEST_CONF_HEADER_VIEW_KEY);
1581 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1583 ModestMainWindow *main_window)
1585 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1586 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1588 /* If no header has been selected then exit */
1593 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1594 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1596 /* Update Main window title */
1597 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1598 const gchar *subject = tny_header_get_subject (header);
1599 if (subject && strlen(subject) > 0)
1600 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1602 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1605 /* Update toolbar dimming state */
1606 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1610 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1612 ModestMainWindow *main_window)
1616 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1621 headers = tny_simple_list_new ();
1622 tny_list_prepend (headers, G_OBJECT (header));
1624 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1626 g_object_unref (headers);
1630 set_active_account_from_tny_account (TnyAccount *account,
1631 ModestWindow *window)
1633 const gchar *server_acc_name = tny_account_get_id (account);
1635 /* We need the TnyAccount provided by the
1636 account store because that is the one that
1637 knows the name of the Modest account */
1638 TnyAccount *modest_server_account = modest_server_account =
1639 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1640 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1643 const gchar *modest_acc_name =
1644 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1645 modest_window_set_active_account (window, modest_acc_name);
1646 g_object_unref (modest_server_account);
1651 folder_refreshed_cb (ModestMailOperation *mail_op,
1655 ModestMainWindow *win = NULL;
1656 GtkWidget *header_view;
1657 TnyFolder *current_folder;
1659 g_return_if_fail (TNY_IS_FOLDER (folder));
1661 win = MODEST_MAIN_WINDOW (user_data);
1663 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1666 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
1667 if (current_folder != NULL && folder != current_folder) {
1672 /* Check if folder is empty and set headers view contents style */
1673 if (tny_folder_get_all_count (folder) == 0) {
1674 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1675 modest_main_window_set_contents_style (win,
1676 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1678 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1683 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1684 TnyFolderStore *folder_store,
1686 ModestMainWindow *main_window)
1689 GtkWidget *header_view;
1691 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1693 header_view = modest_main_window_get_child_widget(main_window,
1694 MODEST_WIDGET_TYPE_HEADER_VIEW);
1698 conf = modest_runtime_get_conf ();
1700 if (TNY_IS_ACCOUNT (folder_store)) {
1702 /* Update active account */
1703 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1704 /* Show account details */
1705 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1708 if (TNY_IS_FOLDER (folder_store) && selected) {
1710 /* Update the active account */
1711 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1713 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1714 g_object_unref (account);
1718 /* Set the header style by default, it could
1719 be changed later by the refresh callback to
1721 modest_main_window_set_contents_style (main_window,
1722 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1724 /* Set folder on header view. This function
1725 will call tny_folder_refresh_async so we
1726 pass a callback that will be called when
1727 finished. We use that callback to set the
1728 empty view if there are no messages */
1729 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1730 TNY_FOLDER (folder_store),
1731 folder_refreshed_cb,
1734 /* Restore configuration. We need to do this
1735 *after* the set_folder because the widget
1736 memory asks the header view about its
1738 modest_widget_memory_restore (modest_runtime_get_conf (),
1739 G_OBJECT(header_view),
1740 MODEST_CONF_HEADER_VIEW_KEY);
1742 /* Update the active account */
1743 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1744 /* Save only if we're seeing headers */
1745 if (modest_main_window_get_contents_style (main_window) ==
1746 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1747 modest_widget_memory_save (conf, G_OBJECT (header_view),
1748 MODEST_CONF_HEADER_VIEW_KEY);
1749 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1753 /* Update toolbar dimming state */
1754 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1758 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1765 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1767 online = tny_device_is_online (modest_runtime_get_device());
1770 /* already online -- the item is simply not there... */
1771 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1773 GTK_MESSAGE_WARNING,
1775 _("The %s you selected cannot be found"),
1777 gtk_dialog_run (GTK_DIALOG(dialog));
1779 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1783 GTK_RESPONSE_REJECT,
1785 GTK_RESPONSE_ACCEPT,
1787 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1788 "Do you want to get online?"), item);
1789 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1790 gtk_label_new (txt), FALSE, FALSE, 0);
1791 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1794 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1795 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1796 // modest_platform_connect_and_wait ();
1799 gtk_widget_destroy (dialog);
1803 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1806 /* g_message ("%s %s", __FUNCTION__, link); */
1811 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1814 modest_platform_activate_uri (link);
1818 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1821 modest_platform_show_uri_popup (link);
1825 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1828 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1832 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1833 const gchar *address,
1836 /* g_message ("%s %s", __FUNCTION__, address); */
1840 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1842 TnyTransportAccount *transport_account;
1843 ModestMailOperation *mail_operation;
1845 gchar *account_name, *from;
1846 ModestAccountMgr *account_mgr;
1847 gchar *info_text = NULL;
1849 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1851 data = modest_msg_edit_window_get_msg_data (edit_window);
1853 account_mgr = modest_runtime_get_account_mgr();
1854 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1856 account_name = modest_account_mgr_get_default_account (account_mgr);
1857 if (!account_name) {
1858 g_printerr ("modest: no account found\n");
1859 modest_msg_edit_window_free_msg_data (edit_window, data);
1863 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1864 account_name = g_strdup (data->account_name);
1868 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1869 (modest_runtime_get_account_store(),
1871 TNY_ACCOUNT_TYPE_TRANSPORT));
1872 if (!transport_account) {
1873 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1874 g_free (account_name);
1875 modest_msg_edit_window_free_msg_data (edit_window, data);
1878 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1880 /* Create the mail operation */
1881 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1882 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1884 modest_mail_operation_save_to_drafts (mail_operation,
1896 data->priority_flags);
1899 g_free (account_name);
1900 g_object_unref (G_OBJECT (transport_account));
1901 g_object_unref (G_OBJECT (mail_operation));
1903 modest_msg_edit_window_free_msg_data (edit_window, data);
1905 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1906 modest_platform_information_banner (NULL, NULL, info_text);
1910 /* For instance, when clicking the Send toolbar button when editing a message: */
1912 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1914 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1916 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
1919 /* Offer the connection dialog, if necessary: */
1920 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window), NULL))
1923 /* FIXME: Code added just for testing. The final version will
1924 use the send queue provided by tinymail and some
1926 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1927 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1929 account_name = modest_account_mgr_get_default_account (account_mgr);
1931 if (!account_name) {
1932 g_printerr ("modest: no account found\n");
1936 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1938 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1939 account_name = g_strdup (data->account_name);
1942 /* Get the currently-active transport account for this modest account: */
1943 TnyTransportAccount *transport_account =
1944 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1945 (modest_runtime_get_account_store(),
1947 if (!transport_account) {
1948 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1949 g_free (account_name);
1950 modest_msg_edit_window_free_msg_data (edit_window, data);
1954 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1956 /* mail content checks and dialogs */
1957 if (data->subject == NULL || data->subject[0] == '\0') {
1958 GtkResponseType response;
1959 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1960 _("mcen_nc_subject_is_empty_send"));
1961 if (response == GTK_RESPONSE_CANCEL) {
1962 g_free (account_name);
1967 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1968 GtkResponseType response;
1969 gchar *note_message;
1970 gchar *note_subject = data->subject;
1971 if (note_subject == NULL || note_subject[0] == '\0')
1972 note_subject = _("mail_va_no_subject");
1973 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1974 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1976 g_free (note_message);
1977 if (response == GTK_RESPONSE_CANCEL) {
1978 g_free (account_name);
1983 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
1985 /* Create the mail operation */
1986 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1987 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1989 modest_mail_operation_send_new_mail (mail_operation,
2000 data->priority_flags);
2004 g_free (account_name);
2005 g_object_unref (G_OBJECT (transport_account));
2006 g_object_unref (G_OBJECT (mail_operation));
2008 modest_msg_edit_window_free_msg_data (edit_window, data);
2009 modest_msg_edit_window_set_sent (edit_window, TRUE);
2011 /* Save settings and close the window: */
2012 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2016 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2017 ModestMsgEditWindow *window)
2019 ModestMsgEditFormatState *format_state = NULL;
2021 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2022 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2024 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2027 format_state = modest_msg_edit_window_get_format_state (window);
2028 g_return_if_fail (format_state != NULL);
2030 format_state->bold = gtk_toggle_action_get_active (action);
2031 modest_msg_edit_window_set_format_state (window, format_state);
2032 g_free (format_state);
2037 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2038 ModestMsgEditWindow *window)
2040 ModestMsgEditFormatState *format_state = NULL;
2042 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2043 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2045 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2048 format_state = modest_msg_edit_window_get_format_state (window);
2049 g_return_if_fail (format_state != NULL);
2051 format_state->italics = gtk_toggle_action_get_active (action);
2052 modest_msg_edit_window_set_format_state (window, format_state);
2053 g_free (format_state);
2058 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2059 ModestMsgEditWindow *window)
2061 ModestMsgEditFormatState *format_state = NULL;
2063 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2064 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2066 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2069 format_state = modest_msg_edit_window_get_format_state (window);
2070 g_return_if_fail (format_state != NULL);
2072 format_state->bullet = gtk_toggle_action_get_active (action);
2073 modest_msg_edit_window_set_format_state (window, format_state);
2074 g_free (format_state);
2079 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2080 GtkRadioAction *selected,
2081 ModestMsgEditWindow *window)
2083 ModestMsgEditFormatState *format_state = NULL;
2084 GtkJustification value;
2086 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2088 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2091 value = gtk_radio_action_get_current_value (selected);
2093 format_state = modest_msg_edit_window_get_format_state (window);
2094 g_return_if_fail (format_state != NULL);
2096 format_state->justification = value;
2097 modest_msg_edit_window_set_format_state (window, format_state);
2098 g_free (format_state);
2102 modest_ui_actions_on_select_editor_color (GtkAction *action,
2103 ModestMsgEditWindow *window)
2105 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2106 g_return_if_fail (GTK_IS_ACTION (action));
2108 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2111 modest_msg_edit_window_select_color (window);
2115 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2116 ModestMsgEditWindow *window)
2118 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2119 g_return_if_fail (GTK_IS_ACTION (action));
2121 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2124 modest_msg_edit_window_select_background_color (window);
2128 modest_ui_actions_on_insert_image (GtkAction *action,
2129 ModestMsgEditWindow *window)
2131 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2132 g_return_if_fail (GTK_IS_ACTION (action));
2134 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2137 modest_msg_edit_window_insert_image (window);
2141 modest_ui_actions_on_attach_file (GtkAction *action,
2142 ModestMsgEditWindow *window)
2144 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2145 g_return_if_fail (GTK_IS_ACTION (action));
2147 modest_msg_edit_window_offer_attach_file (window);
2151 modest_ui_actions_on_remove_attachments (GtkAction *action,
2152 ModestMsgEditWindow *window)
2154 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2155 g_return_if_fail (GTK_IS_ACTION (action));
2157 modest_msg_edit_window_remove_attachments (window, NULL);
2161 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2164 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2165 const GError *error = modest_mail_operation_get_error (mail_op);
2169 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2170 modest_mail_operation_get_error (mail_op)->message);
2175 modest_ui_actions_create_folder(GtkWidget *parent_window,
2176 GtkWidget *folder_view)
2178 TnyFolderStore *parent_folder;
2180 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2182 if (parent_folder) {
2183 gboolean finished = FALSE;
2185 gchar *folder_name = NULL, *suggested_name = NULL;
2187 /* Run the new folder dialog */
2189 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2194 g_free (suggested_name);
2195 suggested_name = NULL;
2197 if (result == GTK_RESPONSE_REJECT) {
2200 ModestMailOperation *mail_op;
2201 TnyFolder *new_folder = NULL;
2203 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2204 G_OBJECT(parent_window),
2205 modest_ui_actions_new_folder_error_handler,
2208 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2210 new_folder = modest_mail_operation_create_folder (mail_op,
2212 (const gchar *) folder_name);
2214 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2217 g_object_unref (new_folder);
2220 g_object_unref (mail_op);
2223 suggested_name = folder_name;
2227 g_object_unref (parent_folder);
2232 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2234 GtkWidget *folder_view;
2236 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2238 folder_view = modest_main_window_get_child_widget (main_window,
2239 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2243 modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2247 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2250 GObject *win = modest_mail_operation_get_source (mail_op);
2251 const GError *error = NULL;
2252 const gchar *message = NULL;
2254 /* Get error message */
2255 error = modest_mail_operation_get_error (mail_op);
2256 if (error != NULL && error->message != NULL) {
2257 message = error->message;
2259 message = _("!!! FIXME: Unable to rename");
2262 /* Show notification dialog */
2263 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
2264 g_object_unref (win);
2268 modest_ui_actions_on_rename_folder (GtkAction *action,
2269 ModestMainWindow *main_window)
2271 TnyFolderStore *folder;
2272 GtkWidget *folder_view;
2273 GtkWidget *header_view;
2275 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2277 folder_view = modest_main_window_get_child_widget (main_window,
2278 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2282 header_view = modest_main_window_get_child_widget (main_window,
2283 MODEST_WIDGET_TYPE_HEADER_VIEW);
2288 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2292 /* Offer the connection dialog if necessary: */
2293 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2294 g_object_unref (G_OBJECT (folder));
2299 if (TNY_IS_FOLDER (folder)) {
2302 const gchar *current_name;
2304 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2305 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2306 current_name, &folder_name);
2308 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2309 ModestMailOperation *mail_op;
2312 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2313 G_OBJECT(main_window),
2314 modest_ui_actions_rename_folder_error_handler,
2318 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2321 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2323 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2324 TNY_FOLDER(folder), TRUE);
2327 modest_header_view_clear ((ModestHeaderView *) header_view);
2329 modest_mail_operation_rename_folder (mail_op,
2330 TNY_FOLDER (folder),
2331 (const gchar *) folder_name);
2333 g_object_unref (mail_op);
2334 g_free (folder_name);
2337 g_object_unref (folder);
2341 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2344 GObject *win = modest_mail_operation_get_source (mail_op);
2346 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2347 _("mail_in_ui_folder_delete_error"));
2348 g_object_unref (win);
2352 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2354 TnyFolderStore *folder;
2355 GtkWidget *folder_view;
2359 g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2361 folder_view = modest_main_window_get_child_widget (main_window,
2362 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2366 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2368 /* Show an error if it's an account */
2369 if (!TNY_IS_FOLDER (folder)) {
2370 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2371 _("mail_in_ui_folder_delete_error"));
2372 g_object_unref (G_OBJECT (folder));
2376 /* Offer the connection dialog if necessary: */
2377 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2378 g_object_unref (G_OBJECT (folder));
2383 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2384 tny_folder_get_name (TNY_FOLDER (folder)));
2385 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2386 (const gchar *) message);
2389 if (response == GTK_RESPONSE_OK) {
2390 ModestMailOperation *mail_op =
2391 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2392 G_OBJECT(main_window),
2393 modest_ui_actions_delete_folder_error_handler,
2396 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2398 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2399 g_object_unref (G_OBJECT (mail_op));
2402 g_object_unref (G_OBJECT (folder));
2406 modest_ui_actions_on_delete_folder (GtkAction *action,
2407 ModestMainWindow *main_window)
2409 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2411 delete_folder (main_window, FALSE);
2415 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2417 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2419 delete_folder (main_window, TRUE);
2424 show_error (GtkWidget *parent_widget, const gchar* text)
2426 hildon_banner_show_information(parent_widget, NULL, text);
2429 GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); */
2431 GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
2438 gtk_dialog_run (dialog);
2439 gtk_widget_destroy (GTK_WIDGET (dialog));
2444 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2445 const gchar* server_account_name,
2450 ModestMainWindow *main_window)
2452 g_return_if_fail(server_account_name);
2453 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2455 /* Initalize output parameters: */
2462 #ifdef MODEST_PLATFORM_MAEMO
2463 /* Maemo uses a different (awkward) button order,
2464 * It should probably just use gtk_alternative_dialog_button_order ().
2466 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2470 GTK_RESPONSE_ACCEPT,
2472 GTK_RESPONSE_REJECT,
2475 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2479 GTK_RESPONSE_REJECT,
2481 GTK_RESPONSE_ACCEPT,
2483 #endif /* MODEST_PLATFORM_MAEMO */
2485 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2487 gchar *server_name = modest_server_account_get_hostname (
2488 modest_runtime_get_account_mgr(), server_account_name);
2489 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2490 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2495 /* This causes a warning because the logical ID has no %s in it,
2496 * though the translation does, but there is not much we can do about that: */
2497 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2498 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2501 g_free (server_name);
2505 gchar *initial_username = modest_server_account_get_username (
2506 modest_runtime_get_account_mgr(), server_account_name);
2508 GtkWidget *entry_username = gtk_entry_new ();
2509 if (initial_username)
2510 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2511 /* Dim this if a connection has ever succeeded with this username,
2512 * as per the UI spec: */
2513 const gboolean username_known =
2514 modest_server_account_get_username_has_succeeded(
2515 modest_runtime_get_account_mgr(), server_account_name);
2516 gtk_widget_set_sensitive (entry_username, !username_known);
2518 #ifdef MODEST_PLATFORM_MAEMO
2519 /* Auto-capitalization is the default, so let's turn it off: */
2520 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2522 /* Create a size group to be used by all captions.
2523 * Note that HildonCaption does not create a default size group if we do not specify one.
2524 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2525 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2527 GtkWidget *caption = hildon_caption_new (sizegroup,
2528 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2529 gtk_widget_show (entry_username);
2530 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2531 FALSE, FALSE, MODEST_MARGIN_HALF);
2532 gtk_widget_show (caption);
2534 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2536 #endif /* MODEST_PLATFORM_MAEMO */
2539 GtkWidget *entry_password = gtk_entry_new ();
2540 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2541 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2543 #ifdef MODEST_PLATFORM_MAEMO
2544 /* Auto-capitalization is the default, so let's turn it off: */
2545 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2546 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2548 caption = hildon_caption_new (sizegroup,
2549 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2550 gtk_widget_show (entry_password);
2551 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2552 FALSE, FALSE, MODEST_MARGIN_HALF);
2553 gtk_widget_show (caption);
2554 g_object_unref (sizegroup);
2556 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2558 #endif /* MODEST_PLATFORM_MAEMO */
2560 /* This is not in the Maemo UI spec:
2561 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2562 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2566 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2568 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2570 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2572 modest_server_account_set_username (
2573 modest_runtime_get_account_mgr(), server_account_name,
2576 const gboolean username_was_changed =
2577 (strcmp (*username, initial_username) != 0);
2578 if (username_was_changed) {
2579 g_warning ("%s: tinymail does not yet support changing the "
2580 "username in the get_password() callback.\n", __FUNCTION__);
2585 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2587 /* We do not save the password in the configuration,
2588 * because this function is only called for passwords that should
2589 * not be remembered:
2590 modest_server_account_set_password (
2591 modest_runtime_get_account_mgr(), server_account_name,
2600 show_error(GTK_WIDGET (main_window), _("mail_ib_login_cancelled"));
2612 /* This is not in the Maemo UI spec:
2613 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2619 gtk_widget_destroy (dialog);
2621 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2625 modest_ui_actions_on_cut (GtkAction *action,
2626 ModestWindow *window)
2628 GtkWidget *focused_widget;
2630 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2631 if (GTK_IS_EDITABLE (focused_widget)) {
2632 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2633 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2634 GtkTextBuffer *buffer;
2635 GtkClipboard *clipboard;
2637 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2638 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2639 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2640 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2641 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2642 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2643 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2644 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2649 modest_ui_actions_on_copy (GtkAction *action,
2650 ModestWindow *window)
2652 GtkClipboard *clipboard;
2653 GtkWidget *focused_widget;
2655 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2656 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2658 if (GTK_IS_LABEL (focused_widget)) {
2659 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2660 } else if (GTK_IS_EDITABLE (focused_widget)) {
2661 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2662 } else if (GTK_IS_HTML (focused_widget)) {
2663 gtk_html_copy (GTK_HTML (focused_widget));
2664 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2665 GtkTextBuffer *buffer;
2666 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2667 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2668 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2669 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2670 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2671 TnyIterator *iter = tny_list_create_iterator (header_list);
2672 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2674 gboolean ask = FALSE;
2676 TnyFolder *folder = tny_header_get_folder (header);
2677 TnyAccount *account = tny_folder_get_account (folder);
2678 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2679 /* If it's POP then ask */
2680 ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2681 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2682 g_object_unref (account);
2683 g_object_unref (folder);
2684 g_object_unref (header);
2687 g_object_unref (iter);
2689 /* Check that the messages have been previously downloaded */
2690 gboolean continue_download = TRUE;
2692 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window), FALSE);
2693 if (continue_download)
2694 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2695 g_object_unref (header_list);
2696 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2697 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2700 /* Show information banner */
2701 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2706 modest_ui_actions_on_undo (GtkAction *action,
2707 ModestWindow *window)
2709 ModestEmailClipboard *clipboard = NULL;
2711 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2712 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2713 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2714 /* Clear clipboard source */
2715 clipboard = modest_runtime_get_email_clipboard ();
2716 modest_email_clipboard_clear (clipboard);
2719 g_return_if_reached ();
2724 modest_ui_actions_on_redo (GtkAction *action,
2725 ModestWindow *window)
2727 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2728 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2731 g_return_if_reached ();
2737 paste_msgs_cb (const GObject *object, gpointer user_data)
2739 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2740 g_return_if_fail (GTK_IS_WIDGET (user_data));
2742 /* destroy information note */
2743 gtk_widget_destroy (GTK_WIDGET(user_data));
2747 modest_ui_actions_on_paste (GtkAction *action,
2748 ModestWindow *window)
2750 GtkWidget *focused_widget = NULL;
2751 GtkWidget *inf_note = NULL;
2752 ModestMailOperation *mail_op = NULL;
2754 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2755 if (GTK_IS_EDITABLE (focused_widget)) {
2756 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2757 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2758 GtkTextBuffer *buffer;
2759 GtkClipboard *clipboard;
2761 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2762 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2763 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2764 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2765 ModestEmailClipboard *clipboard = NULL;
2766 TnyFolder *src_folder = NULL;
2767 TnyFolderStore *folder_store = NULL;
2768 TnyList *data = NULL;
2769 gboolean delete = FALSE;
2771 /* Check clipboard source */
2772 clipboard = modest_runtime_get_email_clipboard ();
2773 if (modest_email_clipboard_cleared (clipboard))
2776 /* Get elements to paste */
2777 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2779 /* Create a new mail operation */
2780 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2781 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2784 /* Get destination folder */
2785 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2787 /* Launch notification */
2788 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2789 _CS("ckct_nw_pasting"));
2790 if (inf_note != NULL) {
2791 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
2792 gtk_widget_show (GTK_WIDGET(inf_note));
2795 /* transfer messages */
2797 modest_mail_operation_xfer_msgs (mail_op,
2799 TNY_FOLDER (folder_store),
2804 } else if (src_folder != NULL) {
2805 modest_mail_operation_xfer_folder (mail_op,
2815 g_object_unref (data);
2816 if (src_folder != NULL)
2817 g_object_unref (src_folder);
2818 if (folder_store != NULL)
2819 g_object_unref (folder_store);
2825 modest_ui_actions_on_select_all (GtkAction *action,
2826 ModestWindow *window)
2828 GtkWidget *focused_widget;
2830 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2831 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2832 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2833 } else if (GTK_IS_LABEL (focused_widget)) {
2834 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2835 } else if (GTK_IS_EDITABLE (focused_widget)) {
2836 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2837 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2838 GtkTextBuffer *buffer;
2839 GtkTextIter start, end;
2841 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2842 gtk_text_buffer_get_start_iter (buffer, &start);
2843 gtk_text_buffer_get_end_iter (buffer, &end);
2844 gtk_text_buffer_select_range (buffer, &start, &end);
2845 } else if (GTK_IS_HTML (focused_widget)) {
2846 gtk_html_select_all (GTK_HTML (focused_widget));
2847 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2848 GtkWidget *header_view = focused_widget;
2849 GtkTreeSelection *selection = NULL;
2851 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2852 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2853 MODEST_WIDGET_TYPE_HEADER_VIEW);
2855 /* Select all messages */
2856 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2857 gtk_tree_selection_select_all (selection);
2859 /* Set focuse on header view */
2860 gtk_widget_grab_focus (header_view);
2866 modest_ui_actions_on_mark_as_read (GtkAction *action,
2867 ModestWindow *window)
2869 g_return_if_fail (MODEST_IS_WINDOW(window));
2871 /* Mark each header as read */
2872 do_headers_action (window, headers_action_mark_as_read, NULL);
2876 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2877 ModestWindow *window)
2879 g_return_if_fail (MODEST_IS_WINDOW(window));
2881 /* Mark each header as read */
2882 do_headers_action (window, headers_action_mark_as_unread, NULL);
2886 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2887 GtkRadioAction *selected,
2888 ModestWindow *window)
2892 value = gtk_radio_action_get_current_value (selected);
2893 if (MODEST_IS_WINDOW (window)) {
2894 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2898 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2899 GtkRadioAction *selected,
2900 ModestWindow *window)
2902 TnyHeaderFlags flags;
2903 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2905 flags = gtk_radio_action_get_current_value (selected);
2906 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2909 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2910 GtkRadioAction *selected,
2911 ModestWindow *window)
2915 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2917 file_format = gtk_radio_action_get_current_value (selected);
2918 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2923 modest_ui_actions_on_zoom_plus (GtkAction *action,
2924 ModestWindow *window)
2926 g_return_if_fail (MODEST_IS_WINDOW (window));
2928 modest_window_zoom_plus (MODEST_WINDOW (window));
2932 modest_ui_actions_on_zoom_minus (GtkAction *action,
2933 ModestWindow *window)
2935 g_return_if_fail (MODEST_IS_WINDOW (window));
2937 modest_window_zoom_minus (MODEST_WINDOW (window));
2941 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2942 ModestWindow *window)
2944 ModestWindowMgr *mgr;
2945 gboolean fullscreen, active;
2946 g_return_if_fail (MODEST_IS_WINDOW (window));
2948 mgr = modest_runtime_get_window_mgr ();
2950 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2951 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2953 if (active != fullscreen) {
2954 modest_window_mgr_set_fullscreen_mode (mgr, active);
2955 gtk_window_present (GTK_WINDOW (window));
2960 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2961 ModestWindow *window)
2963 ModestWindowMgr *mgr;
2964 gboolean fullscreen;
2966 g_return_if_fail (MODEST_IS_WINDOW (window));
2968 mgr = modest_runtime_get_window_mgr ();
2969 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2970 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2972 gtk_window_present (GTK_WINDOW (window));
2976 * Used by modest_ui_actions_on_details to call do_headers_action
2979 headers_action_show_details (TnyHeader *header,
2980 ModestWindow *window,
2987 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2990 gtk_widget_show_all (dialog);
2991 gtk_dialog_run (GTK_DIALOG (dialog));
2993 gtk_widget_destroy (dialog);
2997 * Show the folder details in a ModestDetailsDialog widget
3000 show_folder_details (TnyFolder *folder,
3006 dialog = modest_details_dialog_new_with_folder (window, folder);
3009 gtk_widget_show_all (dialog);
3010 gtk_dialog_run (GTK_DIALOG (dialog));
3012 gtk_widget_destroy (dialog);
3016 * Show the header details in a ModestDetailsDialog widget
3019 modest_ui_actions_on_details (GtkAction *action,
3022 TnyList * headers_list;
3026 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3029 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3032 g_object_unref (msg);
3034 headers_list = get_selected_headers (win);
3038 iter = tny_list_create_iterator (headers_list);
3040 header = TNY_HEADER (tny_iterator_get_current (iter));
3042 headers_action_show_details (header, win, NULL);
3043 g_object_unref (header);
3046 g_object_unref (iter);
3047 g_object_unref (headers_list);
3049 } else if (MODEST_IS_MAIN_WINDOW (win)) {
3050 GtkWidget *folder_view, *header_view;
3052 /* Check which widget has the focus */
3053 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3054 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3055 if (gtk_widget_is_focus (folder_view)) {
3056 TnyFolderStore *folder_store
3057 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3058 if (!folder_store) {
3059 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3062 /* Show only when it's a folder */
3063 /* This function should not be called for account items,
3064 * because we dim the menu item for them. */
3065 if (TNY_IS_FOLDER (folder_store)) {
3066 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3069 g_object_unref (folder_store);
3072 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3073 MODEST_WIDGET_TYPE_HEADER_VIEW);
3074 /* Show details of each header */
3075 do_headers_action (win, headers_action_show_details, header_view);
3081 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3082 ModestMsgEditWindow *window)
3084 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3086 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3090 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3091 ModestMsgEditWindow *window)
3093 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3095 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3099 modest_ui_actions_toggle_folders_view (GtkAction *action,
3100 ModestMainWindow *main_window)
3102 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3104 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3105 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3107 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3111 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3112 ModestWindow *window)
3114 gboolean active, fullscreen = FALSE;
3115 ModestWindowMgr *mgr;
3117 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3119 /* Check if we want to toggle the toolbar vuew in fullscreen
3121 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3122 "ViewShowToolbarFullScreen")) {
3126 /* Toggle toolbar */
3127 mgr = modest_runtime_get_window_mgr ();
3128 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3132 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3133 ModestMsgEditWindow *window)
3135 modest_msg_edit_window_select_font (window);
3139 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3140 const gchar *display_name,
3143 /* Do not change the application name if the widget has not
3144 the focus. This callback could be called even if the folder
3145 view has not the focus, because the handled signal could be
3146 emitted when the folder view is redrawn */
3147 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3149 gtk_window_set_title (window, display_name);
3151 gtk_window_set_title (window, " ");
3156 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3158 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3159 modest_msg_edit_window_select_contacts (window);
3163 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3165 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3166 modest_msg_edit_window_check_names (window, FALSE);
3170 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3172 modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3173 GTK_WIDGET (user_data));
3177 create_move_to_dialog (GtkWindow *win,
3178 GtkWidget *folder_view,
3179 GtkWidget **tree_view)
3181 GtkWidget *dialog, *scroll;
3182 GtkWidget *new_button;
3184 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3186 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3189 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
3190 /* We do this manually so GTK+ does not associate a response ID for
3192 new_button = gtk_button_new_from_stock (GTK_STOCK_NEW);
3193 gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3194 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
3196 /* Create scrolled window */
3197 scroll = gtk_scrolled_window_new (NULL, NULL);
3198 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3199 GTK_POLICY_AUTOMATIC,
3200 GTK_POLICY_AUTOMATIC);
3202 /* Create folder view */
3203 *tree_view = modest_platform_create_folder_view (NULL);
3205 g_signal_connect (G_OBJECT (new_button), "clicked", G_CALLBACK(create_move_to_dialog_on_new_folder), *tree_view);
3207 /* It could happen that we're trying to move a message from a
3208 window (msg window for example) after the main window was
3209 closed, so we can not just get the model of the folder
3211 if (MODEST_IS_FOLDER_VIEW (folder_view))
3212 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3213 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3215 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3216 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3218 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3220 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3222 /* Add scroll to dialog */
3223 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3224 scroll, TRUE, TRUE, 0);
3226 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3227 gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3233 * Returns TRUE if at least one of the headers of the list belongs to
3234 * a message that has been fully retrieved.
3237 has_retrieved_msgs (TnyList *list)
3240 gboolean found = FALSE;
3242 iter = tny_list_create_iterator (list);
3243 while (tny_iterator_is_done (iter) && !found) {
3245 TnyHeaderFlags flags = 0;
3247 header = TNY_HEADER (tny_iterator_get_current (iter));
3249 flags = tny_header_get_flags (header);
3250 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
3253 g_object_unref (header);
3257 tny_iterator_next (iter);
3259 g_object_unref (iter);
3265 * Shows a confirmation dialog to the user when we're moving messages
3266 * from a remote server to the local storage. Returns the dialog
3267 * response. If it's other kind of movement the it always returns
3271 msgs_move_to_confirmation (GtkWindow *win,
3272 TnyFolder *dest_folder,
3275 gint response = GTK_RESPONSE_OK;
3277 /* If the destination is a local folder */
3278 if (modest_tny_folder_is_local_folder (dest_folder)) {
3279 TnyFolder *src_folder = NULL;
3280 TnyIterator *iter = NULL;
3281 TnyHeader *header = NULL;
3283 /* Get source folder */
3284 iter = tny_list_create_iterator (headers);
3285 header = TNY_HEADER (tny_iterator_get_current (iter));
3287 src_folder = tny_header_get_folder (header);
3288 g_object_unref (header);
3291 g_object_unref (iter);
3293 /* if no src_folder, message may be an attahcment */
3294 if (src_folder == NULL)
3295 return GTK_RESPONSE_CANCEL;
3297 /* If the source is a remote folder */
3298 if (!modest_tny_folder_is_local_folder (src_folder)) {
3299 const gchar *message;
3301 if (has_retrieved_msgs (headers))
3302 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3303 tny_list_get_length (headers));
3305 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3306 tny_list_get_length (headers));
3308 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3309 (const gchar *) message);
3312 g_object_unref (src_folder);
3321 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3323 ModestMsgViewWindow *self = NULL;
3325 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3326 self = MODEST_MSG_VIEW_WINDOW (object);
3328 if (!modest_msg_view_window_select_next_message (self))
3329 if (!modest_msg_view_window_select_previous_message (self))
3330 /* No more messages to view, so close this window */
3331 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3335 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3338 GObject *win = modest_mail_operation_get_source (mail_op);
3339 const GError *error = NULL;
3340 const gchar *message = NULL;
3342 /* Get error message */
3343 error = modest_mail_operation_get_error (mail_op);
3344 if (error != NULL && error->message != NULL) {
3345 message = error->message;
3347 message = _("mail_in_ui_folder_move_target_error");
3350 /* Show notification dialog */
3351 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3352 g_object_unref (win);
3356 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3359 GObject *win = modest_mail_operation_get_source (mail_op);
3360 const GError *error = modest_mail_operation_get_error (mail_op);
3362 g_return_if_fail (error != NULL);
3363 if (error->message != NULL)
3364 g_printerr ("modest: %s\n", error->message);
3366 g_printerr ("modest: unkonw error on send&receive operation");
3368 /* Show error message */
3369 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3370 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3371 /* _CS("sfil_ib_unable_to_receive")); */
3373 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3374 /* _CS("sfil_ib_unable_to_send")); */
3375 g_object_unref (win);
3379 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3386 gint pending_purges = 0;
3387 gboolean some_purged = FALSE;
3388 ModestWindow *win = MODEST_WINDOW (user_data);
3389 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
3391 /* If there was any error */
3392 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
3393 modest_window_mgr_unregister_header (mgr, header);
3397 /* Once the message has been retrieved for purging, we check if
3398 * it's all ok for purging */
3400 parts = tny_simple_list_new ();
3401 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3402 iter = tny_list_create_iterator (parts);
3404 while (!tny_iterator_is_done (iter)) {
3406 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3407 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
3408 if (tny_mime_part_is_purged (part))
3415 g_object_unref (part);
3417 tny_iterator_next (iter);
3420 if (pending_purges>0) {
3422 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3424 if (response == GTK_RESPONSE_OK) {
3425 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3426 tny_iterator_first (iter);
3427 while (!tny_iterator_is_done (iter)) {
3430 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3431 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
3432 tny_mime_part_set_purged (part);
3435 g_object_unref (part);
3437 tny_iterator_next (iter);
3440 tny_msg_rewrite_cache (msg);
3443 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3446 /* remove attachments */
3447 tny_iterator_first (iter);
3448 while (!tny_iterator_is_done (iter)) {
3451 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3453 /* One for the reference given by tny_iterator_get_current(): */
3454 g_object_unref (part);
3456 /* TODO: Is this meant to remove the attachment by doing another unref()?
3457 * Otherwise, this seems useless. */
3460 tny_iterator_next (iter);
3462 modest_window_mgr_unregister_header (mgr, header);
3464 g_object_unref (iter);
3465 g_object_unref (parts);
3469 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3470 ModestMainWindow *win)
3472 GtkWidget *header_view;
3473 TnyList *header_list;
3476 TnyHeaderFlags flags;
3477 ModestWindow *msg_view_window = NULL;
3480 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3482 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3483 MODEST_WIDGET_TYPE_HEADER_VIEW);
3485 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3487 if (tny_list_get_length (header_list) == 1) {
3488 iter = tny_list_create_iterator (header_list);
3489 header = TNY_HEADER (tny_iterator_get_current (iter));
3490 g_object_unref (iter);
3495 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3496 header, &msg_view_window);
3497 flags = tny_header_get_flags (header);
3498 if (!(flags & TNY_HEADER_FLAG_CACHED))
3501 if (msg_view_window != NULL)
3502 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3504 /* do nothing; uid was registered before, so window is probably on it's way */
3505 g_warning ("debug: header %p has already been registered", header);
3508 ModestMailOperation *mail_op = NULL;
3509 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3510 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3512 modest_ui_actions_get_msgs_full_error_handler,
3514 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3515 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3517 g_object_unref (mail_op);
3520 g_object_unref (header);
3522 g_object_unref (header_list);
3526 * Utility function that transfer messages from both the main window
3527 * and the msg view window when using the "Move to" dialog
3530 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
3533 TnyList *headers = NULL;
3536 if (!TNY_IS_FOLDER (dst_folder)) {
3537 modest_platform_information_banner (GTK_WIDGET (win),
3539 _CS("ckdg_ib_unable_to_move_to_current_location"));
3543 /* Get selected headers */
3544 headers = get_selected_headers (MODEST_WINDOW (win));
3546 /* Ask for user confirmation */
3547 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3548 TNY_FOLDER (dst_folder),
3551 /* Transfer messages */
3552 if (response == GTK_RESPONSE_OK) {
3553 ModestMailOperation *mail_op =
3554 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3556 modest_ui_actions_move_folder_error_handler,
3558 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3561 modest_mail_operation_xfer_msgs (mail_op,
3563 TNY_FOLDER (dst_folder),
3565 (MODEST_IS_MSG_VIEW_WINDOW (win)) ? transfer_msgs_from_viewer_cb : NULL,
3568 g_object_unref (G_OBJECT (mail_op));
3570 g_object_unref (headers);
3575 * UI handler for the "Move to" action when invoked from the
3579 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3580 GtkWidget *folder_view,
3581 TnyFolderStore *dst_folder,
3582 ModestMainWindow *win)
3584 GtkWidget *header_view = NULL;
3585 ModestMailOperation *mail_op = NULL;
3586 TnyFolderStore *src_folder;
3588 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3590 /* Get the source folder */
3591 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3593 /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3594 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3598 /* Get header view */
3600 modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW);
3602 /* Get folder or messages to transfer */
3603 if (gtk_widget_is_focus (folder_view)) {
3605 /* Allow only to transfer folders to the local root folder */
3606 if (TNY_IS_ACCOUNT (dst_folder) &&
3607 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder))
3610 /* Clean folder on header view before moving it */
3611 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3613 if (TNY_IS_FOLDER (src_folder)) {
3615 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3617 modest_ui_actions_move_folder_error_handler,
3619 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3622 modest_mail_operation_xfer_folder (mail_op,
3623 TNY_FOLDER (src_folder),
3626 /* Unref mail operation */
3627 g_object_unref (G_OBJECT (mail_op));
3629 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3631 } else if (gtk_widget_is_focus (header_view)) {
3632 /* Transfer messages */
3633 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3638 g_object_unref (src_folder);
3643 * UI handler for the "Move to" action when invoked from the
3644 * ModestMsgViewWindow
3647 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3648 TnyFolderStore *dst_folder,
3649 ModestMsgViewWindow *win)
3651 TnyHeader *header = NULL;
3652 TnyFolder *src_folder;
3654 /* Create header list */
3655 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3656 src_folder = tny_header_get_folder(header);
3657 g_object_unref (header);
3659 /* Transfer the message */
3660 if (modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (src_folder)))
3661 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3663 g_object_unref (src_folder);
3667 modest_ui_actions_on_move_to (GtkAction *action,
3670 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3672 TnyFolderStore *dst_folder = NULL;
3673 ModestMainWindow *main_window;
3675 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3676 MODEST_IS_MSG_VIEW_WINDOW (win));
3678 /* Get the main window if exists */
3679 if (MODEST_IS_MAIN_WINDOW (win))
3680 main_window = MODEST_MAIN_WINDOW (win);
3683 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3685 /* Get the folder view widget if exists */
3687 folder_view = modest_main_window_get_child_widget (main_window,
3688 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3692 /* Create and run the dialog */
3693 dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
3694 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3695 result = gtk_dialog_run (GTK_DIALOG(dialog));
3696 g_object_ref (tree_view);
3697 gtk_widget_destroy (dialog);
3699 if (result != GTK_RESPONSE_ACCEPT)
3702 dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3703 /* Offer the connection dialog if necessary: */
3704 if (modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3707 /* Do window specific stuff */
3708 if (MODEST_IS_MAIN_WINDOW (win))
3709 modest_ui_actions_on_main_window_move_to (action,
3712 MODEST_MAIN_WINDOW (win));
3714 modest_ui_actions_on_msg_view_window_move_to (action,
3716 MODEST_MSG_VIEW_WINDOW (win));
3719 g_object_unref (dst_folder);
3723 * Calls #HeadersFunc for each header already selected in the main
3724 * window or the message currently being shown in the msg view window
3727 do_headers_action (ModestWindow *win,
3731 TnyList *headers_list = NULL;
3732 TnyIterator *iter = NULL;
3733 TnyHeader *header = NULL;
3734 TnyFolder *folder = NULL;
3737 headers_list = get_selected_headers (win);
3741 /* Get the folder */
3742 iter = tny_list_create_iterator (headers_list);
3743 header = TNY_HEADER (tny_iterator_get_current (iter));
3745 folder = tny_header_get_folder (header);
3746 g_object_unref (header);
3749 /* Call the function for each header */
3750 while (!tny_iterator_is_done (iter)) {
3751 header = TNY_HEADER (tny_iterator_get_current (iter));
3752 func (header, win, user_data);
3753 g_object_unref (header);
3754 tny_iterator_next (iter);
3757 /* Trick: do a poke status in order to speed up the signaling
3759 tny_folder_poke_status (folder);
3762 g_object_unref (folder);
3763 g_object_unref (iter);
3764 g_object_unref (headers_list);
3768 modest_ui_actions_view_attachment (GtkAction *action,
3769 ModestWindow *window)
3771 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3772 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3774 /* not supported window for this action */
3775 g_return_if_reached ();
3780 modest_ui_actions_save_attachments (GtkAction *action,
3781 ModestWindow *window)
3783 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3784 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3786 /* not supported window for this action */
3787 g_return_if_reached ();
3792 modest_ui_actions_remove_attachments (GtkAction *action,
3793 ModestWindow *window)
3795 if (MODEST_IS_MAIN_WINDOW (window)) {
3796 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
3797 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3798 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
3800 /* not supported window for this action */
3801 g_return_if_reached ();
3806 modest_ui_actions_on_settings (GtkAction *action,
3811 dialog = modest_platform_get_global_settings_dialog ();
3812 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3813 gtk_widget_show_all (dialog);
3815 gtk_dialog_run (GTK_DIALOG (dialog));
3817 gtk_widget_destroy (dialog);
3821 modest_ui_actions_on_help (GtkAction *action,
3824 const gchar *help_id = NULL;
3826 if (MODEST_IS_MAIN_WINDOW (win)) {
3827 const gchar *action_name;
3828 action_name = gtk_action_get_name (action);
3830 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3831 !strcmp (action_name, "HeaderViewCSMHelp")) {
3832 GtkWidget *folder_view;
3833 TnyFolderStore *folder_store;
3834 /* Get selected folder */
3835 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3836 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3837 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3839 /* Switch help_id */
3840 if (TNY_IS_FOLDER (folder_store)) {
3841 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
3842 case TNY_FOLDER_TYPE_NORMAL:
3843 help_id = "applications_email_managefolders";
3845 case TNY_FOLDER_TYPE_INBOX:
3846 help_id = "applications_email_inbox";
3848 case TNY_FOLDER_TYPE_OUTBOX:
3849 help_id = "applications_email_outbox";
3851 case TNY_FOLDER_TYPE_SENT:
3852 help_id = "applications_email_sent";
3854 case TNY_FOLDER_TYPE_DRAFTS:
3855 help_id = "applications_email_drafts";
3857 case TNY_FOLDER_TYPE_ARCHIVE:
3858 help_id = "applications_email_managefolders";
3861 help_id = "applications_email_managefolders";
3864 help_id = "applications_email_mainview";
3866 g_object_unref (folder_store);
3868 help_id = "applications_email_mainview";
3870 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3871 help_id = "applications_email_viewer";
3872 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3873 help_id = "applications_email_editor";
3875 modest_platform_show_help (GTK_WINDOW (win), help_id);
3879 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3880 ModestWindow *window)
3882 ModestMailOperation *mail_op;
3886 headers = get_selected_headers (window);
3890 /* Create mail operation */
3891 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3893 modest_ui_actions_get_msgs_full_error_handler,
3895 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3896 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3899 g_object_unref (headers);
3900 g_object_unref (mail_op);
3904 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3905 ModestWindow *window)
3907 g_return_if_fail (MODEST_IS_WINDOW (window));
3910 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3914 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3915 ModestWindow *window)
3917 g_return_if_fail (MODEST_IS_WINDOW (window));
3920 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3924 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3925 ModestWindow *window)
3927 g_return_if_fail (MODEST_IS_WINDOW (window));
3930 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3934 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3935 ModestWindow *window)
3937 g_return_if_fail (MODEST_IS_WINDOW (window));
3940 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3944 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3945 ModestWindow *window)
3947 g_return_if_fail (MODEST_IS_WINDOW (window));
3950 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3954 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3955 ModestWindow *window)
3957 g_return_if_fail (MODEST_IS_WINDOW (window));
3960 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3964 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3965 ModestWindow *window)
3967 g_return_if_fail (MODEST_IS_WINDOW (window));
3970 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3974 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3975 ModestWindow *window)
3977 g_return_if_fail (MODEST_IS_WINDOW (window));
3980 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3984 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3986 g_return_if_fail (MODEST_IS_WINDOW (window));
3989 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3993 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3995 g_return_if_fail (MODEST_IS_WINDOW (window));
3997 modest_platform_show_search_messages (GTK_WINDOW (window));
4001 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
4003 g_return_if_fail (MODEST_IS_WINDOW (win));
4004 modest_platform_show_addressbook (GTK_WINDOW (win));
4009 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
4010 ModestWindow *window)
4012 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4014 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
4018 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
4019 ModestMailOperationState *state,
4022 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
4024 /* Set send/receive operation finished */
4025 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
4026 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));