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>
48 #include <tny-camel-folder.h>
49 #include <tny-camel-imap-folder.h>
50 #include <tny-camel-pop-folder.h>
52 #ifdef MODEST_PLATFORM_MAEMO
53 #include "maemo/modest-osso-state-saving.h"
54 #include "maemo/modest-maemo-utils.h"
55 #include "maemo/modest-hildon-includes.h"
56 #endif /* MODEST_PLATFORM_MAEMO */
58 #include "widgets/modest-ui-constants.h"
59 #include <widgets/modest-main-window.h>
60 #include <widgets/modest-msg-view-window.h>
61 #include <widgets/modest-account-view-window.h>
62 #include <widgets/modest-details-dialog.h>
63 #include <widgets/modest-attachments-view.h>
64 #include "widgets/modest-folder-view.h"
65 #include "widgets/modest-global-settings-dialog.h"
66 #include "modest-connection-specific-smtp-window.h"
67 #include "modest-account-mgr-helpers.h"
68 #include "modest-mail-operation.h"
69 #include "modest-text-utils.h"
71 #ifdef MODEST_HAVE_EASYSETUP
72 #include "easysetup/modest-easysetup-wizard.h"
73 #endif /* MODEST_HAVE_EASYSETUP */
75 #include <modest-widget-memory.h>
76 #include <tny-error.h>
77 #include <tny-simple-list.h>
78 #include <tny-msg-view.h>
79 #include <tny-device.h>
80 #include <tny-merge-folder.h>
82 #include <gtkhtml/gtkhtml.h>
84 typedef struct _GetMsgAsyncHelper {
86 ModestMailOperation *mail_op;
93 typedef enum _ReplyForwardAction {
99 typedef struct _ReplyForwardHelper {
100 guint reply_forward_type;
101 ReplyForwardAction action;
103 GtkWidget *parent_window;
104 } ReplyForwardHelper;
106 typedef struct _PasteAsAttachmentHelper {
107 ModestMsgEditWindow *window;
109 } PasteAsAttachmentHelper;
113 * The do_headers_action uses this kind of functions to perform some
114 * action to each member of a list of headers
116 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
118 static void do_headers_action (ModestWindow *win,
122 static void open_msg_cb (ModestMailOperation *mail_op,
127 static void reply_forward_cb (ModestMailOperation *mail_op,
132 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
134 static void folder_refreshed_cb (ModestMailOperation *mail_op,
138 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
139 ModestMailOperationState *state,
142 static gint header_list_count_uncached_msgs (
143 TnyList *header_list,
145 static gboolean connect_to_get_msg (
147 gint num_of_uncached_msgs);
151 /* Show the account creation wizard dialog.
152 * returns: TRUE if an account was created. FALSE if the user cancelled.
155 modest_run_account_setup_wizard (ModestWindow *win)
157 gboolean result = FALSE;
160 wizard = modest_window_mgr_get_easysetup_dialog
161 (modest_runtime_get_window_mgr());
163 /* old wizard is active already; present it and
164 * act as if the user cancelled the non-existing
167 printf ("wizard already active\n");
170 /* there is no such wizard yet */
171 wizard = GTK_DIALOG(modest_easysetup_wizard_dialog_new ());
172 modest_window_mgr_set_easysetup_dialog
173 (modest_runtime_get_window_mgr(), GTK_DIALOG(wizard));
177 /* always present a main window in the background
178 * we do it here, so we cannot end up with to wizards (as this
179 * function might be called in modest_window_mgr_get_main_window as well */
181 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr());
183 /* make sure the mainwindow is visible */
184 gtk_widget_show_all (GTK_WIDGET(win));
185 gtk_window_present (GTK_WINDOW(win));
188 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
190 /* Don't make this a modal window, because secondary windows will then
191 * be unusable, freezing the UI: */
192 /* gtk_window_set_modal (GTK_WINDOW (wizard), TRUE); */
194 gint dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
195 if (dialog_response == GTK_RESPONSE_CANCEL)
198 /* Check whether an account was created: */
199 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
202 gtk_widget_destroy (GTK_WIDGET (wizard));
204 /* clear it from the window mgr */
205 modest_window_mgr_set_easysetup_dialog
206 (modest_runtime_get_window_mgr(), NULL);
213 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
216 const gchar *authors[] = {
217 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
220 about = gtk_about_dialog_new ();
221 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
222 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
223 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
224 _("Copyright (c) 2006, Nokia Corporation\n"
225 "All rights reserved."));
226 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
227 _("a modest e-mail client\n\n"
228 "design and implementation: Dirk-Jan C. Binnema\n"
229 "contributions from the fine people at KC and Ig\n"
230 "uses the tinymail email framework written by Philip van Hoof"));
231 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
232 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
233 gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
234 gtk_window_set_modal (GTK_WINDOW (about), TRUE);
236 gtk_dialog_run (GTK_DIALOG (about));
237 gtk_widget_destroy(about);
241 * Gets the list of currently selected messages. If the win is the
242 * main window, then it returns a newly allocated list of the headers
243 * selected in the header view. If win is the msg view window, then
244 * the value returned is a list with just a single header.
246 * The caller of this funcion must free the list.
249 get_selected_headers (ModestWindow *win)
251 if (MODEST_IS_MAIN_WINDOW(win)) {
252 GtkWidget *header_view;
254 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
255 MODEST_WIDGET_TYPE_HEADER_VIEW);
256 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
258 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
259 /* for MsgViewWindows, we simply return a list with one element */
261 TnyList *list = NULL;
263 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
264 if (header != NULL) {
265 list = tny_simple_list_new ();
266 tny_list_prepend (list, G_OBJECT(header));
267 g_object_unref (G_OBJECT(header));
277 headers_action_mark_as_read (TnyHeader *header,
281 TnyHeaderFlags flags;
283 g_return_if_fail (TNY_IS_HEADER(header));
285 flags = tny_header_get_flags (header);
286 if (flags & TNY_HEADER_FLAG_SEEN) return;
287 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
291 headers_action_mark_as_unread (TnyHeader *header,
295 TnyHeaderFlags flags;
297 g_return_if_fail (TNY_IS_HEADER(header));
299 flags = tny_header_get_flags (header);
300 if (flags & TNY_HEADER_FLAG_SEEN) {
301 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
305 /** A convenience method, because deleting a message is
306 * otherwise complicated, and it's best to change it in one place
309 void modest_do_message_delete (TnyHeader *header, ModestWindow *win)
311 ModestMailOperation *mail_op = NULL;
312 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
313 win ? G_OBJECT(win) : NULL);
314 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
317 /* Always delete. TODO: Move to trash still not supported */
318 modest_mail_operation_remove_msg (mail_op, header, FALSE);
319 g_object_unref (G_OBJECT (mail_op));
322 /** A convenience method, because deleting a message is
323 * otherwise complicated, and it's best to change it in one place
326 void modest_do_messages_delete (TnyList *headers, ModestWindow *win)
328 ModestMailOperation *mail_op = NULL;
329 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
330 win ? G_OBJECT(win) : NULL);
331 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
334 /* Always delete. TODO: Move to trash still not supported */
335 modest_mail_operation_remove_msgs (mail_op, headers, FALSE);
336 g_object_unref (G_OBJECT (mail_op));
340 /* headers_action_delete (TnyHeader *header, */
341 /* ModestWindow *win, */
342 /* gpointer user_data) */
344 /* modest_do_message_delete (header, win); */
348 /** After deleing a message that is currently visible in a window,
349 * show the next message from the list, or close the window if there are no more messages.
351 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
353 /* Close msg view window or select next */
354 if (modest_msg_view_window_last_message_selected (win) &&
355 modest_msg_view_window_first_message_selected (win)) {
356 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
358 if (!modest_msg_view_window_select_next_message (win)) {
360 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
366 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
368 TnyList *header_list = NULL;
369 TnyIterator *iter = NULL;
370 TnyHeader *header = NULL;
371 gchar *message = NULL;
374 ModestWindowMgr *mgr;
375 GtkWidget *header_view = NULL;
377 g_return_if_fail (MODEST_IS_WINDOW(win));
379 /* Check first if the header view has the focus */
380 if (MODEST_IS_MAIN_WINDOW (win)) {
382 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
383 MODEST_WIDGET_TYPE_HEADER_VIEW);
384 if (!gtk_widget_is_focus (header_view))
388 /* Get the headers, either from the header view (if win is the main window),
389 * or from the message view window: */
390 header_list = get_selected_headers (win);
391 if (!header_list) return;
393 /* Check if any of the headers are already opened, or in the process of being opened */
394 if (MODEST_IS_MAIN_WINDOW (win)) {
396 iter = tny_list_create_iterator (header_list);
398 mgr = modest_runtime_get_window_mgr ();
399 while (!tny_iterator_is_done (iter) && !found) {
400 header = TNY_HEADER (tny_iterator_get_current (iter));
402 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
403 g_object_unref (header);
406 tny_iterator_next (iter);
408 g_object_unref (iter);
413 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
414 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
416 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
420 g_object_unref (header_list);
426 if (tny_list_get_length(header_list) == 1) {
427 iter = tny_list_create_iterator (header_list);
428 header = TNY_HEADER (tny_iterator_get_current (iter));
430 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
431 g_object_unref (header);
434 g_object_unref (iter);
436 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
437 tny_list_get_length(header_list)), desc);
439 /* Confirmation dialog */
440 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
444 if (response == GTK_RESPONSE_OK) {
445 ModestWindow *main_window = NULL;
446 ModestWindowMgr *mgr = NULL;
447 GtkTreeModel *model = NULL;
448 GtkTreeSelection *sel = NULL;
449 GList *sel_list = NULL, *tmp = NULL;
450 GtkTreeRowReference *row_reference = NULL;
451 GtkTreePath *next_path = NULL;
454 /* Find last selected row */
455 if (MODEST_IS_MAIN_WINDOW (win)) {
456 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
457 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
458 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
459 for (tmp=sel_list; tmp; tmp=tmp->next) {
460 if (tmp->next == NULL) {
461 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
462 gtk_tree_path_next (next_path);
463 row_reference = gtk_tree_row_reference_new (model, next_path);
464 gtk_tree_path_free (next_path);
469 /* Disable window dimming management */
470 modest_window_disable_dimming (MODEST_WINDOW(win));
472 /* Remove each header. If it's a view window header_view == NULL */
473 /* do_headers_action (win, headers_action_delete, header_view); */
474 modest_do_messages_delete (header_list, win);
477 /* Enable window dimming management */
478 gtk_tree_selection_unselect_all (sel);
479 modest_window_enable_dimming (MODEST_WINDOW(win));
481 /* FIXME: May be folder_monitor will also refilter treemode on EXPUNGE changes ? */
482 /* refresh the header view (removing marked-as-deleted) */
483 /* modest_header_view_refilter (MODEST_HEADER_VIEW(header_view)); */
485 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
486 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
488 /* Get main window */
489 mgr = modest_runtime_get_window_mgr ();
490 main_window = modest_window_mgr_get_main_window (mgr);
493 /* Move cursor to next row */
496 /* Select next row */
497 if (gtk_tree_row_reference_valid (row_reference)) {
498 next_path = gtk_tree_row_reference_get_path (row_reference);
499 gtk_tree_selection_select_path (sel, next_path);
500 gtk_tree_path_free (next_path);
502 if (row_reference != NULL)
503 gtk_tree_row_reference_free (row_reference);
507 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, err->code, err->message);
511 /* Update toolbar dimming state */
512 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
515 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
516 g_list_free (sel_list);
522 g_object_unref (header_list);
528 /* delete either message or folder, based on where we are */
530 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
532 g_return_if_fail (MODEST_IS_WINDOW(win));
534 /* Check first if the header view has the focus */
535 if (MODEST_IS_MAIN_WINDOW (win)) {
537 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
538 MODEST_WIDGET_TYPE_FOLDER_VIEW);
539 if (gtk_widget_is_focus (w)) {
540 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
544 modest_ui_actions_on_delete_message (action, win);
550 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
552 #ifdef MODEST_PLATFORM_MAEMO
553 modest_osso_save_state();
554 #endif /* MODEST_PLATFORM_MAEMO */
556 g_debug ("closing down, clearing %d item(s) from operation queue",
557 modest_mail_operation_queue_num_elements
558 (modest_runtime_get_mail_operation_queue()));
560 /* cancel all outstanding operations */
561 modest_mail_operation_queue_cancel_all
562 (modest_runtime_get_mail_operation_queue());
564 g_debug ("queue has been cleared");
566 /* note: when modest-tny-account-store is finalized,
567 it will automatically set all network connections
574 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
578 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
580 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
581 /* gtk_widget_destroy (GTK_WIDGET (win)); */
582 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
583 /* gboolean ret_value; */
584 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
585 /* } else if (MODEST_IS_WINDOW (win)) { */
586 /* gtk_widget_destroy (GTK_WIDGET (win)); */
588 /* g_return_if_reached (); */
593 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
595 GtkClipboard *clipboard = NULL;
596 gchar *selection = NULL;
598 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
599 selection = gtk_clipboard_wait_for_text (clipboard);
601 /* Question: why is the clipboard being used here?
602 * It doesn't really make a lot of sense. */
606 modest_address_book_add_address (selection);
612 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
614 /* This is currently only implemented for Maemo */
615 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
616 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
617 modest_run_account_setup_wizard (win);
620 /* Show the list of accounts: */
621 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
622 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW (win));
624 /* Don't make this a modal window, because secondary windows will then
625 * be unusable, freezing the UI: */
626 /* gtk_window_set_modal (GTK_WINDOW (account_win), TRUE); */
627 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
630 GtkWidget *dialog, *label;
632 /* Create the widgets */
634 dialog = gtk_dialog_new_with_buttons ("Message",
636 GTK_DIALOG_DESTROY_WITH_PARENT,
640 label = gtk_label_new ("Hello World!");
642 /* Ensure that the dialog box is destroyed when the user responds. */
644 g_signal_connect_swapped (dialog, "response",
645 G_CALLBACK (gtk_widget_destroy),
648 /* Add the label, and show everything we've added to the dialog. */
650 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
652 gtk_widget_show_all (dialog);
653 #endif /* MODEST_PLATFORM_MAEMO */
657 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
659 ModestWindow *main_window = MODEST_WINDOW (user_data);
661 /* Save any changes. */
662 modest_connection_specific_smtp_window_save_server_accounts (
663 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
664 modest_window_get_active_account (main_window));
665 gtk_widget_destroy (GTK_WIDGET (window));
671 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
673 /* This is currently only implemented for Maemo,
674 * because it requires an API (libconic) to detect different connection
677 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
679 /* Create the window if necessary: */
680 const gchar *active_account_name = modest_window_get_active_account (win);
682 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
683 * or show the default account?
684 * If we show the default account then the account name should be shown in
685 * the window when we show it. */
686 if (!active_account_name) {
687 g_warning ("%s: No account is active.", __FUNCTION__);
691 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
692 modest_connection_specific_smtp_window_fill_with_connections (
693 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
694 modest_runtime_get_account_mgr(),
695 active_account_name);
697 /* Show the window: */
698 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
699 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
700 gtk_widget_show (specific_window);
702 /* Save changes when the window is hidden: */
703 g_signal_connect (specific_window, "hide",
704 G_CALLBACK (on_smtp_servers_window_hide), win);
705 #endif /* MODEST_PLATFORM_MAEMO */
709 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
711 ModestWindow *msg_win = NULL;
713 TnyFolder *folder = NULL;
714 gchar *account_name = NULL;
715 gchar *from_str = NULL;
716 /* GError *err = NULL; */
717 TnyAccount *account = NULL;
718 ModestWindowMgr *mgr;
719 gchar *signature = NULL, *blank_and_signature = NULL;
721 /* if there are no accounts yet, just show the wizard */
722 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
723 const gboolean created = modest_run_account_setup_wizard (win);
728 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
730 account_name = g_strdup (modest_window_get_active_account (win));
732 g_printerr ("modest: no account found\n");
736 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
738 TNY_ACCOUNT_TYPE_STORE);
740 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
744 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
746 g_printerr ("modest: failed get from string for '%s'\n", account_name);
750 gboolean use_signature = FALSE;
751 signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr (), account_name, &use_signature);
754 blank_and_signature = g_strconcat ("\n", signature, NULL);
756 blank_and_signature = g_strdup ("");
761 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
763 g_printerr ("modest: failed to create new msg\n");
767 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
769 g_printerr ("modest: failed to find Drafts folder\n");
774 /* Create and register edit window */
775 /* This is destroyed by TODO. */
776 msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
777 mgr = modest_runtime_get_window_mgr ();
778 modest_window_mgr_register_window (mgr, msg_win);
781 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
783 gtk_widget_show_all (GTK_WIDGET (msg_win));
786 g_free (account_name);
788 g_free (blank_and_signature);
790 g_object_unref (msg_win);
792 g_object_unref (G_OBJECT(account));
794 g_object_unref (G_OBJECT(msg));
796 g_object_unref (G_OBJECT(folder));
800 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
804 ModestMailOperationStatus status;
806 /* If there is no message or the operation was not successful */
807 status = modest_mail_operation_get_status (mail_op);
808 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
810 /* Remove the header from the preregistered uids */
811 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
821 open_msg_cb (ModestMailOperation *mail_op,
826 ModestWindowMgr *mgr = NULL;
827 ModestWindow *parent_win = NULL;
828 ModestWindow *win = NULL;
829 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
830 gchar *account = NULL;
833 /* Do nothing if there was any problem with the mail
834 operation. The error will be shown by the error_handler of
835 the mail operation */
836 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
840 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
841 folder = tny_header_get_folder (header);
843 /* Mark header as read */
844 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
847 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
849 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
851 /* Gets folder type (OUTBOX headers will be opened in edit window */
852 if (modest_tny_folder_is_local_folder (folder))
853 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
855 /* If the header is in the drafts folder then open the editor,
856 else the message view window */
857 if ((folder_type == TNY_FOLDER_TYPE_DRAFTS) ||
858 (folder_type == TNY_FOLDER_TYPE_OUTBOX)) {
859 /* we cannot edit without a valid account... */
860 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
861 const gboolean created = modest_run_account_setup_wizard(parent_win);
865 win = modest_msg_edit_window_new (msg, account, TRUE);
868 gchar *uid = modest_tny_folder_get_header_unique_id (header);
870 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
871 GtkWidget *header_view;
872 GtkTreeSelection *sel;
873 GList *sel_list = NULL;
876 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
877 MODEST_WIDGET_TYPE_HEADER_VIEW);
879 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
880 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
882 if (sel_list != NULL) {
883 GtkTreeRowReference *row_reference;
885 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
886 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
887 g_list_free (sel_list);
889 win = modest_msg_view_window_new_with_header_model (
890 msg, account, (const gchar*) uid,
891 model, row_reference);
892 gtk_tree_row_reference_free (row_reference);
894 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
897 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
902 /* Register and show new window */
904 mgr = modest_runtime_get_window_mgr ();
905 modest_window_mgr_register_window (mgr, win);
906 g_object_unref (win);
907 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
908 gtk_widget_show_all (GTK_WIDGET(win));
911 /* Update toolbar dimming state */
912 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
913 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
919 g_object_unref (parent_win);
920 g_object_unref (folder);
924 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
928 GObject *win = modest_mail_operation_get_source (mail_op);
930 error = modest_mail_operation_get_error (mail_op);
931 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
933 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
935 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
938 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
939 _("mail_ni_ui_folder_get_msg_folder_error"));
943 g_object_unref (win);
947 * This function is used by both modest_ui_actions_on_open and
948 * modest_ui_actions_on_header_activated. This way we always do the
949 * same when trying to open messages.
952 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
954 ModestWindowMgr *mgr = NULL;
955 TnyIterator *iter = NULL;
956 ModestMailOperation *mail_op = NULL;
957 TnyList *not_opened_headers = NULL;
958 TnyHeaderFlags flags = 0;
960 g_return_if_fail (headers != NULL);
962 /* Check that only one message is selected for opening */
963 if (tny_list_get_length (headers) != 1) {
964 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
965 _("mcen_ib_select_one_message"));
970 /* Look if we already have a message view for each header. If
971 true, then remove the header from the list of headers to
973 mgr = modest_runtime_get_window_mgr ();
974 iter = tny_list_create_iterator (headers);
975 not_opened_headers = tny_simple_list_new ();
977 while (!tny_iterator_is_done (iter)) {
979 ModestWindow *window = NULL;
980 TnyHeader *header = NULL;
981 gboolean found = FALSE;
983 header = TNY_HEADER (tny_iterator_get_current (iter));
985 flags = tny_header_get_flags (header);
988 found = modest_window_mgr_find_registered_header (mgr, header, &window);
990 /* Do not open again the message and present the
991 window to the user */
994 gtk_window_present (GTK_WINDOW (window));
996 /* the header has been registered already, we don't do
997 * anything but wait for the window to come up*/
998 g_debug ("header %p already registered, waiting for window", header);
1000 tny_list_append (not_opened_headers, G_OBJECT (header));
1004 g_object_unref (header);
1006 tny_iterator_next (iter);
1008 g_object_unref (iter);
1011 /* If some messages would have to be downloaded, ask the user to
1012 * make a connection. It's generally easier to do this here (in the mainloop)
1013 * than later in a thread:
1015 if (tny_list_get_length (not_opened_headers) > 0) {
1017 gboolean found = FALSE;
1019 iter = tny_list_create_iterator (not_opened_headers);
1020 while (!tny_iterator_is_done (iter) && !found) {
1021 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1022 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1025 tny_iterator_next (iter);
1027 g_object_unref (header);
1029 g_object_unref (iter);
1031 if (found && !modest_platform_connect_and_wait (GTK_WINDOW (win), NULL)) {
1032 g_object_unref (not_opened_headers);
1037 /* Register the headers before actually creating the windows: */
1038 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
1039 while (!tny_iterator_is_done (iter_not_opened)) {
1040 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
1042 modest_window_mgr_register_header (mgr, header);
1043 g_object_unref (header);
1046 tny_iterator_next (iter_not_opened);
1048 g_object_unref (iter_not_opened);
1049 iter_not_opened = NULL;
1051 /* Open each message */
1052 if (tny_list_get_length (not_opened_headers) > 0) {
1053 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1055 modest_ui_actions_get_msgs_full_error_handler,
1057 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1058 if (tny_list_get_length (not_opened_headers) > 1) {
1059 modest_mail_operation_get_msgs_full (mail_op,
1065 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
1066 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1067 modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
1068 g_object_unref (header);
1069 g_object_unref (iter);
1071 g_object_unref (mail_op);
1075 if (not_opened_headers != NULL)
1076 g_object_unref (not_opened_headers);
1080 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1085 headers = get_selected_headers (win);
1090 _modest_ui_actions_open (headers, win);
1092 g_object_unref(headers);
1097 free_reply_forward_helper (gpointer data)
1099 ReplyForwardHelper *helper;
1101 helper = (ReplyForwardHelper *) data;
1102 g_free (helper->account_name);
1103 g_slice_free (ReplyForwardHelper, helper);
1107 reply_forward_cb (ModestMailOperation *mail_op,
1113 ReplyForwardHelper *rf_helper;
1114 ModestWindow *msg_win = NULL;
1115 ModestEditType edit_type;
1117 TnyAccount *account = NULL;
1118 ModestWindowMgr *mgr = NULL;
1119 gchar *signature = NULL;
1121 /* If there was any error. The mail operation could be NULL,
1122 this means that we already have the message downloaded and
1123 that we didn't do a mail operation to retrieve it */
1124 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1127 g_return_if_fail (user_data != NULL);
1128 rf_helper = (ReplyForwardHelper *) user_data;
1130 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1131 rf_helper->account_name);
1132 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1133 rf_helper->account_name,
1134 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1135 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1136 rf_helper->account_name,
1137 MODEST_ACCOUNT_SIGNATURE, FALSE);
1140 /* Create reply mail */
1141 switch (rf_helper->action) {
1144 modest_tny_msg_create_reply_msg (msg, header, from, signature,
1145 rf_helper->reply_forward_type,
1146 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1148 case ACTION_REPLY_TO_ALL:
1150 modest_tny_msg_create_reply_msg (msg, header, from, signature, rf_helper->reply_forward_type,
1151 MODEST_TNY_MSG_REPLY_MODE_ALL);
1152 edit_type = MODEST_EDIT_TYPE_REPLY;
1154 case ACTION_FORWARD:
1156 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1157 edit_type = MODEST_EDIT_TYPE_FORWARD;
1160 g_return_if_reached ();
1167 g_printerr ("modest: failed to create message\n");
1171 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1172 rf_helper->account_name,
1173 TNY_ACCOUNT_TYPE_STORE);
1175 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1179 /* Create and register the windows */
1180 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
1181 mgr = modest_runtime_get_window_mgr ();
1182 modest_window_mgr_register_window (mgr, msg_win);
1184 if (rf_helper->parent_window != NULL) {
1185 gdouble parent_zoom;
1187 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1188 modest_window_set_zoom (msg_win, parent_zoom);
1191 /* Show edit window */
1192 gtk_widget_show_all (GTK_WIDGET (msg_win));
1196 g_object_unref (msg_win);
1198 g_object_unref (G_OBJECT (new_msg));
1200 g_object_unref (G_OBJECT (account));
1201 /* g_object_unref (msg); */
1202 free_reply_forward_helper (rf_helper);
1205 /* Checks a list of headers. If any of them are not currently
1206 * downloaded (CACHED) then returns TRUE else returns FALSE.
1209 header_list_count_uncached_msgs (
1210 TnyList *header_list,
1214 gint uncached_messages = 0;
1216 iter = tny_list_create_iterator (header_list);
1217 while (!tny_iterator_is_done (iter)) {
1220 header = TNY_HEADER (tny_iterator_get_current (iter));
1222 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1223 uncached_messages ++;
1224 g_object_unref (header);
1227 tny_iterator_next (iter);
1229 g_object_unref (iter);
1231 return uncached_messages;
1234 /* Returns FALSE if the user does not want to download the
1235 * messages. Returns TRUE if the user allowed the download.
1238 connect_to_get_msg (GtkWindow *win,
1239 gint num_of_uncached_msgs)
1241 /* Allways download if we are online. */
1242 if (tny_device_is_online (modest_runtime_get_device ()))
1245 /* If offline, then ask for user permission to download the messages */
1246 GtkResponseType response;
1247 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1248 ngettext("mcen_nc_get_msg",
1250 num_of_uncached_msgs));
1251 if (response == GTK_RESPONSE_CANCEL)
1254 return modest_platform_connect_and_wait(win, NULL);
1258 * Common code for the reply and forward actions
1261 reply_forward (ReplyForwardAction action, ModestWindow *win)
1263 ModestMailOperation *mail_op = NULL;
1264 TnyList *header_list = NULL;
1265 ReplyForwardHelper *rf_helper = NULL;
1266 guint reply_forward_type;
1267 gboolean continue_download = TRUE;
1268 gboolean do_retrieve = TRUE;
1270 g_return_if_fail (MODEST_IS_WINDOW(win));
1272 /* we need an account when editing */
1273 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1274 const gboolean created = modest_run_account_setup_wizard (win);
1279 header_list = get_selected_headers (win);
1283 reply_forward_type =
1284 modest_conf_get_int (modest_runtime_get_conf (),
1285 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1288 /* check if we need to download msg before asking about it */
1289 do_retrieve = (action == ACTION_FORWARD) ||
1290 (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1293 gint num_of_unc_msgs;
1294 /* check that the messages have been previously downloaded */
1295 num_of_unc_msgs = header_list_count_uncached_msgs(
1298 /* If there are any uncached message ask the user
1299 * whether he/she wants to download them. */
1300 if (num_of_unc_msgs)
1301 continue_download = connect_to_get_msg (
1306 if (!continue_download) {
1307 g_object_unref (header_list);
1311 /* We assume that we can only select messages of the
1312 same folder and that we reply all of them from the
1313 same account. In fact the interface currently only
1314 allows single selection */
1317 rf_helper = g_slice_new0 (ReplyForwardHelper);
1318 rf_helper->reply_forward_type = reply_forward_type;
1319 rf_helper->action = action;
1320 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1322 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1323 rf_helper->parent_window = GTK_WIDGET (win);
1324 if (!rf_helper->account_name)
1325 rf_helper->account_name =
1326 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1328 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1331 /* Get header and message. Do not free them here, the
1332 reply_forward_cb must do it */
1333 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1334 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1335 if (!msg || !header) {
1337 g_object_unref (msg);
1338 g_printerr ("modest: no message found\n");
1341 reply_forward_cb (NULL, header, msg, rf_helper);
1344 g_object_unref (header);
1349 /* Only reply/forward to one message */
1350 iter = tny_list_create_iterator (header_list);
1351 header = TNY_HEADER (tny_iterator_get_current (iter));
1352 g_object_unref (iter);
1355 /* Retrieve messages */
1357 mail_op = modest_mail_operation_new_with_error_handling (
1358 MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1360 modest_ui_actions_get_msgs_full_error_handler,
1362 modest_mail_operation_queue_add (
1363 modest_runtime_get_mail_operation_queue (), mail_op);
1365 modest_mail_operation_get_msg (mail_op,
1370 g_object_unref(mail_op);
1372 /* we put a ref here to prevent double unref as the reply
1373 * forward callback unrefs the header at its end */
1374 reply_forward_cb (NULL, header, NULL, rf_helper);
1378 g_object_unref (header);
1384 g_object_unref (header_list);
1388 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1390 g_return_if_fail (MODEST_IS_WINDOW(win));
1392 reply_forward (ACTION_REPLY, win);
1396 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1398 g_return_if_fail (MODEST_IS_WINDOW(win));
1400 reply_forward (ACTION_FORWARD, win);
1404 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1406 g_return_if_fail (MODEST_IS_WINDOW(win));
1408 reply_forward (ACTION_REPLY_TO_ALL, win);
1412 modest_ui_actions_on_next (GtkAction *action,
1413 ModestWindow *window)
1415 if (MODEST_IS_MAIN_WINDOW (window)) {
1416 GtkWidget *header_view;
1418 header_view = modest_main_window_get_child_widget (
1419 MODEST_MAIN_WINDOW(window),
1420 MODEST_WIDGET_TYPE_HEADER_VIEW);
1424 modest_header_view_select_next (
1425 MODEST_HEADER_VIEW(header_view));
1426 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1427 modest_msg_view_window_select_next_message (
1428 MODEST_MSG_VIEW_WINDOW (window));
1430 g_return_if_reached ();
1435 modest_ui_actions_on_prev (GtkAction *action,
1436 ModestWindow *window)
1438 g_return_if_fail (MODEST_IS_WINDOW(window));
1440 if (MODEST_IS_MAIN_WINDOW (window)) {
1441 GtkWidget *header_view;
1442 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1443 MODEST_WIDGET_TYPE_HEADER_VIEW);
1447 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1448 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1449 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1451 g_return_if_reached ();
1456 modest_ui_actions_on_sort (GtkAction *action,
1457 ModestWindow *window)
1459 g_return_if_fail (MODEST_IS_WINDOW(window));
1461 if (MODEST_IS_MAIN_WINDOW (window)) {
1462 GtkWidget *header_view;
1463 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1464 MODEST_WIDGET_TYPE_HEADER_VIEW);
1466 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1471 /* Show sorting dialog */
1472 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1477 new_messages_arrived (ModestMailOperation *self,
1481 ModestMainWindow *win = NULL;
1482 GtkWidget *folder_view = NULL;
1483 TnyFolderStore *folder = NULL;
1484 gboolean folder_empty = FALSE;
1486 g_return_if_fail (MODEST_IS_MAIN_WINDOW (user_data));
1487 win = MODEST_MAIN_WINDOW (user_data);
1489 /* Set contents style of headers view */
1490 if (modest_main_window_get_contents_style (win) == MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY) {
1491 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1492 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1493 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1496 folder_empty = (tny_folder_get_all_count (TNY_FOLDER (folder)) == 0);
1499 modest_main_window_set_contents_style (win,
1500 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1503 /* Notify new messages have been downloaded */
1504 if (new_messages > 0)
1505 modest_platform_on_new_msg ();
1509 * This function performs the send & receive required actions. The
1510 * window is used to create the mail operation. Typically it should
1511 * always be the main window, but we pass it as argument in order to
1515 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1517 gchar *acc_name = NULL;
1518 ModestMailOperation *mail_op;
1520 /* If no account name was provided then get the current account, and if
1521 there is no current account then pick the default one: */
1522 if (!account_name) {
1523 acc_name = g_strdup (modest_window_get_active_account(win));
1525 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1527 g_printerr ("modest: cannot get default account\n");
1531 acc_name = g_strdup (account_name);
1534 /* Set send/receive operation in progress */
1535 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1537 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1539 modest_ui_actions_send_receive_error_handler,
1542 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1543 G_CALLBACK (_on_send_receive_progress_changed),
1546 /* Send & receive. */
1547 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1548 /* Receive and then send. The operation is tagged initially as
1549 a receive operation because the account update performs a
1550 receive and then a send. The operation changes its type
1551 internally, so the progress objects will receive the proper
1552 progress information */
1553 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1554 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, win);
1555 g_object_unref (G_OBJECT (mail_op));
1563 modest_ui_actions_do_cancel_send (const gchar *account_name,
1566 TnyTransportAccount *transport_account;
1567 TnySendQueue *send_queue = NULL;
1568 GError *error = NULL;
1570 /* Get transport account */
1572 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1573 (modest_runtime_get_account_store(),
1575 TNY_ACCOUNT_TYPE_TRANSPORT));
1576 if (!transport_account) {
1577 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1582 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1583 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1584 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1585 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1586 "modest: could not find send queue for account\n");
1588 /* Keeep messages in outbox folder */
1589 tny_send_queue_cancel (send_queue, FALSE, &error);
1593 if (transport_account != NULL)
1594 g_object_unref (G_OBJECT (transport_account));
1598 modest_ui_actions_cancel_send_all (ModestWindow *win)
1600 GSList *account_names, *iter;
1602 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1605 iter = account_names;
1607 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1608 iter = g_slist_next (iter);
1611 modest_account_mgr_free_account_names (account_names);
1612 account_names = NULL;
1616 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1619 /* Check if accounts exist */
1620 gboolean accounts_exist =
1621 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1623 /* If not, allow the user to create an account before trying to send/receive. */
1624 if (!accounts_exist)
1625 modest_ui_actions_on_accounts (NULL, win);
1627 /* Cancel all sending operaitons */
1628 modest_ui_actions_cancel_send_all (win);
1632 * Refreshes all accounts. This function will be used by automatic
1636 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1638 GSList *account_names, *iter;
1640 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1643 iter = account_names;
1645 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1646 iter = g_slist_next (iter);
1649 modest_account_mgr_free_account_names (account_names);
1650 account_names = NULL;
1654 modest_do_refresh_current_folder(ModestWindow *win)
1656 /* Refresh currently selected folder. Note that if we only
1657 want to retreive the headers, then the refresh only will
1658 invoke a poke_status over all folders, i.e., only the
1659 total/unread count will be updated */
1660 if (MODEST_IS_MAIN_WINDOW (win)) {
1661 GtkWidget *header_view, *folder_view;
1662 TnyFolderStore *folder_store;
1664 /* Get folder and header view */
1666 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1667 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1671 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1673 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1675 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1676 MODEST_WIDGET_TYPE_HEADER_VIEW);
1678 /* We do not need to set the contents style
1679 because it hasn't changed. We also do not
1680 need to save the widget status. Just force
1682 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1683 TNY_FOLDER (folder_store),
1684 folder_refreshed_cb,
1685 MODEST_MAIN_WINDOW (win));
1689 g_object_unref (folder_store);
1695 * Handler of the click on Send&Receive button in the main toolbar
1698 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1700 /* Check if accounts exist */
1701 gboolean accounts_exist =
1702 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1704 /* If not, allow the user to create an account before trying to send/receive. */
1705 if (!accounts_exist)
1706 modest_ui_actions_on_accounts (NULL, win);
1708 modest_do_refresh_current_folder (win);
1710 /* Refresh the active account */
1711 modest_ui_actions_do_send_receive (NULL, win);
1716 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1719 GtkWidget *header_view;
1721 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1723 header_view = modest_main_window_get_child_widget (main_window,
1724 MODEST_WIDGET_TYPE_HEADER_VIEW);
1728 conf = modest_runtime_get_conf ();
1730 /* what is saved/restored is depending on the style; thus; we save with
1731 * old style, then update the style, and restore for this new style
1733 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1735 if (modest_header_view_get_style
1736 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1737 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1738 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1740 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1741 MODEST_HEADER_VIEW_STYLE_DETAILS);
1743 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1744 MODEST_CONF_HEADER_VIEW_KEY);
1749 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1751 ModestMainWindow *main_window)
1753 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1754 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1756 /* in the case the folder is empty, show the empty folder message and focus
1758 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
1759 if (modest_header_view_is_empty (header_view)) {
1760 TnyFolder *folder = modest_header_view_get_folder (header_view);
1761 GtkWidget *folder_view =
1762 modest_main_window_get_child_widget (main_window,
1763 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1765 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
1766 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
1770 /* If no header has been selected then exit */
1775 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1776 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1778 /* Update toolbar dimming state */
1779 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1783 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1785 ModestMainWindow *main_window)
1789 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1795 /* headers = tny_simple_list_new (); */
1796 /* tny_list_prepend (headers, G_OBJECT (header)); */
1797 headers = modest_header_view_get_selected_headers (header_view);
1799 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1801 g_object_unref (headers);
1805 set_active_account_from_tny_account (TnyAccount *account,
1806 ModestWindow *window)
1808 const gchar *server_acc_name = tny_account_get_id (account);
1810 /* We need the TnyAccount provided by the
1811 account store because that is the one that
1812 knows the name of the Modest account */
1813 TnyAccount *modest_server_account = modest_server_account =
1814 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1815 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1818 const gchar *modest_acc_name =
1819 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1820 modest_window_set_active_account (window, modest_acc_name);
1821 g_object_unref (modest_server_account);
1826 folder_refreshed_cb (ModestMailOperation *mail_op,
1830 ModestMainWindow *win = NULL;
1831 GtkWidget *header_view;
1832 TnyFolder *current_folder;
1833 gboolean folder_empty = FALSE;
1834 gboolean all_marked_as_deleted = FALSE;
1836 g_return_if_fail (TNY_IS_FOLDER (folder));
1838 win = MODEST_MAIN_WINDOW (user_data);
1840 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1843 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
1844 if (current_folder != NULL && folder != current_folder) {
1849 /* Check if folder is empty and set headers view contents style */
1850 folder_empty = (tny_folder_get_all_count (folder) == 0);
1851 all_marked_as_deleted = modest_header_view_is_empty (MODEST_HEADER_VIEW(header_view));
1852 folder_empty = folder_empty || all_marked_as_deleted ;
1855 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1856 modest_main_window_set_contents_style (win,
1857 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1859 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1864 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1865 TnyFolderStore *folder_store,
1867 ModestMainWindow *main_window)
1870 GtkWidget *header_view;
1872 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1874 header_view = modest_main_window_get_child_widget(main_window,
1875 MODEST_WIDGET_TYPE_HEADER_VIEW);
1879 conf = modest_runtime_get_conf ();
1881 if (TNY_IS_ACCOUNT (folder_store)) {
1883 /* Update active account */
1884 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1885 /* Show account details */
1886 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1889 if (TNY_IS_FOLDER (folder_store) && selected) {
1891 /* Update the active account */
1892 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1894 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1895 g_object_unref (account);
1899 /* Set the header style by default, it could
1900 be changed later by the refresh callback to
1902 modest_main_window_set_contents_style (main_window,
1903 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1905 /* Set folder on header view. This function
1906 will call tny_folder_refresh_async so we
1907 pass a callback that will be called when
1908 finished. We use that callback to set the
1909 empty view if there are no messages */
1910 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1911 TNY_FOLDER (folder_store),
1912 folder_refreshed_cb,
1915 /* Restore configuration. We need to do this
1916 *after* the set_folder because the widget
1917 memory asks the header view about its
1919 modest_widget_memory_restore (modest_runtime_get_conf (),
1920 G_OBJECT(header_view),
1921 MODEST_CONF_HEADER_VIEW_KEY);
1923 /* Update the active account */
1924 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1925 /* Save only if we're seeing headers */
1926 if (modest_main_window_get_contents_style (main_window) ==
1927 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1928 modest_widget_memory_save (conf, G_OBJECT (header_view),
1929 MODEST_CONF_HEADER_VIEW_KEY);
1930 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1934 /* Update toolbar dimming state */
1935 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1939 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1946 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1948 online = tny_device_is_online (modest_runtime_get_device());
1951 /* already online -- the item is simply not there... */
1952 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1954 GTK_MESSAGE_WARNING,
1956 _("The %s you selected cannot be found"),
1958 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
1959 gtk_dialog_run (GTK_DIALOG(dialog));
1961 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1964 _("mcen_bd_dialog_cancel"),
1965 GTK_RESPONSE_REJECT,
1966 _("mcen_bd_dialog_ok"),
1967 GTK_RESPONSE_ACCEPT,
1969 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1970 "Do you want to get online?"), item);
1971 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1972 gtk_label_new (txt), FALSE, FALSE, 0);
1973 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1976 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1977 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1978 /* TODO: Comment about why is this commented out: */
1979 /* modest_platform_connect_and_wait (); */
1982 gtk_widget_destroy (dialog);
1986 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1989 /* g_message ("%s %s", __FUNCTION__, link); */
1994 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1997 modest_platform_activate_uri (link);
2001 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2004 modest_platform_show_uri_popup (link);
2008 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2011 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2015 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2016 const gchar *address,
2019 /* g_message ("%s %s", __FUNCTION__, address); */
2023 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2025 TnyTransportAccount *transport_account;
2026 ModestMailOperation *mail_operation;
2028 gchar *account_name, *from;
2029 ModestAccountMgr *account_mgr;
2030 gchar *info_text = NULL;
2032 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
2034 data = modest_msg_edit_window_get_msg_data (edit_window);
2036 account_mgr = modest_runtime_get_account_mgr();
2037 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2039 account_name = modest_account_mgr_get_default_account (account_mgr);
2040 if (!account_name) {
2041 g_printerr ("modest: no account found\n");
2042 modest_msg_edit_window_free_msg_data (edit_window, data);
2046 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2047 account_name = g_strdup (data->account_name);
2051 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2052 (modest_runtime_get_account_store(),
2054 TNY_ACCOUNT_TYPE_TRANSPORT));
2055 if (!transport_account) {
2056 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2057 g_free (account_name);
2058 modest_msg_edit_window_free_msg_data (edit_window, data);
2061 from = modest_account_mgr_get_from_string (account_mgr, account_name);
2063 /* Create the mail operation */
2064 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
2065 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2067 modest_mail_operation_save_to_drafts (mail_operation,
2079 data->priority_flags);
2082 g_free (account_name);
2083 g_object_unref (G_OBJECT (transport_account));
2084 g_object_unref (G_OBJECT (mail_operation));
2086 modest_msg_edit_window_free_msg_data (edit_window, data);
2088 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
2089 modest_platform_information_banner (NULL, NULL, info_text);
2093 /* For instance, when clicking the Send toolbar button when editing a message: */
2095 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2097 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
2099 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
2102 /* Offer the connection dialog, if necessary: */
2103 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window), NULL))
2106 /* FIXME: Code added just for testing. The final version will
2107 use the send queue provided by tinymail and some
2109 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
2110 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2112 account_name = modest_account_mgr_get_default_account (account_mgr);
2114 if (!account_name) {
2115 /* Run account setup wizard */
2116 const gboolean created = modest_run_account_setup_wizard(MODEST_WINDOW(edit_window));
2121 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
2123 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2124 account_name = g_strdup (data->account_name);
2127 /* Get the currently-active transport account for this modest account: */
2128 TnyTransportAccount *transport_account =
2129 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
2130 (modest_runtime_get_account_store(),
2132 if (!transport_account) {
2133 /* Run account setup wizard */
2134 const gboolean created = modest_run_account_setup_wizard(MODEST_WINDOW(edit_window));
2139 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
2141 /* Create the mail operation */
2142 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
2143 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2145 modest_mail_operation_send_new_mail (mail_operation,
2156 data->priority_flags);
2160 g_free (account_name);
2161 g_object_unref (G_OBJECT (transport_account));
2162 g_object_unref (G_OBJECT (mail_operation));
2164 modest_msg_edit_window_free_msg_data (edit_window, data);
2165 modest_msg_edit_window_set_sent (edit_window, TRUE);
2167 /* Save settings and close the window: */
2168 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2172 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2173 ModestMsgEditWindow *window)
2175 ModestMsgEditFormatState *format_state = NULL;
2177 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2178 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2180 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2183 format_state = modest_msg_edit_window_get_format_state (window);
2184 g_return_if_fail (format_state != NULL);
2186 format_state->bold = gtk_toggle_action_get_active (action);
2187 modest_msg_edit_window_set_format_state (window, format_state);
2188 g_free (format_state);
2193 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2194 ModestMsgEditWindow *window)
2196 ModestMsgEditFormatState *format_state = NULL;
2198 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2199 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2201 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2204 format_state = modest_msg_edit_window_get_format_state (window);
2205 g_return_if_fail (format_state != NULL);
2207 format_state->italics = gtk_toggle_action_get_active (action);
2208 modest_msg_edit_window_set_format_state (window, format_state);
2209 g_free (format_state);
2214 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2215 ModestMsgEditWindow *window)
2217 ModestMsgEditFormatState *format_state = NULL;
2219 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2220 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2222 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2225 format_state = modest_msg_edit_window_get_format_state (window);
2226 g_return_if_fail (format_state != NULL);
2228 format_state->bullet = gtk_toggle_action_get_active (action);
2229 modest_msg_edit_window_set_format_state (window, format_state);
2230 g_free (format_state);
2235 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2236 GtkRadioAction *selected,
2237 ModestMsgEditWindow *window)
2239 ModestMsgEditFormatState *format_state = NULL;
2240 GtkJustification value;
2242 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2244 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2247 value = gtk_radio_action_get_current_value (selected);
2249 format_state = modest_msg_edit_window_get_format_state (window);
2250 g_return_if_fail (format_state != NULL);
2252 format_state->justification = value;
2253 modest_msg_edit_window_set_format_state (window, format_state);
2254 g_free (format_state);
2258 modest_ui_actions_on_select_editor_color (GtkAction *action,
2259 ModestMsgEditWindow *window)
2261 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2262 g_return_if_fail (GTK_IS_ACTION (action));
2264 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2267 modest_msg_edit_window_select_color (window);
2271 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2272 ModestMsgEditWindow *window)
2274 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2275 g_return_if_fail (GTK_IS_ACTION (action));
2277 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2280 modest_msg_edit_window_select_background_color (window);
2284 modest_ui_actions_on_insert_image (GtkAction *action,
2285 ModestMsgEditWindow *window)
2287 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2288 g_return_if_fail (GTK_IS_ACTION (action));
2290 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2293 modest_msg_edit_window_insert_image (window);
2297 modest_ui_actions_on_attach_file (GtkAction *action,
2298 ModestMsgEditWindow *window)
2300 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2301 g_return_if_fail (GTK_IS_ACTION (action));
2303 modest_msg_edit_window_offer_attach_file (window);
2307 modest_ui_actions_on_remove_attachments (GtkAction *action,
2308 ModestMsgEditWindow *window)
2310 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2311 g_return_if_fail (GTK_IS_ACTION (action));
2313 modest_msg_edit_window_remove_attachments (window, NULL);
2317 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2320 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2321 const GError *error = modest_mail_operation_get_error (mail_op);
2325 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2326 modest_mail_operation_get_error (mail_op)->message);
2331 modest_ui_actions_create_folder(GtkWidget *parent_window,
2332 GtkWidget *folder_view)
2334 TnyFolderStore *parent_folder;
2336 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2338 if (parent_folder) {
2339 gboolean finished = FALSE;
2341 gchar *folder_name = NULL, *suggested_name = NULL;
2342 const gchar *proto_str = NULL;
2343 TnyAccount *account;
2345 if (TNY_IS_ACCOUNT (parent_folder))
2346 account = g_object_ref (parent_folder);
2348 account = tny_folder_get_account (TNY_FOLDER (parent_folder));
2349 proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2351 if (proto_str && modest_protocol_info_get_transport_store_protocol (proto_str) ==
2352 MODEST_PROTOCOL_STORE_POP) {
2354 hildon_banner_show_information (NULL, NULL, _("mail_in_ui_folder_create_error"));
2356 g_object_unref (account);
2358 /* Run the new folder dialog */
2360 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2365 g_free (suggested_name);
2366 suggested_name = NULL;
2368 if (result == GTK_RESPONSE_REJECT) {
2371 ModestMailOperation *mail_op;
2372 TnyFolder *new_folder = NULL;
2374 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2375 G_OBJECT(parent_window),
2376 modest_ui_actions_new_folder_error_handler,
2379 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2381 new_folder = modest_mail_operation_create_folder (mail_op,
2383 (const gchar *) folder_name);
2385 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2388 g_object_unref (new_folder);
2391 g_object_unref (mail_op);
2394 suggested_name = folder_name;
2398 g_object_unref (parent_folder);
2403 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2405 GtkWidget *folder_view;
2407 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2409 folder_view = modest_main_window_get_child_widget (main_window,
2410 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2414 modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2418 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2421 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2422 const GError *error = NULL;
2423 const gchar *message = NULL;
2425 /* Get error message */
2426 error = modest_mail_operation_get_error (mail_op);
2428 g_return_if_reached ();
2430 switch (error->code) {
2431 case MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS:
2432 message = _CS("ckdg_ib_folder_already_exists");
2435 g_return_if_reached ();
2438 modest_platform_information_banner (GTK_WIDGET (window), NULL, message);
2442 modest_ui_actions_on_rename_folder (GtkAction *action,
2443 ModestMainWindow *main_window)
2445 TnyFolderStore *folder;
2446 GtkWidget *folder_view;
2447 GtkWidget *header_view;
2449 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2451 folder_view = modest_main_window_get_child_widget (main_window,
2452 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2456 header_view = modest_main_window_get_child_widget (main_window,
2457 MODEST_WIDGET_TYPE_HEADER_VIEW);
2462 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2466 /* Offer the connection dialog if necessary: */
2467 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2468 g_object_unref (G_OBJECT (folder));
2473 if (TNY_IS_FOLDER (folder)) {
2476 const gchar *current_name;
2477 TnyFolderStore *parent;
2479 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2480 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
2481 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window),
2482 parent, current_name,
2484 g_object_unref (parent);
2486 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2487 ModestMailOperation *mail_op;
2488 GtkTreeSelection *sel = NULL;
2491 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2492 G_OBJECT(main_window),
2493 modest_ui_actions_rename_folder_error_handler,
2497 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2500 /* Clear the headers view */
2501 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2502 gtk_tree_selection_unselect_all (sel);
2504 /* Select *after* the changes */
2505 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2506 TNY_FOLDER(folder), TRUE);
2508 modest_mail_operation_rename_folder (mail_op,
2509 TNY_FOLDER (folder),
2510 (const gchar *) folder_name);
2512 g_object_unref (mail_op);
2513 g_free (folder_name);
2516 g_object_unref (folder);
2520 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2523 GObject *win = modest_mail_operation_get_source (mail_op);
2525 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2526 _("mail_in_ui_folder_delete_error"));
2527 g_object_unref (win);
2531 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2533 TnyFolderStore *folder;
2534 GtkWidget *folder_view;
2538 g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2540 folder_view = modest_main_window_get_child_widget (main_window,
2541 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2545 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2547 /* Show an error if it's an account */
2548 if (!TNY_IS_FOLDER (folder)) {
2549 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2550 _("mail_in_ui_folder_delete_error"));
2551 g_object_unref (G_OBJECT (folder));
2555 /* Offer the connection dialog if necessary: */
2556 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2557 g_object_unref (G_OBJECT (folder));
2562 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2563 tny_folder_get_name (TNY_FOLDER (folder)));
2564 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2565 (const gchar *) message);
2568 if (response == GTK_RESPONSE_OK) {
2569 ModestMailOperation *mail_op;
2570 GtkTreeSelection *sel;
2572 /* Unselect the folder before deleting it to free the headers */
2573 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2574 gtk_tree_selection_unselect_all (sel);
2576 /* Create the mail operation */
2578 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2579 G_OBJECT(main_window),
2580 modest_ui_actions_delete_folder_error_handler,
2583 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2585 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2586 g_object_unref (G_OBJECT (mail_op));
2589 g_object_unref (G_OBJECT (folder));
2593 modest_ui_actions_on_delete_folder (GtkAction *action,
2594 ModestMainWindow *main_window)
2596 GtkWidget *folder_view;
2597 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2599 delete_folder (main_window, FALSE);
2600 folder_view = modest_main_window_get_child_widget (main_window,
2601 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2604 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
2608 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2610 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2612 delete_folder (main_window, TRUE);
2617 show_error (GtkWidget *parent_widget, const gchar* text)
2619 hildon_banner_show_information(parent_widget, NULL, text);
2622 GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); */
2624 GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
2631 gtk_dialog_run (dialog);
2632 gtk_widget_destroy (GTK_WIDGET (dialog));
2637 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2638 const gchar* server_account_name,
2643 ModestMainWindow *main_window)
2645 g_return_if_fail(server_account_name);
2646 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2648 /* Initalize output parameters: */
2655 #ifdef MODEST_PLATFORM_MAEMO
2656 /* Maemo uses a different (awkward) button order,
2657 * It should probably just use gtk_alternative_dialog_button_order ().
2659 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2662 _("mcen_bd_dialog_ok"),
2663 GTK_RESPONSE_ACCEPT,
2664 _("mcen_bd_dialog_cancel"),
2665 GTK_RESPONSE_REJECT,
2668 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2672 GTK_RESPONSE_REJECT,
2674 GTK_RESPONSE_ACCEPT,
2676 #endif /* MODEST_PLATFORM_MAEMO */
2678 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2680 gchar *server_name = modest_server_account_get_hostname (
2681 modest_runtime_get_account_mgr(), server_account_name);
2682 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2683 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2688 /* This causes a warning because the logical ID has no %s in it,
2689 * though the translation does, but there is not much we can do about that: */
2690 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2691 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2694 g_free (server_name);
2698 gchar *initial_username = modest_server_account_get_username (
2699 modest_runtime_get_account_mgr(), server_account_name);
2701 GtkWidget *entry_username = gtk_entry_new ();
2702 if (initial_username)
2703 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2704 /* Dim this if a connection has ever succeeded with this username,
2705 * as per the UI spec: */
2706 const gboolean username_known =
2707 modest_server_account_get_username_has_succeeded(
2708 modest_runtime_get_account_mgr(), server_account_name);
2709 gtk_widget_set_sensitive (entry_username, !username_known);
2711 #ifdef MODEST_PLATFORM_MAEMO
2712 /* Auto-capitalization is the default, so let's turn it off: */
2713 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2715 /* Create a size group to be used by all captions.
2716 * Note that HildonCaption does not create a default size group if we do not specify one.
2717 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2718 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2720 GtkWidget *caption = hildon_caption_new (sizegroup,
2721 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2722 gtk_widget_show (entry_username);
2723 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2724 FALSE, FALSE, MODEST_MARGIN_HALF);
2725 gtk_widget_show (caption);
2727 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2729 #endif /* MODEST_PLATFORM_MAEMO */
2732 GtkWidget *entry_password = gtk_entry_new ();
2733 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2734 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2736 #ifdef MODEST_PLATFORM_MAEMO
2737 /* Auto-capitalization is the default, so let's turn it off: */
2738 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2739 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2741 caption = hildon_caption_new (sizegroup,
2742 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2743 gtk_widget_show (entry_password);
2744 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2745 FALSE, FALSE, MODEST_MARGIN_HALF);
2746 gtk_widget_show (caption);
2747 g_object_unref (sizegroup);
2749 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2751 #endif /* MODEST_PLATFORM_MAEMO */
2753 /* This is not in the Maemo UI spec:
2754 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2755 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2759 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2761 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2763 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2765 modest_server_account_set_username (
2766 modest_runtime_get_account_mgr(), server_account_name,
2769 const gboolean username_was_changed =
2770 (strcmp (*username, initial_username) != 0);
2771 if (username_was_changed) {
2772 g_warning ("%s: tinymail does not yet support changing the "
2773 "username in the get_password() callback.\n", __FUNCTION__);
2778 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2780 /* We do not save the password in the configuration,
2781 * because this function is only called for passwords that should
2782 * not be remembered:
2783 modest_server_account_set_password (
2784 modest_runtime_get_account_mgr(), server_account_name,
2793 show_error(GTK_WIDGET (main_window), _("mail_ib_login_cancelled"));
2805 /* This is not in the Maemo UI spec:
2806 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2812 gtk_widget_destroy (dialog);
2814 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2818 modest_ui_actions_on_cut (GtkAction *action,
2819 ModestWindow *window)
2821 GtkWidget *focused_widget;
2822 GtkClipboard *clipboard;
2824 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2825 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2826 if (GTK_IS_EDITABLE (focused_widget)) {
2827 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2828 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2829 gtk_clipboard_store (clipboard);
2830 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2831 GtkTextBuffer *buffer;
2833 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2834 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2835 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2836 gtk_clipboard_store (clipboard);
2837 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2838 TnyList *header_list = modest_header_view_get_selected_headers (
2839 MODEST_HEADER_VIEW (focused_widget));
2840 gboolean continue_download = FALSE;
2841 gint num_of_unc_msgs;
2843 num_of_unc_msgs = header_list_count_uncached_msgs(
2844 header_list, GTK_WINDOW (window));
2846 if (num_of_unc_msgs)
2847 continue_download = connect_to_get_msg(
2848 GTK_WINDOW (window),
2851 if (num_of_unc_msgs == 0 || continue_download) {
2852 /* modest_platform_information_banner (
2853 NULL, NULL, _CS("mcen_ib_getting_items"));*/
2854 modest_header_view_cut_selection (
2855 MODEST_HEADER_VIEW (focused_widget));
2858 g_object_unref (header_list);
2859 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2860 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2865 modest_ui_actions_on_copy (GtkAction *action,
2866 ModestWindow *window)
2868 GtkClipboard *clipboard;
2869 GtkWidget *focused_widget;
2870 gboolean copied = TRUE;
2872 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2873 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2875 if (GTK_IS_LABEL (focused_widget)) {
2876 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2877 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2878 gtk_clipboard_store (clipboard);
2879 } else if (GTK_IS_EDITABLE (focused_widget)) {
2880 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2881 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2882 gtk_clipboard_store (clipboard);
2883 } else if (GTK_IS_HTML (focused_widget)) {
2884 gtk_html_copy (GTK_HTML (focused_widget));
2885 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2886 gtk_clipboard_store (clipboard);
2887 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2888 GtkTextBuffer *buffer;
2889 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2890 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2891 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2892 gtk_clipboard_store (clipboard);
2893 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2894 TnyList *header_list = modest_header_view_get_selected_headers (
2895 MODEST_HEADER_VIEW (focused_widget));
2896 gboolean continue_download = FALSE;
2897 gint num_of_unc_msgs;
2899 num_of_unc_msgs = header_list_count_uncached_msgs(
2901 GTK_WINDOW (window));
2903 if (num_of_unc_msgs)
2904 continue_download = connect_to_get_msg(
2905 GTK_WINDOW (window),
2908 if (num_of_unc_msgs == 0 || continue_download) {
2909 modest_platform_information_banner (
2910 NULL, NULL, _CS("mcen_ib_getting_items"));
2911 modest_header_view_copy_selection (
2912 MODEST_HEADER_VIEW (focused_widget));
2916 g_object_unref (header_list);
2918 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2919 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2922 /* Show information banner if there was a copy to clipboard */
2924 modest_platform_information_banner (
2925 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2929 modest_ui_actions_on_undo (GtkAction *action,
2930 ModestWindow *window)
2932 ModestEmailClipboard *clipboard = NULL;
2934 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2935 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2936 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2937 /* Clear clipboard source */
2938 clipboard = modest_runtime_get_email_clipboard ();
2939 modest_email_clipboard_clear (clipboard);
2942 g_return_if_reached ();
2947 modest_ui_actions_on_redo (GtkAction *action,
2948 ModestWindow *window)
2950 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2951 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2954 g_return_if_reached ();
2960 paste_msgs_cb (const GObject *object, gpointer user_data)
2962 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2963 g_return_if_fail (GTK_IS_WIDGET (user_data));
2965 /* destroy information note */
2966 gtk_widget_destroy (GTK_WIDGET(user_data));
2970 paste_as_attachment_free (gpointer data)
2972 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
2974 gtk_widget_destroy (helper->banner);
2975 g_object_unref (helper->banner);
2980 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
2985 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
2986 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
2991 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
2996 modest_ui_actions_on_paste (GtkAction *action,
2997 ModestWindow *window)
2999 GtkWidget *focused_widget = NULL;
3000 GtkWidget *inf_note = NULL;
3001 ModestMailOperation *mail_op = NULL;
3003 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3004 if (GTK_IS_EDITABLE (focused_widget)) {
3005 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
3006 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3007 ModestEmailClipboard *e_clipboard = NULL;
3008 e_clipboard = modest_runtime_get_email_clipboard ();
3009 if (modest_email_clipboard_cleared (e_clipboard)) {
3010 GtkTextBuffer *buffer;
3011 GtkClipboard *clipboard;
3013 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3014 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3015 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
3016 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3017 ModestMailOperation *mail_op;
3018 TnyFolder *src_folder;
3021 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
3022 helper->window = MODEST_MSG_EDIT_WINDOW (window);
3023 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3024 _CS("ckct_nw_pasting"));
3025 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
3026 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3028 if (helper->banner != NULL) {
3029 g_object_ref (G_OBJECT (helper->banner));
3030 gtk_window_set_modal (GTK_WINDOW (helper->banner), FALSE);
3031 gtk_widget_show (GTK_WIDGET (helper->banner));
3035 modest_mail_operation_get_msgs_full (mail_op,
3037 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
3039 paste_as_attachment_free);
3042 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3043 ModestEmailClipboard *clipboard = NULL;
3044 TnyFolder *src_folder = NULL;
3045 TnyFolderStore *folder_store = NULL;
3046 TnyList *data = NULL;
3047 gboolean delete = FALSE;
3049 /* Check clipboard source */
3050 clipboard = modest_runtime_get_email_clipboard ();
3051 if (modest_email_clipboard_cleared (clipboard))
3054 /* Get elements to paste */
3055 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
3057 /* Create a new mail operation */
3058 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
3060 /* Get destination folder */
3061 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
3063 /* transfer messages */
3067 /* Ask for user confirmation */
3068 response = msgs_move_to_confirmation (GTK_WINDOW (window),
3069 TNY_FOLDER (folder_store),
3073 if (response == GTK_RESPONSE_OK) {
3074 /* Launch notification */
3075 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3076 _CS("ckct_nw_pasting"));
3077 if (inf_note != NULL) {
3078 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3079 gtk_widget_show (GTK_WIDGET(inf_note));
3082 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3083 modest_mail_operation_xfer_msgs (mail_op,
3085 TNY_FOLDER (folder_store),
3090 g_object_unref (mail_op);
3093 } else if (src_folder != NULL) {
3094 /* Launch notification */
3095 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3096 _CS("ckct_nw_pasting"));
3097 if (inf_note != NULL) {
3098 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3099 gtk_widget_show (GTK_WIDGET(inf_note));
3102 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3103 modest_mail_operation_xfer_folder (mail_op,
3113 g_object_unref (data);
3114 if (src_folder != NULL)
3115 g_object_unref (src_folder);
3116 if (folder_store != NULL)
3117 g_object_unref (folder_store);
3123 modest_ui_actions_on_select_all (GtkAction *action,
3124 ModestWindow *window)
3126 GtkWidget *focused_widget;
3128 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3129 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
3130 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
3131 } else if (GTK_IS_LABEL (focused_widget)) {
3132 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
3133 } else if (GTK_IS_EDITABLE (focused_widget)) {
3134 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
3135 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3136 GtkTextBuffer *buffer;
3137 GtkTextIter start, end;
3139 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3140 gtk_text_buffer_get_start_iter (buffer, &start);
3141 gtk_text_buffer_get_end_iter (buffer, &end);
3142 gtk_text_buffer_select_range (buffer, &start, &end);
3143 } else if (GTK_IS_HTML (focused_widget)) {
3144 gtk_html_select_all (GTK_HTML (focused_widget));
3145 } else if (MODEST_IS_MAIN_WINDOW (window)) {
3146 GtkWidget *header_view = focused_widget;
3147 GtkTreeSelection *selection = NULL;
3149 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
3150 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3151 MODEST_WIDGET_TYPE_HEADER_VIEW);
3154 /* Disable window dimming management */
3155 modest_window_disable_dimming (MODEST_WINDOW(window));
3157 /* Select all messages */
3158 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
3159 gtk_tree_selection_select_all (selection);
3161 /* Set focuse on header view */
3162 gtk_widget_grab_focus (header_view);
3165 /* Enable window dimming management */
3166 modest_window_enable_dimming (MODEST_WINDOW(window));
3167 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
3173 modest_ui_actions_on_mark_as_read (GtkAction *action,
3174 ModestWindow *window)
3176 g_return_if_fail (MODEST_IS_WINDOW(window));
3178 /* Mark each header as read */
3179 do_headers_action (window, headers_action_mark_as_read, NULL);
3183 modest_ui_actions_on_mark_as_unread (GtkAction *action,
3184 ModestWindow *window)
3186 g_return_if_fail (MODEST_IS_WINDOW(window));
3188 /* Mark each header as read */
3189 do_headers_action (window, headers_action_mark_as_unread, NULL);
3193 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
3194 GtkRadioAction *selected,
3195 ModestWindow *window)
3199 value = gtk_radio_action_get_current_value (selected);
3200 if (MODEST_IS_WINDOW (window)) {
3201 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
3205 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
3206 GtkRadioAction *selected,
3207 ModestWindow *window)
3209 TnyHeaderFlags flags;
3210 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3212 flags = gtk_radio_action_get_current_value (selected);
3213 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
3216 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
3217 GtkRadioAction *selected,
3218 ModestWindow *window)
3222 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3224 file_format = gtk_radio_action_get_current_value (selected);
3225 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
3230 modest_ui_actions_on_zoom_plus (GtkAction *action,
3231 ModestWindow *window)
3233 g_return_if_fail (MODEST_IS_WINDOW (window));
3235 modest_window_zoom_plus (MODEST_WINDOW (window));
3239 modest_ui_actions_on_zoom_minus (GtkAction *action,
3240 ModestWindow *window)
3242 g_return_if_fail (MODEST_IS_WINDOW (window));
3244 modest_window_zoom_minus (MODEST_WINDOW (window));
3248 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
3249 ModestWindow *window)
3251 ModestWindowMgr *mgr;
3252 gboolean fullscreen, active;
3253 g_return_if_fail (MODEST_IS_WINDOW (window));
3255 mgr = modest_runtime_get_window_mgr ();
3257 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
3258 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3260 if (active != fullscreen) {
3261 modest_window_mgr_set_fullscreen_mode (mgr, active);
3262 gtk_window_present (GTK_WINDOW (window));
3267 modest_ui_actions_on_change_fullscreen (GtkAction *action,
3268 ModestWindow *window)
3270 ModestWindowMgr *mgr;
3271 gboolean fullscreen;
3273 g_return_if_fail (MODEST_IS_WINDOW (window));
3275 mgr = modest_runtime_get_window_mgr ();
3276 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3277 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
3279 gtk_window_present (GTK_WINDOW (window));
3283 * Used by modest_ui_actions_on_details to call do_headers_action
3286 headers_action_show_details (TnyHeader *header,
3287 ModestWindow *window,
3294 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
3297 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3298 gtk_widget_show_all (dialog);
3299 gtk_dialog_run (GTK_DIALOG (dialog));
3301 gtk_widget_destroy (dialog);
3305 * Show the folder details in a ModestDetailsDialog widget
3308 show_folder_details (TnyFolder *folder,
3314 dialog = modest_details_dialog_new_with_folder (window, folder);
3317 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3318 gtk_widget_show_all (dialog);
3319 gtk_dialog_run (GTK_DIALOG (dialog));
3321 gtk_widget_destroy (dialog);
3325 * Show the header details in a ModestDetailsDialog widget
3328 modest_ui_actions_on_details (GtkAction *action,
3331 TnyList * headers_list;
3335 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3338 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3341 g_object_unref (msg);
3343 headers_list = get_selected_headers (win);
3347 iter = tny_list_create_iterator (headers_list);
3349 header = TNY_HEADER (tny_iterator_get_current (iter));
3351 headers_action_show_details (header, win, NULL);
3352 g_object_unref (header);
3355 g_object_unref (iter);
3356 g_object_unref (headers_list);
3358 } else if (MODEST_IS_MAIN_WINDOW (win)) {
3359 GtkWidget *folder_view, *header_view;
3361 /* Check which widget has the focus */
3362 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3363 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3364 if (gtk_widget_is_focus (folder_view)) {
3365 TnyFolderStore *folder_store
3366 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3367 if (!folder_store) {
3368 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3371 /* Show only when it's a folder */
3372 /* This function should not be called for account items,
3373 * because we dim the menu item for them. */
3374 if (TNY_IS_FOLDER (folder_store)) {
3375 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3378 g_object_unref (folder_store);
3381 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3382 MODEST_WIDGET_TYPE_HEADER_VIEW);
3383 /* Show details of each header */
3384 do_headers_action (win, headers_action_show_details, header_view);
3390 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3391 ModestMsgEditWindow *window)
3393 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3395 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3399 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3400 ModestMsgEditWindow *window)
3402 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3404 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3408 modest_ui_actions_toggle_folders_view (GtkAction *action,
3409 ModestMainWindow *main_window)
3411 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3413 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3414 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3416 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3420 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3421 ModestWindow *window)
3423 gboolean active, fullscreen = FALSE;
3424 ModestWindowMgr *mgr;
3426 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3428 /* Check if we want to toggle the toolbar vuew in fullscreen
3430 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3431 "ViewShowToolbarFullScreen")) {
3435 /* Toggle toolbar */
3436 mgr = modest_runtime_get_window_mgr ();
3437 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3441 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3442 ModestMsgEditWindow *window)
3444 modest_msg_edit_window_select_font (window);
3448 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3449 const gchar *display_name,
3452 /* Do not change the application name if the widget has not
3453 the focus. This callback could be called even if the folder
3454 view has not the focus, because the handled signal could be
3455 emitted when the folder view is redrawn */
3456 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3458 gtk_window_set_title (window, display_name);
3460 gtk_window_set_title (window, " ");
3465 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3467 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3468 modest_msg_edit_window_select_contacts (window);
3472 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3474 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3475 modest_msg_edit_window_check_names (window, FALSE);
3479 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3481 modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3482 GTK_WIDGET (user_data));
3486 * This function is used to track changes in the selection of the
3487 * folder view that is inside the "move to" dialog to enable/disable
3488 * the OK button because we do not want the user to select a disallowed
3489 * destination for a folder.
3490 * The user also not desired to be able to use NEW button on items where
3491 * folder creation is not possibel.
3494 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
3495 TnyFolderStore *folder_store,
3499 GtkWidget *dialog = NULL;
3500 GtkWidget *ok_button = NULL, *new_button = NULL;
3501 GList *children = NULL;
3502 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
3503 gboolean moving_folder = FALSE;
3504 gboolean is_remote_account = FALSE;
3505 GtkWidget *folder_view = NULL;
3510 /* Get the OK button */
3511 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
3515 children = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
3516 ok_button = GTK_WIDGET (children->next->next->data);
3517 new_button = GTK_WIDGET (children->next->data);
3518 g_list_free (children);
3520 /* check if folder_store is an remote account */
3521 if (TNY_IS_ACCOUNT (folder_store)) {
3522 TnyAccount *local_account = NULL;
3523 ModestTnyAccountStore *account_store = NULL;
3525 account_store = modest_runtime_get_account_store ();
3526 local_account = modest_tny_account_store_get_local_folders_account (account_store);
3528 if ((gpointer) local_account != (gpointer) folder_store)
3529 is_remote_account = TRUE;
3530 g_object_unref (local_account);
3533 /* New button should be dimmed on remote account root folder
3534 * and on inbox folder. */
3535 if (is_remote_account)
3536 new_sensitive = FALSE;
3538 /* check if folder_store is an rmeote inbox folder */
3539 if (TNY_IS_FOLDER (folder_store))
3540 if (tny_folder_get_folder_type(TNY_FOLDER(folder_store))
3541 == TNY_FOLDER_TYPE_INBOX)
3542 new_sensitive = FALSE;
3545 if (MODEST_IS_MAIN_WINDOW (user_data)) {
3546 /* Get the widgets */
3547 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
3548 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3549 if (gtk_widget_is_focus (folder_view))
3550 moving_folder = TRUE;
3553 if (moving_folder) {
3554 TnyFolderStore *moved_folder = NULL, *parent = NULL;
3556 /* Get the folder to move */
3557 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3559 /* Check that we're not moving to the same folder */
3560 if (TNY_IS_FOLDER (moved_folder)) {
3561 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
3562 if (parent == folder_store)
3563 ok_sensitive = FALSE;
3564 g_object_unref (parent);
3567 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
3568 /* Do not allow to move to an account unless it's the
3569 local folders account */
3570 if (is_remote_account)
3571 ok_sensitive = FALSE;
3574 if (ok_sensitive && (moved_folder == folder_store)) {
3575 /* Do not allow to move to itself */
3576 ok_sensitive = FALSE;
3578 g_object_unref (moved_folder);
3580 TnyHeader *header = NULL;
3581 TnyFolder *src_folder = NULL;
3583 /* Moving a message */
3584 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
3585 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (user_data));
3586 src_folder = tny_header_get_folder (header);
3587 g_object_unref (header);
3590 TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
3593 /* Do not allow to move the msg to the same folder */
3594 /* Do not allow to move the msg to an account */
3595 if ((gpointer) src_folder == (gpointer) folder_store ||
3596 TNY_IS_ACCOUNT (folder_store))
3597 ok_sensitive = FALSE;
3598 g_object_unref (src_folder);
3601 /* Set sensitivity of the OK button */
3602 gtk_widget_set_sensitive (ok_button, ok_sensitive);
3603 /* Set sensitivity of the NEW button */
3604 gtk_widget_set_sensitive (new_button, new_sensitive);
3608 create_move_to_dialog (GtkWindow *win,
3609 GtkWidget *folder_view,
3610 GtkWidget **tree_view)
3612 GtkWidget *dialog, *scroll;
3613 GtkWidget *new_button;
3615 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3617 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3620 gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
3621 /* We do this manually so GTK+ does not associate a response ID for
3623 new_button = gtk_button_new_from_stock (_("mcen_bd_new"));
3624 gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3625 gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_cancel"), GTK_RESPONSE_REJECT);
3627 /* Create scrolled window */
3628 scroll = gtk_scrolled_window_new (NULL, NULL);
3629 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3630 GTK_POLICY_AUTOMATIC,
3631 GTK_POLICY_AUTOMATIC);
3633 /* Create folder view */
3634 *tree_view = modest_platform_create_folder_view (NULL);
3636 /* Track changes in the selection to
3637 * disable the OK button whenever "Move to" is not possible
3638 * disbale NEW button whenever New is not possible */
3639 g_signal_connect (*tree_view,
3640 "folder_selection_changed",
3641 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
3644 /* Listen to clicks on New button */
3645 g_signal_connect (G_OBJECT (new_button),
3647 G_CALLBACK(create_move_to_dialog_on_new_folder),
3650 /* It could happen that we're trying to move a message from a
3651 window (msg window for example) after the main window was
3652 closed, so we can not just get the model of the folder
3654 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
3655 const gchar *visible_id = NULL;
3657 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
3658 MODEST_FOLDER_VIEW(*tree_view));
3661 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
3663 /* Show the same account than the one that is shown in the main window */
3664 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(*tree_view),
3667 const gchar *active_account_name = NULL;
3668 ModestAccountMgr *mgr = NULL;
3669 ModestAccountData *acc_data = NULL;
3671 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3672 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3674 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
3675 mgr = modest_runtime_get_account_mgr ();
3676 acc_data = modest_account_mgr_get_account_data (mgr, active_account_name);
3678 /* Set the new visible & active account */
3679 if (acc_data && acc_data->store_account) {
3680 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (*tree_view),
3681 acc_data->store_account->account_name);
3682 modest_account_mgr_free_account_data (mgr, acc_data);
3686 /* Hide special folders */
3687 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3689 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3691 /* Add scroll to dialog */
3692 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3693 scroll, TRUE, TRUE, 0);
3695 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3696 gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3702 * Returns TRUE if at least one of the headers of the list belongs to
3703 * a message that has been fully retrieved.
3705 #if 0 /* no longer in use. delete in 2007.10 */
3707 has_retrieved_msgs (TnyList *list)
3710 gboolean found = FALSE;
3712 iter = tny_list_create_iterator (list);
3713 while (!tny_iterator_is_done (iter) && !found) {
3715 TnyHeaderFlags flags = 0;
3717 header = TNY_HEADER (tny_iterator_get_current (iter));
3719 flags = tny_header_get_flags (header);
3720 if (flags & TNY_HEADER_FLAG_CACHED)
3721 /* if (!(flags & TNY_HEADER_FLAG_PARTIAL)) */
3724 g_object_unref (header);
3728 tny_iterator_next (iter);
3730 g_object_unref (iter);
3738 * Shows a confirmation dialog to the user when we're moving messages
3739 * from a remote server to the local storage. Returns the dialog
3740 * response. If it's other kind of movement then it always returns
3743 * This one is used by the next functions:
3744 * modest_ui_actions_xfer_messages_from_move_to
3745 * modest_ui_actions_on_paste - commented out
3746 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
3749 msgs_move_to_confirmation (GtkWindow *win,
3750 TnyFolder *dest_folder,
3754 gint response = GTK_RESPONSE_OK;
3756 /* return with OK if the destination is a remote folder */
3757 if (modest_tny_folder_is_remote_folder (dest_folder))
3758 return GTK_RESPONSE_OK;
3760 TnyFolder *src_folder = NULL;
3761 TnyIterator *iter = NULL;
3762 TnyHeader *header = NULL;
3764 /* Get source folder */
3765 iter = tny_list_create_iterator (headers);
3766 header = TNY_HEADER (tny_iterator_get_current (iter));
3768 src_folder = tny_header_get_folder (header);
3769 g_object_unref (header);
3771 g_object_unref (iter);
3773 /* if no src_folder, message may be an attahcment */
3774 if (src_folder == NULL)
3775 return GTK_RESPONSE_CANCEL;
3777 /* If the source is a local or MMC folder */
3778 if (!modest_tny_folder_is_remote_folder (src_folder)) {
3779 g_object_unref (src_folder);
3780 return GTK_RESPONSE_OK;
3782 g_object_unref (src_folder);
3784 /* now if offline we ask the user */
3785 if(connect_to_get_msg( GTK_WINDOW (win),
3786 tny_list_get_length (headers)))
3787 response = GTK_RESPONSE_OK;
3789 response = GTK_RESPONSE_CANCEL;
3797 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3799 ModestMsgViewWindow *self = NULL;
3801 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3802 self = MODEST_MSG_VIEW_WINDOW (object);
3804 if (!modest_msg_view_window_select_next_message (self))
3805 if (!modest_msg_view_window_select_previous_message (self))
3806 /* No more messages to view, so close this window */
3807 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3811 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3814 GObject *win = modest_mail_operation_get_source (mail_op);
3815 const GError *error = NULL;
3816 const gchar *message = NULL;
3818 /* Get error message */
3819 error = modest_mail_operation_get_error (mail_op);
3820 if (error != NULL && error->message != NULL) {
3821 message = error->message;
3823 message = _("mail_in_ui_folder_move_target_error");
3826 /* Show notification dialog */
3827 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3828 g_object_unref (win);
3832 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3835 GObject *win = modest_mail_operation_get_source (mail_op);
3836 const GError *error = modest_mail_operation_get_error (mail_op);
3838 g_return_if_fail (error != NULL);
3839 if (error->message != NULL)
3840 g_printerr ("modest: %s\n", error->message);
3842 g_printerr ("modest: unkonw error on send&receive operation");
3844 /* Show error message */
3845 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3846 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3847 /* _CS("sfil_ib_unable_to_receive")); */
3849 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3850 /* _CS("sfil_ib_unable_to_send")); */
3851 g_object_unref (win);
3855 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3862 gint pending_purges = 0;
3863 gboolean some_purged = FALSE;
3864 ModestWindow *win = MODEST_WINDOW (user_data);
3865 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
3867 /* If there was any error */
3868 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
3869 modest_window_mgr_unregister_header (mgr, header);
3873 /* Once the message has been retrieved for purging, we check if
3874 * it's all ok for purging */
3876 parts = tny_simple_list_new ();
3877 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3878 iter = tny_list_create_iterator (parts);
3880 while (!tny_iterator_is_done (iter)) {
3882 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3883 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
3884 if (tny_mime_part_is_purged (part))
3891 g_object_unref (part);
3893 tny_iterator_next (iter);
3896 if (pending_purges>0) {
3898 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3900 if (response == GTK_RESPONSE_OK) {
3901 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3902 tny_iterator_first (iter);
3903 while (!tny_iterator_is_done (iter)) {
3906 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3907 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
3908 tny_mime_part_set_purged (part);
3911 g_object_unref (part);
3913 tny_iterator_next (iter);
3916 tny_msg_rewrite_cache (msg);
3919 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3922 /* remove attachments */
3923 tny_iterator_first (iter);
3924 while (!tny_iterator_is_done (iter)) {
3927 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3929 /* One for the reference given by tny_iterator_get_current(): */
3930 g_object_unref (part);
3932 /* TODO: Is this meant to remove the attachment by doing another unref()?
3933 * Otherwise, this seems useless. */
3936 tny_iterator_next (iter);
3938 modest_window_mgr_unregister_header (mgr, header);
3940 g_object_unref (iter);
3941 g_object_unref (parts);
3945 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3946 ModestMainWindow *win)
3948 GtkWidget *header_view;
3949 TnyList *header_list;
3952 TnyHeaderFlags flags;
3953 ModestWindow *msg_view_window = NULL;
3956 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3958 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3959 MODEST_WIDGET_TYPE_HEADER_VIEW);
3961 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3963 if (tny_list_get_length (header_list) == 1) {
3964 iter = tny_list_create_iterator (header_list);
3965 header = TNY_HEADER (tny_iterator_get_current (iter));
3966 g_object_unref (iter);
3971 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3972 header, &msg_view_window);
3973 flags = tny_header_get_flags (header);
3974 if (!(flags & TNY_HEADER_FLAG_CACHED))
3977 if (msg_view_window != NULL)
3978 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3980 /* do nothing; uid was registered before, so window is probably on it's way */
3981 g_warning ("debug: header %p has already been registered", header);
3984 ModestMailOperation *mail_op = NULL;
3985 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3986 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3988 modest_ui_actions_get_msgs_full_error_handler,
3990 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3991 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3993 g_object_unref (mail_op);
3996 g_object_unref (header);
3998 g_object_unref (header_list);
4002 * Utility function that transfer messages from both the main window
4003 * and the msg view window when using the "Move to" dialog
4006 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
4009 TnyList *headers = NULL;
4011 TnyAccount *dst_account = NULL;
4012 const gchar *proto_str = NULL;
4013 gboolean dst_is_pop = FALSE;
4015 if (!TNY_IS_FOLDER (dst_folder)) {
4016 modest_platform_information_banner (GTK_WIDGET (win),
4018 _CS("ckdg_ib_unable_to_move_to_current_location"));
4022 dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
4023 proto_str = tny_account_get_proto (dst_account);
4025 /* tinymail will return NULL for local folders it seems */
4026 dst_is_pop = proto_str &&
4027 (modest_protocol_info_get_transport_store_protocol (proto_str) ==
4028 MODEST_PROTOCOL_STORE_POP);
4030 g_object_unref (dst_account);
4032 /* Get selected headers */
4033 headers = get_selected_headers (MODEST_WINDOW (win));
4036 modest_platform_information_banner (GTK_WIDGET (win),
4038 ngettext("mail_in_ui_folder_move_target_error",
4039 "mail_in_ui_folder_move_targets_error",
4040 tny_list_get_length (headers)));
4041 g_object_unref (headers);
4045 /* Ask for user confirmation */
4046 response = msgs_move_to_confirmation (GTK_WINDOW (win),
4047 TNY_FOLDER (dst_folder),
4051 /* Transfer messages */
4052 if (response == GTK_RESPONSE_OK) {
4053 ModestMailOperation *mail_op =
4054 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4056 modest_ui_actions_move_folder_error_handler,
4058 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4061 modest_mail_operation_xfer_msgs (mail_op,
4063 TNY_FOLDER (dst_folder),
4065 (MODEST_IS_MSG_VIEW_WINDOW (win)) ? transfer_msgs_from_viewer_cb : NULL,
4068 g_object_unref (G_OBJECT (mail_op));
4070 g_object_unref (headers);
4074 * UI handler for the "Move to" action when invoked from the
4078 modest_ui_actions_on_main_window_move_to (GtkAction *action,
4079 GtkWidget *folder_view,
4080 TnyFolderStore *dst_folder,
4081 ModestMainWindow *win)
4083 ModestHeaderView *header_view = NULL;
4084 ModestMailOperation *mail_op = NULL;
4085 TnyFolderStore *src_folder;
4086 gboolean online = (tny_device_is_online (modest_runtime_get_device()));
4088 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
4090 /* Get the source folder */
4091 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4093 /* Get header view */
4094 header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW));
4096 /* Get folder or messages to transfer */
4097 if (gtk_widget_is_focus (folder_view)) {
4098 GtkTreeSelection *sel;
4099 gboolean do_xfer = TRUE;
4101 /* Allow only to transfer folders to the local root folder */
4102 if (TNY_IS_ACCOUNT (dst_folder) &&
4103 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder)) {
4105 } else if (!TNY_IS_FOLDER (src_folder)) {
4106 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
4108 } else if (!online && modest_platform_is_network_folderstore(src_folder)) {
4109 guint num_headers = tny_folder_get_all_count(TNY_FOLDER(src_folder));
4110 if (!connect_to_get_msg(GTK_WINDOW(win), num_headers)) {
4116 /* Clean folder on header view before moving it */
4117 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
4118 gtk_tree_selection_unselect_all (sel);
4121 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4123 modest_ui_actions_move_folder_error_handler,
4125 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4128 modest_mail_operation_xfer_folder (mail_op,
4129 TNY_FOLDER (src_folder),
4132 /* Unref mail operation */
4133 g_object_unref (G_OBJECT (mail_op));
4135 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
4136 gboolean do_xfer = TRUE;
4137 /* Ask for confirmation if the source folder is remote and we're not connected */
4138 if (!online && modest_platform_is_network_folderstore(src_folder)) {
4139 guint num_headers = modest_header_view_count_selected_headers(header_view);
4140 if (!connect_to_get_msg(GTK_WINDOW(win), num_headers)) {
4144 if (do_xfer) /* Transfer messages */
4145 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
4149 g_object_unref (src_folder);
4154 * UI handler for the "Move to" action when invoked from the
4155 * ModestMsgViewWindow
4158 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
4159 TnyFolderStore *dst_folder,
4160 ModestMsgViewWindow *win)
4162 TnyHeader *header = NULL;
4163 TnyFolderStore *src_folder;
4165 /* Create header list */
4166 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
4167 src_folder = TNY_FOLDER_STORE(tny_header_get_folder(header));
4168 g_object_unref (header);
4170 /* Transfer the message if online or confirmed by the user */
4171 if (tny_device_is_online (modest_runtime_get_device()) ||
4172 (modest_platform_is_network_folderstore(src_folder) && connect_to_get_msg(GTK_WINDOW(win), 1))) {
4173 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
4176 g_object_unref (src_folder);
4180 modest_ui_actions_on_move_to (GtkAction *action,
4183 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
4185 TnyFolderStore *dst_folder = NULL;
4186 ModestMainWindow *main_window;
4188 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
4189 MODEST_IS_MSG_VIEW_WINDOW (win));
4191 /* Get the main window if exists */
4192 if (MODEST_IS_MAIN_WINDOW (win))
4193 main_window = MODEST_MAIN_WINDOW (win);
4196 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
4198 /* Get the folder view widget if exists */
4200 folder_view = modest_main_window_get_child_widget (main_window,
4201 MODEST_WIDGET_TYPE_FOLDER_VIEW);
4205 /* Create and run the dialog */
4206 dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
4207 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
4208 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
4209 result = gtk_dialog_run (GTK_DIALOG(dialog));
4210 g_object_ref (tree_view);
4211 gtk_widget_destroy (dialog);
4213 if (result != GTK_RESPONSE_ACCEPT)
4216 dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
4217 /* Do window specific stuff */
4218 if (MODEST_IS_MAIN_WINDOW (win)) {
4219 modest_ui_actions_on_main_window_move_to (action,
4222 MODEST_MAIN_WINDOW (win));
4224 modest_ui_actions_on_msg_view_window_move_to (action,
4226 MODEST_MSG_VIEW_WINDOW (win));
4230 g_object_unref (dst_folder);
4234 * Calls #HeadersFunc for each header already selected in the main
4235 * window or the message currently being shown in the msg view window
4238 do_headers_action (ModestWindow *win,
4242 TnyList *headers_list = NULL;
4243 TnyIterator *iter = NULL;
4244 TnyHeader *header = NULL;
4245 TnyFolder *folder = NULL;
4248 headers_list = get_selected_headers (win);
4252 /* Get the folder */
4253 iter = tny_list_create_iterator (headers_list);
4254 header = TNY_HEADER (tny_iterator_get_current (iter));
4256 folder = tny_header_get_folder (header);
4257 g_object_unref (header);
4260 /* Call the function for each header */
4261 while (!tny_iterator_is_done (iter)) {
4262 header = TNY_HEADER (tny_iterator_get_current (iter));
4263 func (header, win, user_data);
4264 g_object_unref (header);
4265 tny_iterator_next (iter);
4268 /* Trick: do a poke status in order to speed up the signaling
4270 tny_folder_poke_status (folder);
4273 g_object_unref (folder);
4274 g_object_unref (iter);
4275 g_object_unref (headers_list);
4279 modest_ui_actions_view_attachment (GtkAction *action,
4280 ModestWindow *window)
4282 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4283 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
4285 /* not supported window for this action */
4286 g_return_if_reached ();
4291 modest_ui_actions_save_attachments (GtkAction *action,
4292 ModestWindow *window)
4294 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4295 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
4297 /* not supported window for this action */
4298 g_return_if_reached ();
4303 modest_ui_actions_remove_attachments (GtkAction *action,
4304 ModestWindow *window)
4306 if (MODEST_IS_MAIN_WINDOW (window)) {
4307 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
4308 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4309 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
4311 /* not supported window for this action */
4312 g_return_if_reached ();
4317 modest_ui_actions_on_settings (GtkAction *action,
4322 dialog = modest_platform_get_global_settings_dialog ();
4323 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
4324 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
4325 gtk_widget_show_all (dialog);
4327 gtk_dialog_run (GTK_DIALOG (dialog));
4329 gtk_widget_destroy (dialog);
4333 modest_ui_actions_on_help (GtkAction *action,
4336 const gchar *help_id = NULL;
4338 if (MODEST_IS_MAIN_WINDOW (win)) {
4339 const gchar *action_name;
4340 action_name = gtk_action_get_name (action);
4342 if (!strcmp (action_name, "FolderViewCSMHelp") ||
4343 !strcmp (action_name, "HeaderViewCSMHelp")) {
4344 GtkWidget *folder_view;
4345 TnyFolderStore *folder_store;
4346 /* Get selected folder */
4347 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4348 MODEST_WIDGET_TYPE_FOLDER_VIEW);
4349 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4351 /* Switch help_id */
4352 if (TNY_IS_FOLDER (folder_store)) {
4353 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
4354 case TNY_FOLDER_TYPE_NORMAL:
4355 help_id = "applications_email_managefolders";
4357 case TNY_FOLDER_TYPE_INBOX:
4358 help_id = "applications_email_inbox";
4360 case TNY_FOLDER_TYPE_OUTBOX:
4361 help_id = "applications_email_outbox";
4363 case TNY_FOLDER_TYPE_SENT:
4364 help_id = "applications_email_sent";
4366 case TNY_FOLDER_TYPE_DRAFTS:
4367 help_id = "applications_email_drafts";
4369 case TNY_FOLDER_TYPE_ARCHIVE:
4370 help_id = "applications_email_managefolders";
4373 help_id = "applications_email_managefolders";
4376 help_id = "applications_email_mainview";
4378 g_object_unref (folder_store);
4380 help_id = "applications_email_mainview";
4382 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4383 help_id = "applications_email_viewer";
4384 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
4385 help_id = "applications_email_editor";
4387 modest_platform_show_help (GTK_WINDOW (win), help_id);
4391 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
4392 ModestWindow *window)
4394 ModestMailOperation *mail_op;
4398 headers = get_selected_headers (window);
4402 /* Create mail operation */
4403 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4405 modest_ui_actions_get_msgs_full_error_handler,
4407 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4408 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
4411 g_object_unref (headers);
4412 g_object_unref (mail_op);
4416 modest_ui_actions_on_email_menu_activated (GtkAction *action,
4417 ModestWindow *window)
4419 g_return_if_fail (MODEST_IS_WINDOW (window));
4422 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4426 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
4427 ModestWindow *window)
4429 g_return_if_fail (MODEST_IS_WINDOW (window));
4432 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4436 modest_ui_actions_on_view_menu_activated (GtkAction *action,
4437 ModestWindow *window)
4439 g_return_if_fail (MODEST_IS_WINDOW (window));
4442 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4446 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
4447 ModestWindow *window)
4449 g_return_if_fail (MODEST_IS_WINDOW (window));
4452 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4456 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
4457 ModestWindow *window)
4459 g_return_if_fail (MODEST_IS_WINDOW (window));
4462 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4466 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
4467 ModestWindow *window)
4469 g_return_if_fail (MODEST_IS_WINDOW (window));
4472 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4476 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
4477 ModestWindow *window)
4479 g_return_if_fail (MODEST_IS_WINDOW (window));
4482 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4486 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
4487 ModestWindow *window)
4489 g_return_if_fail (MODEST_IS_WINDOW (window));
4492 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4496 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
4498 g_return_if_fail (MODEST_IS_WINDOW (window));
4501 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
4505 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
4507 g_return_if_fail (MODEST_IS_WINDOW (window));
4509 modest_platform_show_search_messages (GTK_WINDOW (window));
4513 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
4515 g_return_if_fail (MODEST_IS_WINDOW (win));
4516 modest_platform_show_addressbook (GTK_WINDOW (win));
4521 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
4522 ModestWindow *window)
4524 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4526 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
4530 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
4531 ModestMailOperationState *state,
4534 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
4536 /* Set send/receive operation finished */
4537 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
4538 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));