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-defs.h>
39 #include <modest-tny-folder.h>
40 #include <modest-tny-msg.h>
41 #include <modest-tny-account.h>
42 #include <modest-address-book.h>
43 #include "modest-error.h"
44 #include "modest-ui-actions.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
47 #include "modest-debug.h"
48 #include <tny-mime-part.h>
49 #include <tny-error.h>
50 #include <tny-camel-folder.h>
51 #include <tny-camel-imap-folder.h>
52 #include <tny-camel-pop-folder.h>
53 #ifdef MODEST_TOOLKIT_HILDON2
54 #include <modest-accounts-window.h>
55 #include <hildon/hildon-pannable-area.h>
56 #include <hildon/hildon-gtk.h>
57 #include <modest-header-window.h>
58 #include <modest-folder-window.h>
59 #include <modest-maemo-utils.h>
62 #ifdef MODEST_PLATFORM_MAEMO
63 #include "maemo/modest-osso-state-saving.h"
64 #endif /* MODEST_PLATFORM_MAEMO */
65 #ifndef MODEST_TOOLKIT_GTK
66 #include "maemo/modest-hildon-includes.h"
67 #include "maemo/modest-connection-specific-smtp-window.h"
68 #endif /* !MODEST_TOOLKIT_GTK */
69 #include <modest-utils.h>
71 #include "widgets/modest-ui-constants.h"
72 #include <widgets/modest-main-window.h>
73 #include <widgets/modest-msg-view-window.h>
74 #include <widgets/modest-account-view-window.h>
75 #include <widgets/modest-details-dialog.h>
76 #include <widgets/modest-attachments-view.h>
77 #include "widgets/modest-folder-view.h"
78 #include "widgets/modest-global-settings-dialog.h"
79 #include "modest-account-mgr-helpers.h"
80 #include "modest-mail-operation.h"
81 #include "modest-text-utils.h"
82 #include <modest-widget-memory.h>
83 #include <tny-error.h>
84 #include <tny-simple-list.h>
85 #include <tny-msg-view.h>
86 #include <tny-device.h>
87 #include <tny-merge-folder.h>
89 #include <gtkhtml/gtkhtml.h>
91 #define MIN_FREE_SPACE 5 * 1024 * 1024
92 #define MODEST_MOVE_TO_DIALOG_FOLDER_VIEW "move-to-dialog-folder-view"
94 typedef struct _GetMsgAsyncHelper {
96 ModestMailOperation *mail_op;
103 typedef enum _ReplyForwardAction {
107 } ReplyForwardAction;
109 typedef struct _ReplyForwardHelper {
110 guint reply_forward_type;
111 ReplyForwardAction action;
114 GtkWidget *parent_window;
116 } ReplyForwardHelper;
118 typedef struct _MoveToHelper {
119 GtkTreeRowReference *reference;
123 typedef struct _PasteAsAttachmentHelper {
124 ModestMsgEditWindow *window;
126 } PasteAsAttachmentHelper;
134 * The do_headers_action uses this kind of functions to perform some
135 * action to each member of a list of headers
137 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
139 static void do_headers_action (ModestWindow *win,
143 static void open_msg_cb (ModestMailOperation *mail_op,
150 static void reply_forward_cb (ModestMailOperation *mail_op,
157 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
159 static void folder_refreshed_cb (ModestMailOperation *mail_op,
163 static void on_send_receive_finished (ModestMailOperation *mail_op,
166 static gint header_list_count_uncached_msgs (TnyList *header_list);
168 static gboolean connect_to_get_msg (ModestWindow *win,
169 gint num_of_uncached_msgs,
170 TnyAccount *account);
172 static gboolean remote_folder_has_leave_on_server (TnyFolderStore *folder);
174 static void do_create_folder (GtkWindow *window,
175 TnyFolderStore *parent_folder,
176 const gchar *suggested_name);
178 static TnyAccount *get_account_from_folder_store (TnyFolderStore *folder_store);
180 static void modest_ui_actions_on_main_window_move_to (GtkAction *action,
181 GtkWidget *folder_view,
182 TnyFolderStore *dst_folder,
183 ModestMainWindow *win);
184 #ifdef MODEST_TOOLKIT_HILDON2
185 static void modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
186 TnyFolderStore *dst_folder,
191 static void modest_ui_actions_on_window_move_to (GtkAction *action,
192 TnyList *list_to_move,
193 TnyFolderStore *dst_folder,
197 * This function checks whether a TnyFolderStore is a pop account
200 remote_folder_has_leave_on_server (TnyFolderStore *folder)
205 g_return_val_if_fail (TNY_IS_FOLDER_STORE (folder), FALSE);
207 account = get_account_from_folder_store (folder);
208 result = (modest_protocol_registry_protocol_type_has_leave_on_server (modest_runtime_get_protocol_registry (),
209 modest_tny_account_get_protocol_type (account)));
210 g_object_unref (account);
215 /* FIXME: this should be merged with the similar code in modest-account-view-window */
216 /* Show the account creation wizard dialog.
217 * returns: TRUE if an account was created. FALSE if the user cancelled.
220 modest_ui_actions_run_account_setup_wizard (ModestWindow *win)
222 gboolean result = FALSE;
224 gint dialog_response;
226 /* there is no such wizard yet */
227 wizard = GTK_WINDOW (modest_platform_get_account_settings_wizard ());
228 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (wizard), (GtkWindow *) win);
230 #ifndef MODEST_TOOLKIT_HILDON2
231 /* always present a main window in the background
232 * we do it here, so we cannot end up with two wizards (as this
233 * function might be called in modest_window_mgr_get_main_window as well */
235 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
236 TRUE); /* create if not existent */
240 ModestWindowMgr *mgr;
242 mgr = modest_runtime_get_window_mgr ();
244 window_list = modest_window_mgr_get_window_list (mgr);
245 if (window_list == NULL) {
246 win = MODEST_WINDOW (modest_accounts_window_new ());
247 if (modest_window_mgr_register_window (mgr, win, NULL)) {
248 gtk_widget_show_all (GTK_WIDGET (win));
250 gtk_widget_destroy (GTK_WIDGET (win));
255 g_list_free (window_list);
261 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
263 /* make sure the mainwindow is visible. We need to present the
264 wizard again to give it the focus back. show_all are needed
265 in order to get the widgets properly drawn (MainWindow main
266 paned won't be in its right position and the dialog will be
268 #ifndef MODEST_TOOLKIT_HILDON2
269 gtk_widget_show_all (GTK_WIDGET (win));
270 gtk_widget_show_all (GTK_WIDGET (wizard));
271 gtk_window_present (GTK_WINDOW (win));
272 gtk_window_present (GTK_WINDOW (wizard));
275 dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
276 gtk_widget_destroy (GTK_WIDGET (wizard));
277 if (gtk_events_pending ())
278 gtk_main_iteration ();
280 if (dialog_response == GTK_RESPONSE_CANCEL) {
283 /* Check whether an account was created: */
284 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
291 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
294 const gchar *authors[] = {
295 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
298 about = gtk_about_dialog_new ();
299 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
300 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
301 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
302 _("Copyright (c) 2006, Nokia Corporation\n"
303 "All rights reserved."));
304 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
305 _("a modest e-mail client\n\n"
306 "design and implementation: Dirk-Jan C. Binnema\n"
307 "contributions from the fine people at KC and Ig\n"
308 "uses the tinymail email framework written by Philip van Hoof"));
309 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
310 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
311 gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
312 gtk_window_set_modal (GTK_WINDOW (about), TRUE);
314 gtk_dialog_run (GTK_DIALOG (about));
315 gtk_widget_destroy(about);
319 * Gets the list of currently selected messages. If the win is the
320 * main window, then it returns a newly allocated list of the headers
321 * selected in the header view. If win is the msg view window, then
322 * the value returned is a list with just a single header.
324 * The caller of this funcion must free the list.
327 get_selected_headers (ModestWindow *win)
329 if (MODEST_IS_MAIN_WINDOW(win)) {
330 GtkWidget *header_view;
332 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
333 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
334 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
336 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
337 /* for MsgViewWindows, we simply return a list with one element */
339 TnyList *list = NULL;
341 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
342 if (header != NULL) {
343 list = tny_simple_list_new ();
344 tny_list_prepend (list, G_OBJECT(header));
345 g_object_unref (G_OBJECT(header));
350 #ifdef MODEST_TOOLKIT_HILDON2
351 } else if (MODEST_IS_HEADER_WINDOW (win)) {
352 GtkWidget *header_view;
354 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
355 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
361 static GtkTreeRowReference *
362 get_next_after_selected_headers (ModestHeaderView *header_view)
364 GtkTreeSelection *sel;
365 GList *selected_rows, *node;
367 GtkTreeRowReference *result;
370 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
371 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
372 selected_rows = gtk_tree_selection_get_selected_rows (sel, NULL);
374 if (selected_rows == NULL)
377 node = g_list_last (selected_rows);
378 path = gtk_tree_path_copy ((GtkTreePath *) node->data);
379 gtk_tree_path_next (path);
381 result = gtk_tree_row_reference_new (model, path);
383 gtk_tree_path_free (path);
384 g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
385 g_list_free (selected_rows);
391 headers_action_mark_as_read (TnyHeader *header,
395 TnyHeaderFlags flags;
397 g_return_if_fail (TNY_IS_HEADER(header));
399 flags = tny_header_get_flags (header);
400 if (flags & TNY_HEADER_FLAG_SEEN) return;
401 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
405 headers_action_mark_as_unread (TnyHeader *header,
409 TnyHeaderFlags flags;
411 g_return_if_fail (TNY_IS_HEADER(header));
413 flags = tny_header_get_flags (header);
414 if (flags & TNY_HEADER_FLAG_SEEN) {
415 tny_header_unset_flag (header, TNY_HEADER_FLAG_SEEN);
419 /** After deleing a message that is currently visible in a window,
420 * show the next message from the list, or close the window if there are no more messages.
423 modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
425 /* Close msg view window or select next */
426 if (!modest_msg_view_window_select_next_message (win) &&
427 !modest_msg_view_window_select_previous_message (win)) {
429 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
435 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
437 modest_ui_actions_on_edit_mode_delete_message (win);
441 modest_ui_actions_on_edit_mode_delete_message (ModestWindow *win)
443 TnyList *header_list = NULL;
444 TnyIterator *iter = NULL;
445 TnyHeader *header = NULL;
446 gchar *message = NULL;
449 ModestWindowMgr *mgr;
450 GtkWidget *header_view = NULL;
451 gboolean retval = TRUE;
453 g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
455 /* Check first if the header view has the focus */
456 if (MODEST_IS_MAIN_WINDOW (win)) {
458 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
459 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
460 if (!gtk_widget_is_focus (header_view))
464 /* Get the headers, either from the header view (if win is the main window),
465 * or from the message view window: */
466 header_list = get_selected_headers (win);
467 if (!header_list) return FALSE;
469 /* Check if any of the headers are already opened, or in the process of being opened */
470 if (MODEST_IS_MAIN_WINDOW (win)) {
471 gint opened_headers = 0;
473 iter = tny_list_create_iterator (header_list);
474 mgr = modest_runtime_get_window_mgr ();
475 while (!tny_iterator_is_done (iter)) {
476 header = TNY_HEADER (tny_iterator_get_current (iter));
478 if (modest_window_mgr_find_registered_header (mgr, header, NULL))
480 g_object_unref (header);
482 tny_iterator_next (iter);
484 g_object_unref (iter);
486 if (opened_headers > 0) {
489 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"),
492 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg, FALSE);
495 g_object_unref (header_list);
501 if (tny_list_get_length(header_list) == 1) {
502 iter = tny_list_create_iterator (header_list);
503 header = TNY_HEADER (tny_iterator_get_current (iter));
506 subject = tny_header_dup_subject (header);
508 subject = g_strdup (_("mail_va_no_subject"));
509 desc = g_strdup_printf ("%s", subject);
511 g_object_unref (header);
514 g_object_unref (iter);
516 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
517 tny_list_get_length(header_list)), desc);
519 /* Confirmation dialog */
520 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
524 if (response == GTK_RESPONSE_OK) {
525 ModestWindow *main_window = NULL;
526 ModestWindowMgr *mgr = NULL;
527 GtkTreeModel *model = NULL;
528 GtkTreeSelection *sel = NULL;
529 GList *sel_list = NULL, *tmp = NULL;
530 GtkTreeRowReference *next_row_reference = NULL;
531 GtkTreeRowReference *prev_row_reference = NULL;
532 GtkTreePath *next_path = NULL;
533 GtkTreePath *prev_path = NULL;
534 ModestMailOperation *mail_op = NULL;
536 /* Find last selected row */
537 if (MODEST_IS_MAIN_WINDOW (win)) {
538 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
539 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
540 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
541 for (tmp=sel_list; tmp; tmp=tmp->next) {
542 if (tmp->next == NULL) {
543 prev_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
544 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
546 gtk_tree_path_prev (prev_path);
547 gtk_tree_path_next (next_path);
549 prev_row_reference = gtk_tree_row_reference_new (model, prev_path);
550 next_row_reference = gtk_tree_row_reference_new (model, next_path);
555 /* Disable window dimming management */
556 modest_window_disable_dimming (MODEST_WINDOW(win));
558 /* Remove each header. If it's a view window header_view == NULL */
559 mail_op = modest_mail_operation_new ((GObject *) win);
560 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
562 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
563 g_object_unref (mail_op);
565 /* Enable window dimming management */
567 gtk_tree_selection_unselect_all (sel);
569 modest_window_enable_dimming (MODEST_WINDOW(win));
571 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
572 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
574 /* Get main window */
575 mgr = modest_runtime_get_window_mgr ();
576 main_window = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
577 } else if (MODEST_IS_MAIN_WINDOW (win)) {
578 /* Move cursor to next row */
581 /* Select next or previous row */
582 if (gtk_tree_row_reference_valid (next_row_reference)) {
583 gtk_tree_selection_select_path (sel, next_path);
585 else if (gtk_tree_row_reference_valid (prev_row_reference)) {
586 gtk_tree_selection_select_path (sel, prev_path);
590 if (gtk_tree_row_reference_valid (next_row_reference))
591 gtk_tree_row_reference_free (next_row_reference);
592 if (next_path != NULL)
593 gtk_tree_path_free (next_path);
594 if (gtk_tree_row_reference_valid (prev_row_reference))
595 gtk_tree_row_reference_free (prev_row_reference);
596 if (prev_path != NULL)
597 gtk_tree_path_free (prev_path);
600 /* Update toolbar dimming state */
602 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
603 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
607 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
608 g_list_free (sel_list);
617 g_object_unref (header_list);
625 /* delete either message or folder, based on where we are */
627 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
629 g_return_if_fail (MODEST_IS_WINDOW(win));
631 /* Check first if the header view has the focus */
632 if (MODEST_IS_MAIN_WINDOW (win)) {
634 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
635 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
636 if (gtk_widget_is_focus (w)) {
637 modest_ui_actions_on_delete_folder (action, MODEST_WINDOW(win));
641 modest_ui_actions_on_delete_message (action, win);
645 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
647 ModestWindowMgr *mgr = NULL;
649 #ifdef MODEST_PLATFORM_MAEMO
650 modest_osso_save_state();
651 #endif /* MODEST_PLATFORM_MAEMO */
653 g_debug ("closing down, clearing %d item(s) from operation queue",
654 modest_mail_operation_queue_num_elements
655 (modest_runtime_get_mail_operation_queue()));
657 /* cancel all outstanding operations */
658 modest_mail_operation_queue_cancel_all
659 (modest_runtime_get_mail_operation_queue());
661 g_debug ("queue has been cleared");
664 /* Check if there are opened editing windows */
665 mgr = modest_runtime_get_window_mgr ();
666 modest_window_mgr_close_all_windows (mgr);
668 /* note: when modest-tny-account-store is finalized,
669 it will automatically set all network connections
672 /* gtk_main_quit (); */
676 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
680 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
682 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
683 /* gtk_widget_destroy (GTK_WIDGET (win)); */
684 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
685 /* gboolean ret_value; */
686 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
687 /* } else if (MODEST_IS_WINDOW (win)) { */
688 /* gtk_widget_destroy (GTK_WIDGET (win)); */
690 /* g_return_if_reached (); */
695 modest_ui_actions_add_to_contacts (GtkAction *action, ModestWindow *win)
697 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
699 modest_msg_view_window_add_to_contacts (MODEST_MSG_VIEW_WINDOW (win));
703 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
705 GtkClipboard *clipboard = NULL;
706 gchar *selection = NULL;
708 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
709 selection = gtk_clipboard_wait_for_text (clipboard);
711 /* Question: why is the clipboard being used here?
712 * It doesn't really make a lot of sense. */
716 modest_address_book_add_address (selection);
722 modest_ui_actions_on_new_account (GtkAction *action,
723 ModestWindow *window)
725 if (!modest_ui_actions_run_account_setup_wizard (window)) {
726 g_debug ("%s: wizard was already running", __FUNCTION__);
731 modest_ui_actions_on_accounts (GtkAction *action,
734 /* This is currently only implemented for Maemo */
735 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
736 if (!modest_ui_actions_run_account_setup_wizard (win))
737 g_debug ("%s: wizard was already running", __FUNCTION__);
741 /* Show the list of accounts */
742 GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
744 /* The accounts dialog must be modal */
745 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (account_win), (GtkWindow *) win);
746 modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
751 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
753 /* This is currently only implemented for Maemo,
754 * because it requires an API (libconic) to detect different connection
757 #ifndef MODEST_TOOLKIT_GTK /* Defined in config.h */
759 /* Create the window if necessary: */
760 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
761 modest_connection_specific_smtp_window_fill_with_connections (
762 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
763 modest_runtime_get_account_mgr());
765 /* Show the window: */
766 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
767 GTK_WINDOW (specific_window), (GtkWindow *) win);
768 gtk_widget_show (specific_window);
769 #endif /* !MODEST_TOOLKIT_GTK */
773 count_part_size (const gchar *part)
775 GnomeVFSURI *vfs_uri;
776 gchar *escaped_filename;
778 GnomeVFSFileInfo *info;
781 /* Estimation of attachment size if we cannot get it from file info */
784 vfs_uri = gnome_vfs_uri_new (part);
786 escaped_filename = g_path_get_basename (gnome_vfs_uri_get_path (vfs_uri));
787 filename = gnome_vfs_unescape_string_for_display (escaped_filename);
788 g_free (escaped_filename);
789 gnome_vfs_uri_unref (vfs_uri);
791 info = gnome_vfs_file_info_new ();
793 if (gnome_vfs_get_file_info (part,
795 GNOME_VFS_FILE_INFO_GET_MIME_TYPE)
797 if (info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) {
802 gnome_vfs_file_info_unref (info);
808 count_parts_size (GSList *parts)
813 for (node = parts; node != NULL; node = g_slist_next (node)) {
814 result += count_part_size ((const gchar *) node->data);
821 modest_ui_actions_compose_msg(ModestWindow *win,
824 const gchar *bcc_str,
825 const gchar *subject_str,
826 const gchar *body_str,
828 gboolean set_as_modified)
830 gchar *account_name = NULL;
831 const gchar *mailbox;
833 TnyAccount *account = NULL;
834 TnyFolder *folder = NULL;
835 gchar *from_str = NULL, *signature = NULL, *body = NULL;
836 gchar *recipient = NULL;
837 gboolean use_signature = FALSE;
838 ModestWindow *msg_win = NULL;
839 ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
840 ModestTnyAccountStore *store = modest_runtime_get_account_store();
841 GnomeVFSFileSize total_size, allowed_size;
842 guint64 available_disk, expected_size, parts_size;
845 /* we check for low-mem */
846 if (modest_platform_check_memory_low (win, TRUE))
849 available_disk = modest_utils_get_available_space (NULL);
850 parts_count = g_slist_length (attachments);
851 parts_size = count_parts_size (attachments);
852 expected_size = modest_tny_msg_estimate_size (body, NULL, parts_count, parts_size);
854 /* Double check: memory full condition or message too big */
855 if (available_disk < MIN_FREE_SPACE ||
856 expected_size > available_disk) {
857 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
858 modest_platform_information_banner (NULL, NULL, msg);
864 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
865 modest_platform_run_information_dialog (
867 _KR("memr_ib_operation_disabled"),
873 #ifdef MODEST_TOOLKIT_HILDON2
875 account_name = g_strdup (modest_window_get_active_account(win));
878 account_name = modest_account_mgr_get_default_account(mgr);
881 g_printerr ("modest: no account found\n");
886 mailbox = modest_window_get_active_mailbox (win);
889 account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
891 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
894 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
896 g_printerr ("modest: failed to find Drafts folder\n");
899 from_str = modest_account_mgr_get_from_string (mgr, account_name, mailbox);
901 g_printerr ("modest: failed get from string for '%s'\n", account_name);
905 recipient = modest_text_utils_get_email_address (from_str);
906 signature = modest_account_mgr_get_signature_from_recipient (mgr, recipient, &use_signature);
908 if (body_str != NULL) {
909 body = use_signature ? g_strconcat(body_str, "\n--\n", signature, NULL) : g_strdup(body_str);
911 body = use_signature ? g_strconcat("\n--\n", signature, NULL) : g_strdup("");
914 msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, NULL, NULL, body, NULL, NULL, NULL);
916 g_printerr ("modest: failed to create new msg\n");
920 /* Create and register edit window */
921 /* This is destroyed by TODO. */
923 allowed_size = MODEST_MAX_ATTACHMENT_SIZE;
924 msg_win = modest_msg_edit_window_new (msg, account_name, mailbox, FALSE);
926 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win, win)) {
927 gtk_widget_destroy (GTK_WIDGET (msg_win));
930 modest_msg_edit_window_set_modified (MODEST_MSG_EDIT_WINDOW (msg_win), set_as_modified);
931 gtk_widget_show_all (GTK_WIDGET (msg_win));
933 while (attachments) {
934 GnomeVFSFileSize att_size;
936 modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
937 attachments->data, allowed_size);
938 total_size += att_size;
940 if (att_size > allowed_size) {
941 g_warning ("%s: total size: %u",
942 __FUNCTION__, (unsigned int)total_size);
945 allowed_size -= att_size;
947 attachments = g_slist_next(attachments);
954 g_free (account_name);
956 g_object_unref (G_OBJECT(account));
958 g_object_unref (G_OBJECT(folder));
960 g_object_unref (G_OBJECT(msg));
964 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
966 /* if there are no accounts yet, just show the wizard */
967 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
968 if (!modest_ui_actions_run_account_setup_wizard (win))
971 modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL, FALSE);
976 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
980 ModestMailOperationStatus status;
982 /* If there is no message or the operation was not successful */
983 status = modest_mail_operation_get_status (mail_op);
984 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
987 /* If it's a memory low issue, then show a banner */
988 error = modest_mail_operation_get_error (mail_op);
989 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
990 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
991 GObject *source = modest_mail_operation_get_source (mail_op);
992 modest_platform_run_information_dialog (GTK_IS_WINDOW (source) ? GTK_WINDOW (source) : NULL,
993 _KR("memr_ib_operation_disabled"),
995 g_object_unref (source);
998 if (error && ((error->code == TNY_SERVICE_ERROR_NO_SUCH_MESSAGE) ||
999 error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE)) {
1000 gchar *subject, *msg, *format = NULL;
1001 TnyAccount *account;
1002 subject = tny_header_dup_subject (header);
1004 subject = g_strdup (_("mail_va_no_subject"));
1006 account = modest_mail_operation_get_account (mail_op);
1008 ModestProtocol *protocol;
1009 ModestProtocolType proto;
1010 proto = modest_tny_account_get_protocol_type (account);
1011 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (), proto);
1013 format = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
1014 g_object_unref (account);
1018 format = g_strdup (_("emev_ni_ui_imap_message_not_available_in_server"));
1020 msg = g_strdup_printf (format, subject);
1021 modest_platform_run_information_dialog (NULL, msg, FALSE);
1027 /* Remove the header from the preregistered uids */
1028 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1041 } OpenMsgBannerInfo;
1044 GtkTreeModel *model;
1046 OpenMsgBannerInfo *banner_info;
1047 GtkTreeRowReference *rowref;
1051 open_msg_banner_idle (gpointer userdata)
1053 OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) userdata;
1055 gdk_threads_enter ();
1056 banner_info->idle_handler = 0;
1057 banner_info->banner = modest_platform_animation_banner (NULL, NULL, banner_info->message);
1058 if (banner_info->banner)
1059 g_object_ref (banner_info->banner);
1061 gdk_threads_leave ();
1067 get_header_view_from_window (ModestWindow *window)
1069 GtkWidget *header_view;
1071 if (MODEST_IS_MAIN_WINDOW (window)) {
1072 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
1073 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1074 #ifdef MODEST_TOOLKIT_HILDON2
1075 } else if (MODEST_IS_HEADER_WINDOW (window)){
1076 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
1086 get_info_from_header (TnyHeader *header, gboolean *is_draft, gboolean *can_open)
1089 gchar *account = NULL;
1090 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
1095 folder = tny_header_get_folder (header);
1096 /* Gets folder type (OUTBOX headers will be opened in edit window */
1097 if (modest_tny_folder_is_local_folder (folder)) {
1098 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1099 if (folder_type == TNY_FOLDER_TYPE_INVALID)
1100 g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
1103 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
1104 TnyTransportAccount *traccount = NULL;
1105 ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
1106 traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
1108 ModestTnySendQueue *send_queue = NULL;
1109 ModestTnySendQueueStatus status;
1111 account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
1112 TNY_ACCOUNT(traccount)));
1113 send_queue = modest_runtime_get_send_queue(traccount, TRUE);
1114 if (TNY_IS_SEND_QUEUE (send_queue)) {
1115 msg_id = modest_tny_send_queue_get_msg_id (header);
1116 status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
1118 /* Only open messages in outbox with the editor if they are in Failed state */
1119 if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
1122 #ifdef MODEST_TOOLKIT_HILDON2
1124 /* In Fremantle we can not
1125 open any message from
1126 outbox which is not in
1132 g_object_unref(traccount);
1134 g_warning("Cannot get transport account for message in outbox!!");
1136 } else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
1137 *is_draft = TRUE; /* Open in editor if the message is in the Drafts folder */
1141 TnyAccount *acc = tny_folder_get_account (folder);
1144 g_strdup (modest_tny_account_get_parent_modest_account_name_for_server_account (acc));
1145 g_object_unref (acc);
1149 g_object_unref (folder);
1155 open_msg_cb (ModestMailOperation *mail_op,
1162 ModestWindowMgr *mgr = NULL;
1163 ModestWindow *parent_win = NULL;
1164 ModestWindow *win = NULL;
1165 gchar *account = NULL;
1166 gboolean open_in_editor = FALSE;
1168 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1170 /* Do nothing if there was any problem with the mail
1171 operation. The error will be shown by the error_handler of
1172 the mail operation */
1173 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1176 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
1178 /* Mark header as read */
1179 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
1181 account = get_info_from_header (header, &open_in_editor, &can_open);
1185 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
1187 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1189 if (open_in_editor) {
1190 ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
1191 gchar *from_header = NULL, *acc_name;
1192 gchar *mailbox = NULL;
1194 from_header = tny_header_dup_from (header);
1196 /* we cannot edit without a valid account... */
1197 if (!modest_account_mgr_has_accounts(mgr, TRUE)) {
1198 if (!modest_ui_actions_run_account_setup_wizard(parent_win)) {
1199 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1201 g_free (from_header);
1206 acc_name = modest_utils_get_account_name_from_recipient (from_header, &mailbox);
1207 g_free (from_header);
1213 win = modest_msg_edit_window_new (msg, account, mailbox, TRUE);
1217 gchar *uid = modest_tny_folder_get_header_unique_id (header);
1218 const gchar *mailbox = NULL;
1220 if (parent_win && MODEST_IS_WINDOW (parent_win))
1221 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_win));
1223 if (helper->rowref && helper->model) {
1224 win = modest_msg_view_window_new_with_header_model (msg, account, mailbox, (const gchar*) uid,
1225 helper->model, helper->rowref);
1227 win = modest_msg_view_window_new_for_attachment (msg, account, mailbox, (const gchar*) uid);
1232 /* Register and show new window */
1234 mgr = modest_runtime_get_window_mgr ();
1235 if (!modest_window_mgr_register_window (mgr, win, NULL)) {
1236 gtk_widget_destroy (GTK_WIDGET (win));
1239 gtk_widget_show_all (GTK_WIDGET(win));
1242 /* Update toolbar dimming state */
1243 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
1244 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
1250 g_object_unref (parent_win);
1254 is_memory_full_error (GError *error, ModestMailOperation *mail_op)
1256 gboolean enough_free_space = TRUE;
1257 GnomeVFSURI *cache_dir_uri;
1258 const gchar *cache_dir = NULL;
1259 GnomeVFSFileSize free_space;
1260 TnyAccountStore *acc_store;
1262 acc_store = TNY_ACCOUNT_STORE (modest_runtime_get_account_store ());
1264 /* Cache dir is different in case we're using an external storage (like MMC account) */
1266 TnyAccount *account = modest_mail_operation_get_account (mail_op);
1268 if (modest_tny_account_is_memory_card_account (account)) {
1269 cache_dir = g_getenv (MODEST_MMC1_VOLUMEPATH_ENV);
1271 g_object_unref (account);
1275 /* Get the default local cache dir */
1277 cache_dir = tny_account_store_get_cache_dir (acc_store);
1279 cache_dir_uri = gnome_vfs_uri_new (cache_dir);
1280 if (cache_dir_uri) {
1281 if (gnome_vfs_get_volume_free_space (cache_dir_uri, &free_space) == GNOME_VFS_OK) {
1282 if (free_space < MIN_FREE_SPACE)
1283 enough_free_space = FALSE;
1285 gnome_vfs_uri_unref (cache_dir_uri);
1288 if ((error->code == TNY_SYSTEM_ERROR_MEMORY ||
1289 /* When asking for a mail and no space left on device
1290 tinymail returns this error */
1291 error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE ||
1292 /* When the folder summary could not be read or
1294 error->code == TNY_IO_ERROR_WRITE ||
1295 error->code == TNY_IO_ERROR_READ) &&
1296 !enough_free_space) {
1304 check_memory_full_error (GtkWidget *parent_window, GError *err)
1309 if (is_memory_full_error (err, NULL)) {
1310 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
1311 modest_platform_information_banner (parent_window, NULL, msg);
1313 } else if (err->code == TNY_SYSTEM_ERROR_MEMORY)
1314 /* If the account was created in memory full
1315 conditions then tinymail won't be able to
1316 connect so it'll return this error code */
1317 modest_platform_information_banner (parent_window,
1318 NULL, _("emev_ui_imap_inbox_select_error"));
1326 modest_ui_actions_disk_operations_error_handler (ModestMailOperation *mail_op,
1329 const GError *error;
1330 GObject *win = NULL;
1331 ModestMailOperationStatus status;
1333 win = modest_mail_operation_get_source (mail_op);
1334 error = modest_mail_operation_get_error (mail_op);
1335 status = modest_mail_operation_get_status (mail_op);
1337 /* If the mail op has been cancelled then it's not an error:
1338 don't show any message */
1339 if (status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
1340 if (is_memory_full_error ((GError *) error, mail_op)) {
1341 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
1342 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
1344 } else if (error->code == TNY_SYSTEM_ERROR_MEMORY) {
1345 modest_platform_information_banner ((GtkWidget *) win,
1346 NULL, _("emev_ui_imap_inbox_select_error"));
1347 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
1348 error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1349 modest_platform_information_banner ((GtkWidget *) win,
1350 NULL, _CS ("sfil_ni_unable_to_open_file_not_found"));
1351 } else if (user_data) {
1352 modest_platform_information_banner ((GtkWidget *) win,
1358 g_object_unref (win);
1362 * Returns the account a list of headers belongs to. It returns a
1363 * *new* reference so don't forget to unref it
1366 get_account_from_header_list (TnyList *headers)
1368 TnyAccount *account = NULL;
1370 if (tny_list_get_length (headers) > 0) {
1371 TnyIterator *iter = tny_list_create_iterator (headers);
1372 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1373 TnyFolder *folder = tny_header_get_folder (header);
1376 g_object_unref (header);
1378 while (!tny_iterator_is_done (iter)) {
1379 header = TNY_HEADER (tny_iterator_get_current (iter));
1380 folder = tny_header_get_folder (header);
1383 g_object_unref (header);
1385 tny_iterator_next (iter);
1390 account = tny_folder_get_account (folder);
1391 g_object_unref (folder);
1395 g_object_unref (header);
1397 g_object_unref (iter);
1403 get_account_from_header (TnyHeader *header)
1405 TnyAccount *account = NULL;
1408 folder = tny_header_get_folder (header);
1411 account = tny_folder_get_account (folder);
1412 g_object_unref (folder);
1418 open_msg_helper_destroyer (gpointer user_data)
1420 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1422 if (helper->banner_info) {
1423 g_free (helper->banner_info->message);
1424 if (helper->banner_info->idle_handler > 0) {
1425 g_source_remove (helper->banner_info->idle_handler);
1426 helper->banner_info->idle_handler = 0;
1428 if (helper->banner_info->banner != NULL) {
1429 gtk_widget_destroy (helper->banner_info->banner);
1430 g_object_unref (helper->banner_info->banner);
1431 helper->banner_info->banner = NULL;
1433 g_slice_free (OpenMsgBannerInfo, helper->banner_info);
1434 helper->banner_info = NULL;
1436 g_object_unref (helper->model);
1437 g_object_unref (helper->header);
1438 gtk_tree_row_reference_free (helper->rowref);
1439 g_slice_free (OpenMsgHelper, helper);
1443 open_msg_performer(gboolean canceled,
1445 GtkWindow *parent_window,
1446 TnyAccount *account,
1449 ModestMailOperation *mail_op = NULL;
1450 gchar *error_msg = NULL;
1451 ModestProtocolType proto;
1452 TnyConnectionStatus status;
1453 OpenMsgHelper *helper = NULL;
1454 ModestProtocol *protocol;
1455 ModestProtocolRegistry *protocol_registry;
1458 helper = (OpenMsgHelper *) user_data;
1460 status = tny_account_get_connection_status (account);
1461 if (err || canceled) {
1462 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1463 /* Free the helper */
1464 open_msg_helper_destroyer (helper);
1466 /* In memory full conditions we could get this error here */
1467 check_memory_full_error ((GtkWidget *) parent_window, err);
1472 /* Get the error message depending on the protocol */
1473 proto = modest_tny_account_get_protocol_type (account);
1474 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
1475 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
1478 protocol_registry = modest_runtime_get_protocol_registry ();
1479 subject = tny_header_dup_subject (helper->header);
1481 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, proto);
1482 error_msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
1486 if (error_msg == NULL) {
1487 error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1490 #ifndef MODEST_TOOLKIT_HILDON2
1491 gboolean show_open_draft = FALSE;
1492 if (modest_protocol_registry_protocol_type_has_tag (protocol_registry,
1494 MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS)) {
1496 TnyFolderType folder_type;
1498 folder = tny_header_get_folder (helper->header);
1499 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1500 show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
1501 g_object_unref (folder);
1505 #ifdef MODEST_TOOLKIT_HILDON2
1508 gchar *account_name = get_info_from_header (helper->header, &is_draft, &can_open);
1511 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1512 g_free (account_name);
1513 open_msg_helper_destroyer (helper);
1518 ModestWindow *window;
1519 GtkWidget *header_view;
1522 header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
1523 uid = modest_tny_folder_get_header_unique_id (helper->header);
1525 const gchar *mailbox = NULL;
1526 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_window));
1527 window = modest_msg_view_window_new_from_header_view
1528 (MODEST_HEADER_VIEW (header_view), account_name, mailbox, uid, helper->rowref);
1529 if (window != NULL) {
1530 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr (),
1532 gtk_widget_destroy (GTK_WIDGET (window));
1534 gtk_widget_show_all (GTK_WIDGET(window));
1538 g_free (account_name);
1540 open_msg_helper_destroyer (helper);
1543 g_free (account_name);
1545 /* Create the mail operation */
1547 modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
1548 modest_ui_actions_disk_operations_error_handler,
1549 g_strdup (error_msg), g_free);
1550 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1554 #ifndef MODEST_TOOLKIT_HILDON2
1555 if (show_open_draft) {
1556 helper->banner_info = g_slice_new (OpenMsgBannerInfo);
1557 helper->banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
1558 helper->banner_info->banner = NULL;
1559 helper->banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle,
1560 helper->banner_info);
1566 headers = TNY_LIST (tny_simple_list_new ());
1567 tny_list_prepend (headers, G_OBJECT (helper->header));
1568 modest_mail_operation_get_msgs_full (mail_op,
1572 open_msg_helper_destroyer);
1573 g_object_unref (headers);
1580 g_object_unref (mail_op);
1581 g_object_unref (account);
1585 * This function is used by both modest_ui_actions_on_open and
1586 * modest_ui_actions_on_header_activated. This way we always do the
1587 * same when trying to open messages.
1590 open_msg_from_header (TnyHeader *header, GtkTreeRowReference *rowref, ModestWindow *win)
1592 ModestWindowMgr *mgr = NULL;
1593 TnyAccount *account;
1594 gboolean cached = FALSE;
1596 GtkWidget *header_view = NULL;
1597 OpenMsgHelper *helper;
1598 ModestWindow *window;
1600 g_return_if_fail (header != NULL && rowref != NULL);
1602 mgr = modest_runtime_get_window_mgr ();
1605 header_view = get_header_view_from_window (MODEST_WINDOW (win));
1606 if (header_view == NULL)
1609 /* Get the account */
1610 account = get_account_from_header (header);
1615 found = modest_window_mgr_find_registered_header (mgr, header, &window);
1617 /* Do not open again the message and present the
1618 window to the user */
1621 #ifndef MODEST_TOOLKIT_HILDON2
1622 gtk_window_present (GTK_WINDOW (window));
1625 /* the header has been registered already, we don't do
1626 * anything but wait for the window to come up*/
1627 g_debug ("header %p already registered, waiting for window", header);
1632 /* Open each message */
1633 cached = tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED;
1635 /* Allways download if we are online. */
1636 if (!tny_device_is_online (modest_runtime_get_device ())) {
1639 /* If ask for user permission to download the messages */
1640 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1641 _("mcen_nc_get_msg"));
1643 /* End if the user does not want to continue */
1644 if (response == GTK_RESPONSE_CANCEL) {
1650 /* We register the window for opening */
1651 modest_window_mgr_register_header (mgr, header, NULL);
1653 /* Create the helper. We need to get a reference to the model
1654 here because it could change while the message is readed
1655 (the user could switch between folders) */
1656 helper = g_slice_new (OpenMsgHelper);
1657 helper->model = g_object_ref (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)));
1658 helper->header = g_object_ref (header);
1659 helper->rowref = gtk_tree_row_reference_copy (rowref);
1660 helper->banner_info = NULL;
1662 /* Connect to the account and perform */
1664 modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
1665 open_msg_performer, helper);
1667 /* Call directly the performer, do not need to connect */
1668 open_msg_performer (FALSE, NULL, (GtkWindow *) win,
1669 g_object_ref (account), helper);
1674 g_object_unref (account);
1678 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1685 /* we check for low-mem; in that case, show a warning, and don't allow
1688 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1692 headers = get_selected_headers (win);
1696 headers_count = tny_list_get_length (headers);
1697 if (headers_count != 1) {
1698 if (headers_count > 1) {
1699 /* Don't allow activation if there are more than one message selected */
1700 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
1703 g_object_unref (headers);
1707 iter = tny_list_create_iterator (headers);
1708 header = TNY_HEADER (tny_iterator_get_current (iter));
1709 g_object_unref (iter);
1713 open_msg_from_header (header, NULL, win);
1714 g_object_unref (header);
1717 g_object_unref(headers);
1721 rf_helper_window_closed (gpointer data,
1724 ReplyForwardHelper *helper = (ReplyForwardHelper *) data;
1726 helper->parent_window = NULL;
1729 static ReplyForwardHelper*
1730 create_reply_forward_helper (ReplyForwardAction action,
1732 guint reply_forward_type,
1735 ReplyForwardHelper *rf_helper = NULL;
1736 const gchar *active_acc = modest_window_get_active_account (win);
1737 const gchar *active_mailbox = modest_window_get_active_mailbox (win);
1739 rf_helper = g_slice_new0 (ReplyForwardHelper);
1740 rf_helper->reply_forward_type = reply_forward_type;
1741 rf_helper->action = action;
1742 rf_helper->parent_window = (MODEST_IS_WINDOW (win)) ? GTK_WIDGET (win) : NULL;
1743 rf_helper->header = (header) ? g_object_ref (header) : NULL;
1744 rf_helper->account_name = (active_acc) ?
1745 g_strdup (active_acc) :
1746 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1747 rf_helper->mailbox = g_strdup (active_mailbox);
1749 /* Note that window could be destroyed just AFTER calling
1750 register_window so we must ensure that this pointer does
1751 not hold invalid references */
1752 if (rf_helper->parent_window)
1753 g_object_weak_ref (G_OBJECT (rf_helper->parent_window),
1754 rf_helper_window_closed, rf_helper);
1760 free_reply_forward_helper (gpointer data)
1762 ReplyForwardHelper *helper;
1764 helper = (ReplyForwardHelper *) data;
1765 g_free (helper->account_name);
1766 g_free (helper->mailbox);
1768 g_object_unref (helper->header);
1769 if (helper->parent_window)
1770 g_object_weak_unref (G_OBJECT (helper->parent_window),
1771 rf_helper_window_closed, helper);
1772 g_slice_free (ReplyForwardHelper, helper);
1776 reply_forward_cb (ModestMailOperation *mail_op,
1783 TnyMsg *new_msg = NULL;
1784 ReplyForwardHelper *rf_helper;
1785 ModestWindow *msg_win = NULL;
1786 ModestEditType edit_type;
1788 TnyAccount *account = NULL;
1789 ModestWindowMgr *mgr = NULL;
1790 gchar *signature = NULL;
1791 gboolean use_signature;
1794 /* If there was any error. The mail operation could be NULL,
1795 this means that we already have the message downloaded and
1796 that we didn't do a mail operation to retrieve it */
1797 rf_helper = (ReplyForwardHelper *) user_data;
1798 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1801 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1802 rf_helper->account_name, rf_helper->mailbox);
1803 recipient = modest_text_utils_get_email_address (from);
1804 signature = modest_account_mgr_get_signature_from_recipient (modest_runtime_get_account_mgr(),
1809 /* Create reply mail */
1810 switch (rf_helper->action) {
1813 modest_tny_msg_create_reply_msg (msg, header, from,
1814 (use_signature) ? signature : NULL,
1815 rf_helper->reply_forward_type,
1816 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1818 case ACTION_REPLY_TO_ALL:
1820 modest_tny_msg_create_reply_msg (msg, header, from,
1821 (use_signature) ? signature : NULL,
1822 rf_helper->reply_forward_type,
1823 MODEST_TNY_MSG_REPLY_MODE_ALL);
1824 edit_type = MODEST_EDIT_TYPE_REPLY;
1826 case ACTION_FORWARD:
1828 modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL,
1829 rf_helper->reply_forward_type);
1830 edit_type = MODEST_EDIT_TYPE_FORWARD;
1833 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1835 g_return_if_reached ();
1843 g_warning ("%s: failed to create message\n", __FUNCTION__);
1847 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1848 rf_helper->account_name,
1849 TNY_ACCOUNT_TYPE_STORE);
1851 g_warning ("%s: failed to get tnyaccount for '%s'\n", __FUNCTION__, rf_helper->account_name);
1855 /* Create and register the windows */
1856 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, rf_helper->mailbox, FALSE);
1857 mgr = modest_runtime_get_window_mgr ();
1858 modest_window_mgr_register_window (mgr, msg_win, (ModestWindow *) rf_helper->parent_window);
1860 /* Note that register_window could have deleted the account */
1861 if (MODEST_IS_WINDOW (rf_helper->parent_window)) {
1862 gdouble parent_zoom;
1864 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1865 modest_window_set_zoom (msg_win, parent_zoom);
1868 /* Show edit window */
1869 gtk_widget_show_all (GTK_WIDGET (msg_win));
1872 /* We always unregister the header because the message is
1873 forwarded or replied so the original one is no longer
1875 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1878 g_object_unref (G_OBJECT (new_msg));
1880 g_object_unref (G_OBJECT (account));
1881 free_reply_forward_helper (rf_helper);
1884 /* Checks a list of headers. If any of them are not currently
1885 * downloaded (CACHED) then returns TRUE else returns FALSE.
1888 header_list_count_uncached_msgs (TnyList *header_list)
1891 gint uncached_messages = 0;
1893 iter = tny_list_create_iterator (header_list);
1894 while (!tny_iterator_is_done (iter)) {
1897 header = TNY_HEADER (tny_iterator_get_current (iter));
1899 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1900 uncached_messages ++;
1901 g_object_unref (header);
1904 tny_iterator_next (iter);
1906 g_object_unref (iter);
1908 return uncached_messages;
1911 /* Returns FALSE if the user does not want to download the
1912 * messages. Returns TRUE if the user allowed the download.
1915 connect_to_get_msg (ModestWindow *win,
1916 gint num_of_uncached_msgs,
1917 TnyAccount *account)
1919 GtkResponseType response;
1921 /* Allways download if we are online. */
1922 if (tny_device_is_online (modest_runtime_get_device ()))
1925 /* If offline, then ask for user permission to download the messages */
1926 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1927 ngettext("mcen_nc_get_msg",
1929 num_of_uncached_msgs));
1931 if (response == GTK_RESPONSE_CANCEL)
1934 return modest_platform_connect_and_wait((GtkWindow *) win, account);
1938 reply_forward_performer (gboolean canceled,
1940 GtkWindow *parent_window,
1941 TnyAccount *account,
1944 ReplyForwardHelper *rf_helper = NULL;
1945 ModestMailOperation *mail_op;
1947 rf_helper = (ReplyForwardHelper *) user_data;
1949 if (canceled || err) {
1950 free_reply_forward_helper (rf_helper);
1954 /* Retrieve the message */
1955 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), rf_helper->header, NULL);
1956 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (parent_window),
1957 modest_ui_actions_disk_operations_error_handler,
1959 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1960 modest_mail_operation_get_msg (mail_op, rf_helper->header, TRUE, reply_forward_cb, rf_helper);
1963 g_object_unref(mail_op);
1967 * Common code for the reply and forward actions
1970 reply_forward (ReplyForwardAction action, ModestWindow *win)
1972 ReplyForwardHelper *rf_helper = NULL;
1973 guint reply_forward_type;
1975 g_return_if_fail (MODEST_IS_WINDOW(win));
1977 /* we check for low-mem; in that case, show a warning, and don't allow
1978 * reply/forward (because it could potentially require a lot of memory */
1979 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1983 /* we need an account when editing */
1984 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1985 if (!modest_ui_actions_run_account_setup_wizard (win))
1989 reply_forward_type =
1990 modest_conf_get_int (modest_runtime_get_conf (),
1991 (action == ACTION_FORWARD) ?
1992 MODEST_CONF_FORWARD_TYPE :
1993 MODEST_CONF_REPLY_TYPE,
1996 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1998 TnyHeader *header = NULL;
1999 /* Get header and message. Do not free them here, the
2000 reply_forward_cb must do it */
2001 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
2002 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2004 if (msg && header) {
2006 rf_helper = create_reply_forward_helper (action, win,
2007 reply_forward_type, header);
2008 reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
2010 g_warning("%s: no message or header found in viewer\n", __FUNCTION__);
2014 g_object_unref (msg);
2016 g_object_unref (header);
2018 TnyHeader *header = NULL;
2020 gboolean do_retrieve = TRUE;
2021 TnyList *header_list = NULL;
2023 header_list = get_selected_headers (win);
2026 /* Check that only one message is selected for replying */
2027 if (tny_list_get_length (header_list) != 1) {
2028 modest_platform_information_banner ((win) ? GTK_WIDGET (win) : NULL,
2029 NULL, _("mcen_ib_select_one_message"));
2030 g_object_unref (header_list);
2034 /* Only reply/forward to one message */
2035 iter = tny_list_create_iterator (header_list);
2036 header = TNY_HEADER (tny_iterator_get_current (iter));
2037 g_object_unref (iter);
2039 /* Retrieve messages */
2040 do_retrieve = (action == ACTION_FORWARD) ||
2041 (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
2044 TnyAccount *account = NULL;
2045 TnyFolder *folder = NULL;
2046 gdouble download = TRUE;
2047 guint uncached_msgs = 0;
2049 folder = tny_header_get_folder (header);
2051 goto do_retrieve_frees;
2052 account = tny_folder_get_account (folder);
2054 goto do_retrieve_frees;
2056 uncached_msgs = header_list_count_uncached_msgs (header_list);
2058 if (uncached_msgs > 0) {
2059 /* Allways download if we are online. */
2060 if (!tny_device_is_online (modest_runtime_get_device ())) {
2063 /* If ask for user permission to download the messages */
2064 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2065 ngettext("mcen_nc_get_msg",
2069 /* End if the user does not want to continue */
2070 if (response == GTK_RESPONSE_CANCEL)
2077 rf_helper = create_reply_forward_helper (action, win,
2078 reply_forward_type, header);
2079 if (uncached_msgs > 0) {
2080 modest_platform_connect_and_perform (GTK_WINDOW (win),
2082 reply_forward_performer,
2085 reply_forward_performer (FALSE, NULL, GTK_WINDOW (win),
2086 account, rf_helper);
2091 g_object_unref (account);
2093 g_object_unref (folder);
2095 reply_forward_cb (NULL, header, FALSE, NULL, NULL, rf_helper);
2098 g_object_unref (header_list);
2099 g_object_unref (header);
2104 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
2106 g_return_if_fail (MODEST_IS_WINDOW(win));
2108 reply_forward (ACTION_REPLY, win);
2112 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
2114 g_return_if_fail (MODEST_IS_WINDOW(win));
2116 reply_forward (ACTION_FORWARD, win);
2120 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
2122 g_return_if_fail (MODEST_IS_WINDOW(win));
2124 reply_forward (ACTION_REPLY_TO_ALL, win);
2128 modest_ui_actions_on_next (GtkAction *action,
2129 ModestWindow *window)
2131 if (MODEST_IS_MAIN_WINDOW (window)) {
2132 GtkWidget *header_view;
2134 header_view = modest_main_window_get_child_widget (
2135 MODEST_MAIN_WINDOW(window),
2136 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2140 modest_header_view_select_next (
2141 MODEST_HEADER_VIEW(header_view));
2142 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2143 modest_msg_view_window_select_next_message (
2144 MODEST_MSG_VIEW_WINDOW (window));
2146 g_return_if_reached ();
2151 modest_ui_actions_on_prev (GtkAction *action,
2152 ModestWindow *window)
2154 g_return_if_fail (MODEST_IS_WINDOW(window));
2156 if (MODEST_IS_MAIN_WINDOW (window)) {
2157 GtkWidget *header_view;
2158 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2159 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2163 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
2164 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2165 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
2167 g_return_if_reached ();
2172 modest_ui_actions_on_sort (GtkAction *action,
2173 ModestWindow *window)
2175 GtkWidget *header_view = NULL;
2177 g_return_if_fail (MODEST_IS_WINDOW(window));
2179 if (MODEST_IS_MAIN_WINDOW (window)) {
2180 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2181 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2182 #ifdef MODEST_TOOLKIT_HILDON2
2183 } else if (MODEST_IS_HEADER_WINDOW (window)) {
2184 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
2189 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
2194 /* Show sorting dialog */
2195 modest_utils_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
2199 new_messages_arrived (ModestMailOperation *self,
2200 TnyList *new_headers,
2204 gboolean show_visual_notifications;
2206 source = modest_mail_operation_get_source (self);
2207 show_visual_notifications = (source) ? FALSE : TRUE;
2209 g_object_unref (source);
2211 /* Notify new messages have been downloaded. If the
2212 send&receive was invoked by the user then do not show any
2213 visual notification, only play a sound and activate the LED
2214 (for the Maemo version) */
2215 if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0) {
2217 /* We only notify about really new messages (not seen) we get */
2218 TnyList *actually_new_list;
2219 TnyIterator *iterator;
2220 actually_new_list = TNY_LIST (tny_simple_list_new ());
2221 for (iterator = tny_list_create_iterator (new_headers);
2222 !tny_iterator_is_done (iterator);
2223 tny_iterator_next (iterator)) {
2225 TnyHeaderFlags flags;
2226 header = TNY_HEADER (tny_iterator_get_current (iterator));
2227 flags = tny_header_get_flags (header);
2229 if (!(flags & TNY_HEADER_FLAG_SEEN)) {
2230 tny_list_append (actually_new_list, G_OBJECT (header));
2232 g_object_unref (header);
2235 g_object_unref (iterator);
2237 if (tny_list_get_length (actually_new_list) > 0) {
2238 modest_platform_on_new_headers_received (actually_new_list,
2239 show_visual_notifications);
2241 g_object_unref (actually_new_list);
2247 retrieve_all_messages_cb (GObject *source,
2249 guint retrieve_limit)
2255 window = GTK_WINDOW (source);
2256 msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"),
2257 num_msgs, retrieve_limit);
2259 /* Ask the user if they want to retrieve all the messages */
2261 modest_platform_run_confirmation_dialog_with_buttons (window, msg,
2262 _("mcen_bd_get_all"),
2263 _("mcen_bd_newest_only"));
2264 /* Free and return */
2266 return (response == GTK_RESPONSE_ACCEPT) ? TRUE : FALSE;
2270 TnyAccount *account;
2272 gchar *account_name;
2273 gboolean poke_status;
2274 gboolean interactive;
2275 ModestMailOperation *mail_op;
2279 do_send_receive_performer (gboolean canceled,
2281 GtkWindow *parent_window,
2282 TnyAccount *account,
2285 SendReceiveInfo *info;
2287 info = (SendReceiveInfo *) user_data;
2289 if (err || canceled) {
2290 /* In memory full conditions we could get this error here */
2291 check_memory_full_error ((GtkWidget *) parent_window, err);
2293 if (info->mail_op) {
2294 modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (),
2300 /* Set send/receive operation in progress */
2301 if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
2302 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
2305 if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
2306 g_signal_connect (G_OBJECT (info->mail_op), "operation-finished",
2307 G_CALLBACK (on_send_receive_finished),
2310 /* Send & receive. */
2311 modest_mail_operation_update_account (info->mail_op, info->account_name, info->poke_status, info->interactive,
2312 (info->win) ? retrieve_all_messages_cb : NULL,
2313 new_messages_arrived, info->win);
2318 g_object_unref (G_OBJECT (info->mail_op));
2319 if (info->account_name)
2320 g_free (info->account_name);
2322 g_object_unref (info->win);
2324 g_object_unref (info->account);
2325 g_slice_free (SendReceiveInfo, info);
2329 * This function performs the send & receive required actions. The
2330 * window is used to create the mail operation. Typically it should
2331 * always be the main window, but we pass it as argument in order to
2335 modest_ui_actions_do_send_receive (const gchar *account_name,
2336 gboolean force_connection,
2337 gboolean poke_status,
2338 gboolean interactive,
2341 gchar *acc_name = NULL;
2342 SendReceiveInfo *info;
2343 ModestTnyAccountStore *acc_store;
2345 /* If no account name was provided then get the current account, and if
2346 there is no current account then pick the default one: */
2347 if (!account_name) {
2349 acc_name = g_strdup (modest_window_get_active_account (win));
2351 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
2353 g_printerr ("modest: cannot get default account\n");
2357 acc_name = g_strdup (account_name);
2360 acc_store = modest_runtime_get_account_store ();
2362 /* Create the info for the connect and perform */
2363 info = g_slice_new (SendReceiveInfo);
2364 info->account_name = acc_name;
2365 info->win = (win) ? g_object_ref (win) : NULL;
2366 info->poke_status = poke_status;
2367 info->interactive = interactive;
2368 info->account = modest_tny_account_store_get_server_account (acc_store, acc_name,
2369 TNY_ACCOUNT_TYPE_STORE);
2370 /* We need to create the operation here, because otherwise it
2371 could happen that the queue emits the queue-empty signal
2372 while we're trying to connect the account */
2373 info->mail_op = modest_mail_operation_new_with_error_handling ((info->win) ? G_OBJECT (info->win) : NULL,
2374 modest_ui_actions_disk_operations_error_handler,
2376 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), info->mail_op);
2378 /* Invoke the connect and perform */
2379 modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
2380 force_connection, info->account,
2381 do_send_receive_performer, info);
2386 modest_ui_actions_do_cancel_send (const gchar *account_name,
2389 TnyTransportAccount *transport_account;
2390 TnySendQueue *send_queue = NULL;
2391 GError *error = NULL;
2393 /* Get transport account */
2395 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2396 (modest_runtime_get_account_store(),
2398 TNY_ACCOUNT_TYPE_TRANSPORT));
2399 if (!transport_account) {
2400 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2405 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account, TRUE));
2406 if (!TNY_IS_SEND_QUEUE(send_queue)) {
2407 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
2408 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2409 "modest: could not find send queue for account\n");
2411 /* Cancel the current send */
2412 tny_account_cancel (TNY_ACCOUNT (transport_account));
2414 /* Suspend all pending messages */
2415 tny_send_queue_cancel (send_queue, TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, &error);
2419 if (transport_account != NULL)
2420 g_object_unref (G_OBJECT (transport_account));
2424 modest_ui_actions_cancel_send_all (ModestWindow *win)
2426 GSList *account_names, *iter;
2428 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2431 iter = account_names;
2433 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
2434 iter = g_slist_next (iter);
2437 modest_account_mgr_free_account_names (account_names);
2438 account_names = NULL;
2442 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
2445 /* Check if accounts exist */
2446 gboolean accounts_exist =
2447 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2449 /* If not, allow the user to create an account before trying to send/receive. */
2450 if (!accounts_exist)
2451 modest_ui_actions_on_accounts (NULL, win);
2453 /* Cancel all sending operaitons */
2454 modest_ui_actions_cancel_send_all (win);
2458 * Refreshes all accounts. This function will be used by automatic
2462 modest_ui_actions_do_send_receive_all (ModestWindow *win,
2463 gboolean force_connection,
2464 gboolean poke_status,
2465 gboolean interactive)
2467 GSList *account_names, *iter;
2469 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2472 iter = account_names;
2474 modest_ui_actions_do_send_receive ((const char*) iter->data,
2476 poke_status, interactive, win);
2477 iter = g_slist_next (iter);
2480 modest_account_mgr_free_account_names (account_names);
2481 account_names = NULL;
2485 * Handler of the click on Send&Receive button in the main toolbar
2488 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
2490 /* Check if accounts exist */
2491 gboolean accounts_exist;
2494 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2496 /* If not, allow the user to create an account before trying to send/receive. */
2497 if (!accounts_exist)
2498 modest_ui_actions_on_accounts (NULL, win);
2500 /* Refresh the current folder. The if is always TRUE it's just an extra check */
2501 if (MODEST_IS_MAIN_WINDOW (win)) {
2502 GtkWidget *folder_view;
2503 TnyFolderStore *folder_store;
2506 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2507 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2511 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2514 g_object_unref (folder_store);
2515 /* Refresh the active account. Force the connection if needed
2516 and poke the status of all folders */
2517 modest_ui_actions_do_send_receive (NULL, TRUE, TRUE, TRUE, win);
2518 #ifdef MODEST_TOOLKIT_HILDON2
2519 } else if (MODEST_IS_ACCOUNTS_WINDOW (win)) {
2520 modest_ui_actions_do_send_receive_all (win, TRUE, TRUE, TRUE);
2523 const gchar *active_account;
2524 active_account = modest_window_get_active_account (MODEST_WINDOW (win));
2526 modest_ui_actions_do_send_receive (active_account, TRUE, TRUE, TRUE, win);
2533 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
2536 GtkWidget *header_view;
2538 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2540 header_view = modest_main_window_get_child_widget (main_window,
2541 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2545 conf = modest_runtime_get_conf ();
2547 /* what is saved/restored is depending on the style; thus; we save with
2548 * old style, then update the style, and restore for this new style
2550 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
2552 if (modest_header_view_get_style
2553 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
2554 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2555 MODEST_HEADER_VIEW_STYLE_TWOLINES);
2557 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2558 MODEST_HEADER_VIEW_STYLE_DETAILS);
2560 modest_widget_memory_restore (conf, G_OBJECT(header_view),
2561 MODEST_CONF_HEADER_VIEW_KEY);
2566 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
2568 ModestMainWindow *main_window)
2570 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2571 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2573 /* in the case the folder is empty, show the empty folder message and focus
2575 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
2576 if (modest_header_view_is_empty (header_view)) {
2577 TnyFolder *folder = modest_header_view_get_folder (header_view);
2578 GtkWidget *folder_view =
2579 modest_main_window_get_child_widget (main_window,
2580 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2581 if (folder != NULL) {
2582 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
2583 g_object_unref (folder);
2585 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
2589 /* If no header has been selected then exit */
2594 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
2595 gtk_widget_grab_focus (GTK_WIDGET(header_view));
2597 /* Update toolbar dimming state */
2598 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2599 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2603 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
2606 ModestWindow *window)
2608 GtkWidget *open_widget;
2609 GtkTreeRowReference *rowref;
2611 g_return_if_fail (MODEST_IS_WINDOW(window));
2612 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2613 g_return_if_fail (TNY_IS_HEADER (header));
2615 if (modest_header_view_count_selected_headers (header_view) > 1) {
2616 /* Don't allow activation if there are more than one message selected */
2617 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
2621 /* we check for low-mem; in that case, show a warning, and don't allow
2622 * activating headers
2624 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
2627 if (MODEST_IS_MAIN_WINDOW (window)) {
2628 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
2629 open_widget = modest_window_get_action_widget (MODEST_WINDOW (window), "/MenuBar/EmailMenu/EmailOpenMenu");
2630 if (!GTK_WIDGET_IS_SENSITIVE (open_widget))
2634 rowref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)), path);
2635 open_msg_from_header (header, rowref, MODEST_WINDOW (window));
2636 gtk_tree_row_reference_free (rowref);
2640 set_active_account_from_tny_account (TnyAccount *account,
2641 ModestWindow *window)
2643 const gchar *server_acc_name = tny_account_get_id (account);
2645 /* We need the TnyAccount provided by the
2646 account store because that is the one that
2647 knows the name of the Modest account */
2648 TnyAccount *modest_server_account =
2649 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
2650 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
2652 if (!modest_server_account) {
2653 g_warning ("%s: could not get tny account\n", __FUNCTION__);
2657 /* Update active account, but only if it's not a pseudo-account */
2658 if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
2659 (!modest_tny_account_is_memory_card_account(modest_server_account))) {
2660 const gchar *modest_acc_name =
2661 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
2662 if (modest_acc_name)
2663 modest_window_set_active_account (window, modest_acc_name);
2666 g_object_unref (modest_server_account);
2671 folder_refreshed_cb (ModestMailOperation *mail_op,
2675 ModestMainWindow *win = NULL;
2676 GtkWidget *folder_view, *header_view;
2677 const GError *error;
2679 g_return_if_fail (TNY_IS_FOLDER (folder));
2681 win = MODEST_MAIN_WINDOW (user_data);
2683 /* Check if the operation failed due to memory low conditions */
2684 error = modest_mail_operation_get_error (mail_op);
2685 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
2686 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
2687 modest_platform_run_information_dialog (GTK_WINDOW (win),
2688 _KR("memr_ib_operation_disabled"),
2694 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2696 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2699 TnyFolderStore *current_folder;
2701 current_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2702 if (current_folder) {
2703 gboolean different = ((TnyFolderStore *) folder != current_folder);
2704 g_object_unref (current_folder);
2710 /* Check if folder is empty and set headers view contents style */
2711 if ((tny_folder_get_all_count (folder) == 0) ||
2712 modest_header_view_is_empty (MODEST_HEADER_VIEW (header_view)))
2713 modest_main_window_set_contents_style (win,
2714 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2718 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2719 TnyFolderStore *folder_store,
2721 ModestMainWindow *main_window)
2723 GtkWidget *header_view;
2725 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2727 header_view = modest_main_window_get_child_widget(main_window,
2728 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2733 if (TNY_IS_ACCOUNT (folder_store)) {
2735 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2737 /* Show account details */
2738 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2741 if (TNY_IS_FOLDER (folder_store) && selected) {
2742 TnyAccount *account;
2744 /* Update the active account */
2745 account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2747 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2748 g_object_unref (account);
2752 /* Set the header style by default, it could
2753 be changed later by the refresh callback to
2755 modest_main_window_set_contents_style (main_window,
2756 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2758 /* Set folder on header view. This function
2759 will call tny_folder_refresh_async so we
2760 pass a callback that will be called when
2761 finished. We use that callback to set the
2762 empty view if there are no messages */
2763 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2764 TNY_FOLDER (folder_store),
2766 MODEST_WINDOW (main_window),
2767 folder_refreshed_cb,
2770 /* Restore configuration. We need to do this
2771 *after* the set_folder because the widget
2772 memory asks the header view about its
2774 modest_widget_memory_restore (modest_runtime_get_conf (),
2775 G_OBJECT(header_view),
2776 MODEST_CONF_HEADER_VIEW_KEY);
2778 /* No need to save the header view
2779 configuration for Maemo because it only
2780 saves the sorting stuff and that it's
2781 already being done by the sort
2782 dialog. Remove it when the GNOME version
2783 has the same behaviour */
2784 #ifdef MODEST_TOOLKIT_GTK
2785 if (modest_main_window_get_contents_style (main_window) ==
2786 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2787 modest_widget_memory_save (modest_runtime_get_conf (),
2788 G_OBJECT (header_view),
2789 MODEST_CONF_HEADER_VIEW_KEY);
2791 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2795 /* Update dimming state */
2796 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2797 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2801 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2808 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2810 online = tny_device_is_online (modest_runtime_get_device());
2813 /* already online -- the item is simply not there... */
2814 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2816 GTK_MESSAGE_WARNING,
2818 _("The %s you selected cannot be found"),
2820 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2821 gtk_dialog_run (GTK_DIALOG(dialog));
2823 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2826 _("mcen_bd_dialog_cancel"),
2827 GTK_RESPONSE_REJECT,
2828 _("mcen_bd_dialog_ok"),
2829 GTK_RESPONSE_ACCEPT,
2831 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2832 "Do you want to get online?"), item);
2833 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
2834 gtk_label_new (txt), FALSE, FALSE, 0);
2835 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2838 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2839 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2840 /* TODO: Comment about why is this commented out: */
2841 /* modest_platform_connect_and_wait (); */
2844 gtk_widget_destroy (dialog);
2848 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2851 /* g_message ("%s %s", __FUNCTION__, link); */
2856 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2859 modest_platform_activate_uri (link);
2863 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2866 modest_platform_show_uri_popup (link);
2870 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2873 /* we check for low-mem; in that case, show a warning, and don't allow
2874 * viewing attachments
2876 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
2879 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2883 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2884 const gchar *address,
2887 /* g_message ("%s %s", __FUNCTION__, address); */
2891 on_save_to_drafts_cb (ModestMailOperation *mail_op,
2892 TnyMsg *saved_draft,
2895 ModestMsgEditWindow *edit_window;
2897 /* TODO: in hildon 2 we have to dim and undim the header views while we're saving */
2898 #ifndef MODEST_TOOLKIT_HILDON2
2899 ModestMainWindow *win;
2901 /* FIXME. Make the header view sensitive again. This is a
2902 * temporary hack. See modest_ui_actions_on_save_to_drafts()
2904 win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2905 modest_runtime_get_window_mgr(), FALSE));
2907 GtkWidget *hdrview = modest_main_window_get_child_widget(
2908 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2909 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2913 edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2915 /* Set draft is there was no error */
2916 if (!modest_mail_operation_get_error (mail_op))
2917 modest_msg_edit_window_set_draft (edit_window, saved_draft);
2919 g_object_unref(edit_window);
2923 enough_space_for_message (ModestMsgEditWindow *edit_window,
2926 guint64 available_disk, expected_size;
2931 available_disk = modest_utils_get_available_space (NULL);
2932 modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2933 expected_size = modest_tny_msg_estimate_size (data->plain_body,
2938 /* Double check: memory full condition or message too big */
2939 if (available_disk < MIN_FREE_SPACE ||
2940 expected_size > available_disk) {
2941 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
2942 modest_platform_information_banner (NULL, NULL, msg);
2949 * djcb: if we're in low-memory state, we only allow for
2950 * saving messages smaller than
2951 * MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE (see modest-defs.h) this
2952 * should still allow for sending anything critical...
2954 if ((expected_size > MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE) &&
2955 modest_platform_check_memory_low (MODEST_WINDOW(edit_window), TRUE))
2959 * djcb: we also make sure that the attachments are smaller than the max size
2960 * this is for the case where we'd try to forward a message with attachments
2961 * bigger than our max allowed size, or sending an message from drafts which
2962 * somehow got past our checks when attaching.
2964 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
2965 modest_platform_run_information_dialog (
2966 GTK_WINDOW(edit_window),
2967 _KR("memr_ib_operation_disabled"),
2976 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2978 TnyTransportAccount *transport_account;
2979 ModestMailOperation *mail_operation;
2981 gchar *account_name;
2982 ModestAccountMgr *account_mgr;
2983 gboolean had_error = FALSE;
2984 ModestMainWindow *win = NULL;
2986 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
2988 data = modest_msg_edit_window_get_msg_data (edit_window);
2991 if (!enough_space_for_message (edit_window, data)) {
2992 modest_msg_edit_window_free_msg_data (edit_window, data);
2996 account_name = g_strdup (data->account_name);
2997 account_mgr = modest_runtime_get_account_mgr();
2999 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
3001 account_name = modest_account_mgr_get_default_account (account_mgr);
3002 if (!account_name) {
3003 g_printerr ("modest: no account found\n");
3004 modest_msg_edit_window_free_msg_data (edit_window, data);
3008 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
3009 account_name = g_strdup (data->account_name);
3013 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3014 (modest_runtime_get_account_store (),
3016 TNY_ACCOUNT_TYPE_TRANSPORT));
3017 if (!transport_account) {
3018 g_printerr ("modest: no transport account found for '%s'\n", account_name);
3019 g_free (account_name);
3020 modest_msg_edit_window_free_msg_data (edit_window, data);
3024 /* Create the mail operation */
3025 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler,
3027 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3029 modest_mail_operation_save_to_drafts (mail_operation,
3041 data->priority_flags,
3044 on_save_to_drafts_cb,
3045 g_object_ref(edit_window));
3047 #ifdef MODEST_TOOLKIT_HILDON2
3048 /* In hildon2 we always show the information banner on saving to drafts.
3049 * It will be a system information banner in this case.
3051 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3052 modest_platform_information_banner (NULL, NULL, text);
3055 /* Use the main window as the parent of the banner, if the
3056 main window does not exist it won't be shown, if the parent
3057 window exists then it's properly shown. We don't use the
3058 editor window because it could be closed (save to drafts
3059 could happen after closing the window */
3060 win = (ModestMainWindow *)
3061 modest_window_mgr_get_main_window( modest_runtime_get_window_mgr(), FALSE);
3063 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3064 modest_platform_information_banner (GTK_WIDGET (win), NULL, text);
3068 modest_msg_edit_window_set_modified (edit_window, FALSE);
3071 g_free (account_name);
3072 g_object_unref (G_OBJECT (transport_account));
3073 g_object_unref (G_OBJECT (mail_operation));
3075 modest_msg_edit_window_free_msg_data (edit_window, data);
3078 * If the drafts folder is selected then make the header view
3079 * insensitive while the message is being saved to drafts
3080 * (it'll be sensitive again in on_save_to_drafts_cb()). This
3081 * is not very clean but it avoids letting the drafts folder
3082 * in an inconsistent state: the user could edit the message
3083 * being saved and undesirable things would happen.
3084 * In the average case the user won't notice anything at
3085 * all. In the worst case (the user is editing a really big
3086 * file from Drafts) the header view will be insensitive
3087 * during the saving process (10 or 20 seconds, depending on
3088 * the message). Anyway this is just a quick workaround: once
3089 * we find a better solution it should be removed
3090 * See NB#65125 (commend #18) for details.
3092 if (!had_error && win != NULL) {
3093 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
3094 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
3096 TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
3098 if (modest_tny_folder_is_local_folder(folder)) {
3099 TnyFolderType folder_type;
3100 folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
3101 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
3102 GtkWidget *hdrview = modest_main_window_get_child_widget(
3103 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3104 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
3108 if (folder != NULL) g_object_unref(folder);
3115 /* For instance, when clicking the Send toolbar button when editing a message: */
3117 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
3119 TnyTransportAccount *transport_account = NULL;
3120 gboolean had_error = FALSE;
3122 ModestAccountMgr *account_mgr;
3123 gchar *account_name;
3124 ModestMailOperation *mail_operation;
3126 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
3128 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
3131 data = modest_msg_edit_window_get_msg_data (edit_window);
3134 if (!enough_space_for_message (edit_window, data)) {
3135 modest_msg_edit_window_free_msg_data (edit_window, data);
3139 account_mgr = modest_runtime_get_account_mgr();
3140 account_name = g_strdup (data->account_name);
3142 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
3145 account_name = modest_account_mgr_get_default_account (account_mgr);
3147 if (!account_name) {
3148 modest_msg_edit_window_free_msg_data (edit_window, data);
3149 /* Run account setup wizard */
3150 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window))) {
3155 /* Get the currently-active transport account for this modest account: */
3156 if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
3158 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3159 (modest_runtime_get_account_store (),
3160 account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
3163 if (!transport_account) {
3164 modest_msg_edit_window_free_msg_data (edit_window, data);
3165 /* Run account setup wizard */
3166 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
3171 /* Create the mail operation */
3172 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler, NULL, NULL);
3173 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3175 modest_mail_operation_send_new_mail (mail_operation,
3189 data->priority_flags);
3191 if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3192 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
3194 if (modest_mail_operation_get_error (mail_operation) != NULL) {
3195 const GError *error = modest_mail_operation_get_error (mail_operation);
3196 if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3197 error->code == MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED) {
3198 g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_operation))->message);
3199 modest_platform_information_banner (NULL, NULL, _CS("sfil_ni_not_enough_memory"));
3205 g_free (account_name);
3206 g_object_unref (G_OBJECT (transport_account));
3207 g_object_unref (G_OBJECT (mail_operation));
3209 modest_msg_edit_window_free_msg_data (edit_window, data);
3212 modest_msg_edit_window_set_sent (edit_window, TRUE);
3214 /* Save settings and close the window: */
3215 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
3222 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
3223 ModestMsgEditWindow *window)
3225 ModestMsgEditFormatState *format_state = NULL;
3227 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3228 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3230 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3233 format_state = modest_msg_edit_window_get_format_state (window);
3234 g_return_if_fail (format_state != NULL);
3236 format_state->bold = gtk_toggle_action_get_active (action);
3237 modest_msg_edit_window_set_format_state (window, format_state);
3238 g_free (format_state);
3243 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
3244 ModestMsgEditWindow *window)
3246 ModestMsgEditFormatState *format_state = NULL;
3248 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3249 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3251 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3254 format_state = modest_msg_edit_window_get_format_state (window);
3255 g_return_if_fail (format_state != NULL);
3257 format_state->italics = gtk_toggle_action_get_active (action);
3258 modest_msg_edit_window_set_format_state (window, format_state);
3259 g_free (format_state);
3264 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
3265 ModestMsgEditWindow *window)
3267 ModestMsgEditFormatState *format_state = NULL;
3269 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3270 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3272 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3275 format_state = modest_msg_edit_window_get_format_state (window);
3276 g_return_if_fail (format_state != NULL);
3278 format_state->bullet = gtk_toggle_action_get_active (action);
3279 modest_msg_edit_window_set_format_state (window, format_state);
3280 g_free (format_state);
3285 modest_ui_actions_on_change_justify (GtkRadioAction *action,
3286 GtkRadioAction *selected,
3287 ModestMsgEditWindow *window)
3289 ModestMsgEditFormatState *format_state = NULL;
3290 GtkJustification value;
3292 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3294 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3297 value = gtk_radio_action_get_current_value (selected);
3299 format_state = modest_msg_edit_window_get_format_state (window);
3300 g_return_if_fail (format_state != NULL);
3302 format_state->justification = value;
3303 modest_msg_edit_window_set_format_state (window, format_state);
3304 g_free (format_state);
3308 modest_ui_actions_on_select_editor_color (GtkAction *action,
3309 ModestMsgEditWindow *window)
3311 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3312 g_return_if_fail (GTK_IS_ACTION (action));
3314 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3317 modest_msg_edit_window_select_color (window);
3321 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
3322 ModestMsgEditWindow *window)
3324 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3325 g_return_if_fail (GTK_IS_ACTION (action));
3327 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3330 modest_msg_edit_window_select_background_color (window);
3334 modest_ui_actions_on_insert_image (GObject *object,
3335 ModestMsgEditWindow *window)
3337 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3340 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3343 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3346 modest_msg_edit_window_insert_image (window);
3350 modest_ui_actions_on_attach_file (GtkAction *action,
3351 ModestMsgEditWindow *window)
3353 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3354 g_return_if_fail (GTK_IS_ACTION (action));
3356 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3359 modest_msg_edit_window_offer_attach_file (window);
3363 modest_ui_actions_on_remove_attachments (GtkAction *action,
3364 ModestMsgEditWindow *window)
3366 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3368 modest_msg_edit_window_remove_attachments (window, NULL);
3372 do_create_folder_cb (ModestMailOperation *mail_op,
3373 TnyFolderStore *parent_folder,
3374 TnyFolder *new_folder,
3377 gchar *suggested_name = (gchar *) user_data;
3378 GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
3379 const GError *error;
3381 error = modest_mail_operation_get_error (mail_op);
3384 /* Show an error. If there was some problem writing to
3385 disk, show it, otherwise show the generic folder
3386 create error. We do it here and not in an error
3387 handler because the call to do_create_folder will
3388 stop the main loop in a gtk_dialog_run and then,
3389 the message won't be shown until that dialog is
3391 modest_ui_actions_disk_operations_error_handler (mail_op,
3392 _("mail_in_ui_folder_create_error"));
3394 if (!is_memory_full_error ((GError *) error, mail_op)) {
3395 /* Try again if there is no full memory condition */
3396 do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
3399 /* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
3400 * FIXME: any other? */
3401 GtkWidget *folder_view;
3403 if (MODEST_IS_MAIN_WINDOW(source_win))
3405 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
3406 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3408 folder_view = GTK_WIDGET(g_object_get_data (G_OBJECT (source_win),
3409 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
3411 /* Select the newly created folder. It could happen
3412 that the widget is no longer there (i.e. the window
3413 has been destroyed, so we need to check this */
3415 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
3417 g_object_unref (new_folder);
3419 /* Free. Note that the first time it'll be NULL so noop */
3420 g_free (suggested_name);
3421 g_object_unref (source_win);
3426 TnyFolderStore *parent;
3427 } CreateFolderConnect;
3430 do_create_folder_performer (gboolean canceled,
3432 GtkWindow *parent_window,
3433 TnyAccount *account,
3436 CreateFolderConnect *helper = (CreateFolderConnect *) user_data;
3437 ModestMailOperation *mail_op;
3439 if (canceled || err) {
3440 /* In memory full conditions we could get this error here */
3441 check_memory_full_error ((GtkWidget *) parent_window, err);
3443 /* This happens if we have selected the outbox folder
3445 if (err->code == TNY_SERVICE_ERROR_UNKNOWN &&
3446 TNY_IS_MERGE_FOLDER (helper->parent)) {
3447 /* Show an error and retry */
3448 modest_platform_information_banner ((GtkWidget *) parent_window,
3450 _("mail_in_ui_folder_create_error"));
3452 do_create_folder (parent_window, helper->parent, helper->folder_name);
3458 mail_op = modest_mail_operation_new ((GObject *) parent_window);
3459 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3461 modest_mail_operation_create_folder (mail_op,
3463 (const gchar *) helper->folder_name,
3464 do_create_folder_cb,
3465 g_strdup (helper->folder_name));
3466 g_object_unref (mail_op);
3470 g_object_unref (helper->parent);
3471 if (helper->folder_name)
3472 g_free (helper->folder_name);
3473 g_slice_free (CreateFolderConnect, helper);
3478 do_create_folder (GtkWindow *parent_window,
3479 TnyFolderStore *suggested_parent,
3480 const gchar *suggested_name)
3483 gchar *folder_name = NULL;
3484 TnyFolderStore *parent_folder = NULL;
3486 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
3488 (gchar *) suggested_name,
3492 if (result == GTK_RESPONSE_ACCEPT && parent_folder) {
3493 CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderConnect);
3494 helper->folder_name = g_strdup (folder_name);
3495 helper->parent = g_object_ref (parent_folder);
3497 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
3500 do_create_folder_performer,
3505 g_free (folder_name);
3507 g_object_unref (parent_folder);
3511 modest_ui_actions_create_folder(GtkWidget *parent_window,
3512 GtkWidget *folder_view,
3513 TnyFolderStore *parent_folder)
3515 if (!parent_folder) {
3516 #ifdef MODEST_TOOLKIT_HILDON2
3517 ModestTnyAccountStore *acc_store;
3519 acc_store = modest_runtime_get_account_store ();
3521 parent_folder = (TnyFolderStore *)
3522 modest_tny_account_store_get_local_folders_account (acc_store);
3524 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3528 if (parent_folder) {
3529 do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
3530 g_object_unref (parent_folder);
3535 modest_ui_actions_on_new_folder (GtkAction *action, ModestWindow *window)
3538 g_return_if_fail (MODEST_IS_WINDOW(window));
3540 if (MODEST_IS_MAIN_WINDOW (window)) {
3541 GtkWidget *folder_view;
3543 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3544 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3548 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3549 #ifdef MODEST_TOOLKIT_HILDON2
3550 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3551 GtkWidget *folder_view;
3553 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3554 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3557 g_assert_not_reached ();
3562 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
3565 const GError *error = NULL;
3566 gchar *message = NULL;
3569 /* Get error message */
3570 error = modest_mail_operation_get_error (mail_op);
3572 g_return_if_reached ();
3574 mem_full = is_memory_full_error ((GError *) error, mail_op);
3576 message = g_strdup_printf (_KR("cerm_device_memory_full"), "");
3577 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3578 error->code == MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS) {
3579 message = _CS("ckdg_ib_folder_already_exists");
3580 } else if (error->domain == TNY_ERROR_DOMAIN &&
3581 error->code == TNY_SERVICE_ERROR_STATE) {
3582 /* This means that the folder is already in use (a
3583 message is opened for example */
3584 message = _("emev_ni_internal_error");
3586 message = _CS("ckdg_ib_unable_to_rename");
3589 /* We don't set a parent for the dialog because the dialog
3590 will be destroyed so the banner won't appear */
3591 modest_platform_information_banner (NULL, NULL, message);
3598 TnyFolderStore *folder;
3603 on_rename_folder_cb (ModestMailOperation *mail_op,
3604 TnyFolder *new_folder,
3607 ModestFolderView *folder_view;
3609 /* If the window was closed when renaming a folder, or if
3610 * it's not a main window this will happen */
3611 if (!MODEST_IS_FOLDER_VIEW (user_data))
3614 folder_view = MODEST_FOLDER_VIEW (user_data);
3615 /* Note that if the rename fails new_folder will be NULL */
3617 modest_folder_view_select_folder (folder_view, new_folder, FALSE);
3619 modest_folder_view_select_first_inbox_or_local (folder_view);
3621 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
3625 on_rename_folder_performer (gboolean canceled,
3627 GtkWindow *parent_window,
3628 TnyAccount *account,
3631 ModestMailOperation *mail_op = NULL;
3632 GtkTreeSelection *sel = NULL;
3633 GtkWidget *folder_view = NULL;
3634 RenameFolderInfo *data = (RenameFolderInfo*)user_data;
3636 if (canceled || err) {
3637 /* In memory full conditions we could get this error here */
3638 check_memory_full_error ((GtkWidget *) parent_window, err);
3642 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3643 modest_ui_actions_rename_folder_error_handler,
3644 parent_window, NULL);
3646 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3649 if (MODEST_IS_MAIN_WINDOW(parent_window)) {
3651 folder_view = modest_main_window_get_child_widget (
3652 MODEST_MAIN_WINDOW (parent_window),
3653 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3655 #ifdef MODEST_TOOLKIT_HILDON2
3656 else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3657 ModestFolderWindow *folder_window = (ModestFolderWindow *) parent_window;
3658 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (folder_window));
3662 /* Clear the folders view */
3663 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3664 gtk_tree_selection_unselect_all (sel);
3666 /* Actually rename the folder */
3667 modest_mail_operation_rename_folder (mail_op,
3668 TNY_FOLDER (data->folder),
3669 (const gchar *) (data->new_name),
3670 on_rename_folder_cb,
3672 g_object_unref (mail_op);
3675 g_object_unref (data->folder);
3676 g_free (data->new_name);
3681 modest_ui_actions_on_rename_folder (GtkAction *action,
3682 ModestWindow *window)
3684 modest_ui_actions_on_edit_mode_rename_folder (window);
3688 modest_ui_actions_on_edit_mode_rename_folder (ModestWindow *window)
3690 TnyFolderStore *folder;
3691 GtkWidget *folder_view;
3692 gboolean do_rename = TRUE;
3694 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3696 if (MODEST_IS_MAIN_WINDOW (window)) {
3697 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3698 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3702 #ifdef MODEST_TOOLKIT_HILDON2
3703 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3704 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3710 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3715 if (TNY_IS_FOLDER (folder)) {
3716 gchar *folder_name = NULL;
3718 const gchar *current_name;
3719 TnyFolderStore *parent;
3721 current_name = tny_folder_get_name (TNY_FOLDER (folder));
3722 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
3723 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (window),
3724 parent, current_name,
3726 g_object_unref (parent);
3728 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
3731 RenameFolderInfo *rename_folder_data = g_new0 (RenameFolderInfo, 1);
3732 rename_folder_data->folder = g_object_ref (folder);
3733 rename_folder_data->new_name = folder_name;
3734 modest_platform_connect_if_remote_and_perform (GTK_WINDOW(window), TRUE,
3735 folder, on_rename_folder_performer, rename_folder_data);
3738 g_object_unref (folder);
3743 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
3746 GObject *win = modest_mail_operation_get_source (mail_op);
3748 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
3749 _("mail_in_ui_folder_delete_error"),
3751 g_object_unref (win);
3755 TnyFolderStore *folder;
3756 gboolean move_to_trash;
3760 on_delete_folder_cb (gboolean canceled,
3762 GtkWindow *parent_window,
3763 TnyAccount *account,
3766 DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
3767 GtkWidget *folder_view;
3768 ModestMailOperation *mail_op;
3769 GtkTreeSelection *sel;
3771 if (!MODEST_IS_WINDOW(parent_window) || canceled || (err!=NULL)) {
3772 g_object_unref (G_OBJECT (info->folder));
3777 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
3778 folder_view = modest_main_window_get_child_widget (
3779 MODEST_MAIN_WINDOW (parent_window),
3780 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3781 #ifdef MODEST_TOOLKIT_HILDON2
3782 } else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3783 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (parent_window)));
3786 g_object_unref (G_OBJECT (info->folder));
3791 /* Unselect the folder before deleting it to free the headers */
3792 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3793 gtk_tree_selection_unselect_all (sel);
3795 /* Create the mail operation */
3797 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3798 modest_ui_actions_delete_folder_error_handler,
3801 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3803 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
3805 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
3807 g_object_unref (G_OBJECT (mail_op));
3808 g_object_unref (G_OBJECT (info->folder));
3813 delete_folder (ModestWindow *window, gboolean move_to_trash)
3815 TnyFolderStore *folder;
3816 GtkWidget *folder_view;
3820 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3822 if (MODEST_IS_MAIN_WINDOW (window)) {
3824 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3825 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3826 #ifdef MODEST_TOOLKIT_HILDON2
3827 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3828 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3836 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3841 /* Show an error if it's an account */
3842 if (!TNY_IS_FOLDER (folder)) {
3843 modest_platform_run_information_dialog (GTK_WINDOW (window),
3844 _("mail_in_ui_folder_delete_error"),
3846 g_object_unref (G_OBJECT (folder));
3851 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
3852 tny_folder_get_name (TNY_FOLDER (folder)));
3853 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
3854 (const gchar *) message);
3857 if (response == GTK_RESPONSE_OK) {
3858 DeleteFolderInfo *info;
3859 info = g_new0(DeleteFolderInfo, 1);
3860 info->folder = folder;
3861 info->move_to_trash = move_to_trash;
3862 g_object_ref (G_OBJECT (info->folder));
3863 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder));
3864 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (window),
3866 TNY_FOLDER_STORE (account),
3867 on_delete_folder_cb, info);
3868 g_object_unref (account);
3873 g_object_unref (G_OBJECT (folder));
3877 modest_ui_actions_on_delete_folder (GtkAction *action,
3878 ModestWindow *window)
3880 modest_ui_actions_on_edit_mode_delete_folder (window);
3884 modest_ui_actions_on_edit_mode_delete_folder (ModestWindow *window)
3886 g_return_val_if_fail (MODEST_IS_WINDOW(window), TRUE);
3888 return delete_folder (window, FALSE);
3892 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
3894 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3896 delete_folder (MODEST_WINDOW (main_window), TRUE);
3900 typedef struct _PasswordDialogFields {
3901 GtkWidget *username;
3902 GtkWidget *password;
3904 } PasswordDialogFields;
3907 password_dialog_check_field (GtkEditable *editable,
3908 PasswordDialogFields *fields)
3911 gboolean any_value_empty = FALSE;
3913 #ifdef MODEST_TOOLKIT_HILDON2
3914 value = hildon_entry_get_text (HILDON_ENTRY (fields->username));
3916 value = gtk_entry_get_text (GTK_ENTRY (fields->username));
3918 if ((value == NULL) || value[0] == '\0') {
3919 any_value_empty = TRUE;
3921 #ifdef MODEST_TOOLKIT_HILDON2
3922 value = hildon_entry_get_text (HILDON_ENTRY (fields->password));
3924 value = gtk_entry_get_text (GTK_ENTRY (fields->password));
3926 if ((value == NULL) || value[0] == '\0') {
3927 any_value_empty = TRUE;
3929 gtk_dialog_set_response_sensitive (GTK_DIALOG (fields->dialog), GTK_RESPONSE_ACCEPT, !any_value_empty);
3933 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
3934 const gchar* server_account_name,
3939 ModestMainWindow *main_window)
3941 g_return_if_fail(server_account_name);
3942 gboolean completed = FALSE;
3943 PasswordDialogFields *fields = NULL;
3945 /* Initalize output parameters: */
3952 #ifndef MODEST_TOOLKIT_GTK
3953 /* Maemo uses a different (awkward) button order,
3954 * It should probably just use gtk_alternative_dialog_button_order ().
3956 #ifdef MODEST_TOOLKIT_HILDON2
3958 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3961 _HL("wdgt_bd_done"),
3962 GTK_RESPONSE_ACCEPT,
3964 gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
3965 HILDON_MARGIN_DOUBLE);
3968 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3971 _("mcen_bd_dialog_ok"),
3972 GTK_RESPONSE_ACCEPT,
3973 _("mcen_bd_dialog_cancel"),
3974 GTK_RESPONSE_REJECT,
3976 #endif /* MODEST_TOOLKIT_HILDON2 */
3979 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3983 GTK_RESPONSE_REJECT,
3985 GTK_RESPONSE_ACCEPT,
3987 #endif /* MODEST_TOOLKIT_GTK */
3989 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog), NULL);
3991 gchar *server_name = modest_account_mgr_get_server_account_hostname (
3992 modest_runtime_get_account_mgr(), server_account_name);
3993 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
3994 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
3997 gtk_widget_destroy (dialog);
4001 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
4002 GtkWidget *label = gtk_label_new (txt);
4003 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4005 g_free (server_name);
4006 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
4011 gchar *initial_username = modest_account_mgr_get_server_account_username (
4012 modest_runtime_get_account_mgr(), server_account_name);
4014 #ifdef MODEST_TOOLKIT_HILDON2
4015 GtkWidget *entry_username = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4016 if (initial_username)
4017 hildon_entry_set_text (HILDON_ENTRY (entry_username), initial_username);
4019 GtkWidget *entry_username = gtk_entry_new ();
4020 if (initial_username)
4021 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
4023 /* Dim this if a connection has ever succeeded with this username,
4024 * as per the UI spec: */
4025 /* const gboolean username_known = */
4026 /* modest_account_mgr_get_server_account_username_has_succeeded( */
4027 /* modest_runtime_get_account_mgr(), server_account_name); */
4028 /* gtk_widget_set_sensitive (entry_username, !username_known); */
4030 /* We drop the username sensitive code and disallow changing it here
4031 * as tinymail does not support really changing the username in the callback
4033 gtk_widget_set_sensitive (entry_username, FALSE);
4035 #ifndef MODEST_TOOLKIT_GTK
4036 /* Auto-capitalization is the default, so let's turn it off: */
4037 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
4039 /* Create a size group to be used by all captions.
4040 * Note that HildonCaption does not create a default size group if we do not specify one.
4041 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
4042 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
4044 #ifdef MODEST_TOOLKIT_HILDON2
4045 GtkWidget *caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4046 _("mail_fi_username"), FALSE,
4049 GtkWidget *caption = hildon_caption_new (sizegroup,
4050 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
4052 gtk_widget_show (entry_username);
4053 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4054 FALSE, FALSE, MODEST_MARGIN_HALF);
4055 gtk_widget_show (caption);
4057 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
4059 #endif /* !MODEST_TOOLKIT_GTK */
4062 #ifdef MODEST_TOOLKIT_HILDON2
4063 GtkWidget *entry_password = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4065 GtkWidget *entry_password = gtk_entry_new ();
4067 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
4068 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
4070 #ifndef MODEST_TOOLKIT_GTK
4071 /* Auto-capitalization is the default, so let's turn it off: */
4072 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
4073 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
4075 #ifdef MODEST_TOOLKIT_HILDON2
4076 caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4077 _("mail_fi_password"), FALSE,
4080 caption = hildon_caption_new (sizegroup,
4081 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
4083 gtk_widget_show (entry_password);
4084 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4085 FALSE, FALSE, MODEST_MARGIN_HALF);
4086 gtk_widget_show (caption);
4087 g_object_unref (sizegroup);
4089 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
4091 #endif /* !MODEST_TOOLKIT_GTK */
4093 if (initial_username != NULL)
4094 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
4096 /* This is not in the Maemo UI spec:
4097 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
4098 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
4102 fields = g_slice_new0 (PasswordDialogFields);
4103 fields->username = entry_username;
4104 fields->password = entry_password;
4105 fields->dialog = dialog;
4107 g_signal_connect (entry_username, "changed", G_CALLBACK (password_dialog_check_field), fields);
4108 g_signal_connect (entry_password, "changed", G_CALLBACK (password_dialog_check_field), fields);
4109 password_dialog_check_field (NULL, fields);
4111 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
4113 while (!completed) {
4115 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
4117 #ifdef MODEST_TOOLKIT_HILDON2
4118 *username = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_username)));
4120 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
4123 /* Note that an empty field becomes the "" string */
4124 if (*username && strlen (*username) > 0) {
4125 modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
4126 server_account_name,
4130 const gboolean username_was_changed =
4131 (strcmp (*username, initial_username) != 0);
4132 if (username_was_changed) {
4133 g_warning ("%s: tinymail does not yet support changing the "
4134 "username in the get_password() callback.\n", __FUNCTION__);
4140 modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
4141 _("mcen_ib_username_pw_incorrect"));
4147 #ifdef MODEST_TOOLKIT_HILDON2
4148 *password = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_password)));
4150 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
4153 /* We do not save the password in the configuration,
4154 * because this function is only called for passwords that should
4155 * not be remembered:
4156 modest_server_account_set_password (
4157 modest_runtime_get_account_mgr(), server_account_name,
4164 #ifndef MODEST_TOOLKIT_HILDON2
4165 /* Set parent to NULL or the banner will disappear with its parent dialog */
4166 modest_platform_information_banner(NULL, NULL, _("mail_ib_login_cancelled"));
4178 /* This is not in the Maemo UI spec:
4179 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
4185 g_free (initial_username);
4186 gtk_widget_destroy (dialog);
4187 g_slice_free (PasswordDialogFields, fields);
4189 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
4193 modest_ui_actions_on_cut (GtkAction *action,
4194 ModestWindow *window)
4196 GtkWidget *focused_widget;
4197 GtkClipboard *clipboard;
4199 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4200 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4201 if (GTK_IS_EDITABLE (focused_widget)) {
4202 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
4203 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4204 gtk_clipboard_store (clipboard);
4205 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4206 GtkTextBuffer *buffer;
4208 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4209 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4210 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
4211 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4212 gtk_clipboard_store (clipboard);
4214 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4215 TnyList *header_list = modest_header_view_get_selected_headers (
4216 MODEST_HEADER_VIEW (focused_widget));
4217 gboolean continue_download = FALSE;
4218 gint num_of_unc_msgs;
4220 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4222 if (num_of_unc_msgs) {
4223 TnyAccount *account = get_account_from_header_list (header_list);
4225 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4226 g_object_unref (account);
4230 if (num_of_unc_msgs == 0 || continue_download) {
4231 /* modest_platform_information_banner (
4232 NULL, NULL, _CS("mcen_ib_getting_items"));*/
4233 modest_header_view_cut_selection (
4234 MODEST_HEADER_VIEW (focused_widget));
4237 g_object_unref (header_list);
4238 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4239 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
4244 modest_ui_actions_on_copy (GtkAction *action,
4245 ModestWindow *window)
4247 GtkClipboard *clipboard;
4248 GtkWidget *focused_widget;
4249 gboolean copied = TRUE;
4251 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4252 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4254 if (GTK_IS_LABEL (focused_widget)) {
4256 selection = modest_text_utils_label_get_selection (GTK_LABEL (focused_widget));
4257 gtk_clipboard_set_text (clipboard, selection, -1);
4259 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4260 gtk_clipboard_store (clipboard);
4261 } else if (GTK_IS_EDITABLE (focused_widget)) {
4262 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
4263 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4264 gtk_clipboard_store (clipboard);
4265 } else if (GTK_IS_HTML (focused_widget)) {
4268 sel = gtk_html_get_selection_html (GTK_HTML (focused_widget), &len);
4269 if ((sel == NULL) || (sel[0] == '\0')) {
4272 gtk_html_copy (GTK_HTML (focused_widget));
4273 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4274 gtk_clipboard_store (clipboard);
4276 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4277 GtkTextBuffer *buffer;
4278 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4279 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4280 gtk_text_buffer_copy_clipboard (buffer, clipboard);
4281 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4282 gtk_clipboard_store (clipboard);
4284 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4285 TnyList *header_list = modest_header_view_get_selected_headers (
4286 MODEST_HEADER_VIEW (focused_widget));
4287 gboolean continue_download = FALSE;
4288 gint num_of_unc_msgs;
4290 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4292 if (num_of_unc_msgs) {
4293 TnyAccount *account = get_account_from_header_list (header_list);
4295 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4296 g_object_unref (account);
4300 if (num_of_unc_msgs == 0 || continue_download) {
4301 modest_platform_information_banner (
4302 NULL, NULL, _CS("mcen_ib_getting_items"));
4303 modest_header_view_copy_selection (
4304 MODEST_HEADER_VIEW (focused_widget));
4308 g_object_unref (header_list);
4310 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4311 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
4314 /* Show information banner if there was a copy to clipboard */
4316 modest_platform_information_banner (
4317 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
4321 modest_ui_actions_on_undo (GtkAction *action,
4322 ModestWindow *window)
4324 ModestEmailClipboard *clipboard = NULL;
4326 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4327 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
4328 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4329 /* Clear clipboard source */
4330 clipboard = modest_runtime_get_email_clipboard ();
4331 modest_email_clipboard_clear (clipboard);
4334 g_return_if_reached ();
4339 modest_ui_actions_on_redo (GtkAction *action,
4340 ModestWindow *window)
4342 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4343 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
4346 g_return_if_reached ();
4352 destroy_information_note (ModestMailOperation *mail_op,
4355 /* destroy information note */
4356 gtk_widget_destroy (GTK_WIDGET(user_data));
4360 destroy_folder_information_note (ModestMailOperation *mail_op,
4361 TnyFolder *new_folder,
4364 /* destroy information note */
4365 gtk_widget_destroy (GTK_WIDGET(user_data));
4370 paste_as_attachment_free (gpointer data)
4372 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
4374 if (helper->banner) {
4375 gtk_widget_destroy (helper->banner);
4376 g_object_unref (helper->banner);
4382 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
4387 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
4388 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
4393 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
4398 modest_ui_actions_on_paste (GtkAction *action,
4399 ModestWindow *window)
4401 GtkWidget *focused_widget = NULL;
4402 GtkWidget *inf_note = NULL;
4403 ModestMailOperation *mail_op = NULL;
4405 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4406 if (GTK_IS_EDITABLE (focused_widget)) {
4407 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
4408 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4409 ModestEmailClipboard *e_clipboard = NULL;
4410 e_clipboard = modest_runtime_get_email_clipboard ();
4411 if (modest_email_clipboard_cleared (e_clipboard)) {
4412 GtkTextBuffer *buffer;
4413 GtkClipboard *clipboard;
4415 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4416 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4417 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
4418 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4419 ModestMailOperation *mail_op;
4420 TnyFolder *src_folder = NULL;
4421 TnyList *data = NULL;
4423 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
4424 helper->window = MODEST_MSG_EDIT_WINDOW (window);
4425 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4426 _CS("ckct_nw_pasting"));
4427 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
4428 mail_op = modest_mail_operation_new (G_OBJECT (window));
4429 if (helper->banner != NULL) {
4430 g_object_ref (G_OBJECT (helper->banner));
4431 gtk_widget_show (GTK_WIDGET (helper->banner));
4435 modest_mail_operation_get_msgs_full (mail_op,
4437 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
4439 paste_as_attachment_free);
4443 g_object_unref (data);
4445 g_object_unref (src_folder);
4448 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4449 ModestEmailClipboard *clipboard = NULL;
4450 TnyFolder *src_folder = NULL;
4451 TnyFolderStore *folder_store = NULL;
4452 TnyList *data = NULL;
4453 gboolean delete = FALSE;
4455 /* Check clipboard source */
4456 clipboard = modest_runtime_get_email_clipboard ();
4457 if (modest_email_clipboard_cleared (clipboard))
4460 /* Get elements to paste */
4461 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
4463 /* Create a new mail operation */
4464 mail_op = modest_mail_operation_new (G_OBJECT(window));
4466 /* Get destination folder */
4467 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
4469 /* transfer messages */
4473 /* Ask for user confirmation */
4475 modest_ui_actions_msgs_move_to_confirmation (window,
4476 TNY_FOLDER (folder_store),
4480 if (response == GTK_RESPONSE_OK) {
4481 /* Launch notification */
4482 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4483 _CS("ckct_nw_pasting"));
4484 if (inf_note != NULL) {
4485 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4486 gtk_widget_show (GTK_WIDGET(inf_note));
4489 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4490 modest_mail_operation_xfer_msgs (mail_op,
4492 TNY_FOLDER (folder_store),
4494 destroy_information_note,
4497 g_object_unref (mail_op);
4500 } else if (src_folder != NULL) {
4501 /* Launch notification */
4502 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4503 _CS("ckct_nw_pasting"));
4504 if (inf_note != NULL) {
4505 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4506 gtk_widget_show (GTK_WIDGET(inf_note));
4509 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4510 modest_mail_operation_xfer_folder (mail_op,
4514 destroy_folder_information_note,
4520 g_object_unref (data);
4521 if (src_folder != NULL)
4522 g_object_unref (src_folder);
4523 if (folder_store != NULL)
4524 g_object_unref (folder_store);
4530 modest_ui_actions_on_select_all (GtkAction *action,
4531 ModestWindow *window)
4533 GtkWidget *focused_widget;
4535 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4536 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
4537 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
4538 } else if (GTK_IS_LABEL (focused_widget)) {
4539 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
4540 } else if (GTK_IS_EDITABLE (focused_widget)) {
4541 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
4542 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4543 GtkTextBuffer *buffer;
4544 GtkTextIter start, end;
4546 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4547 gtk_text_buffer_get_start_iter (buffer, &start);
4548 gtk_text_buffer_get_end_iter (buffer, &end);
4549 gtk_text_buffer_select_range (buffer, &start, &end);
4550 } else if (GTK_IS_HTML (focused_widget)) {
4551 gtk_html_select_all (GTK_HTML (focused_widget));
4552 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4553 GtkWidget *header_view = focused_widget;
4554 GtkTreeSelection *selection = NULL;
4556 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
4557 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
4558 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4561 /* Disable window dimming management */
4562 modest_window_disable_dimming (MODEST_WINDOW(window));
4564 /* Select all messages */
4565 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
4566 gtk_tree_selection_select_all (selection);
4568 /* Set focuse on header view */
4569 gtk_widget_grab_focus (header_view);
4571 /* Enable window dimming management */
4572 modest_window_enable_dimming (MODEST_WINDOW(window));
4573 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
4574 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
4580 modest_ui_actions_on_mark_as_read (GtkAction *action,
4581 ModestWindow *window)
4583 g_return_if_fail (MODEST_IS_WINDOW(window));
4585 /* Mark each header as read */
4586 do_headers_action (window, headers_action_mark_as_read, NULL);
4590 modest_ui_actions_on_mark_as_unread (GtkAction *action,
4591 ModestWindow *window)
4593 g_return_if_fail (MODEST_IS_WINDOW(window));
4595 /* Mark each header as read */
4596 do_headers_action (window, headers_action_mark_as_unread, NULL);
4600 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
4601 GtkRadioAction *selected,
4602 ModestWindow *window)
4606 value = gtk_radio_action_get_current_value (selected);
4607 if (MODEST_IS_WINDOW (window)) {
4608 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
4613 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
4614 GtkRadioAction *selected,
4615 ModestWindow *window)
4617 TnyHeaderFlags flags;
4618 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4620 flags = gtk_radio_action_get_current_value (selected);
4621 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
4625 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
4626 GtkRadioAction *selected,
4627 ModestWindow *window)
4631 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4633 file_format = gtk_radio_action_get_current_value (selected);
4634 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
4639 modest_ui_actions_on_zoom_plus (GtkAction *action,
4640 ModestWindow *window)
4642 g_return_if_fail (MODEST_IS_WINDOW (window));
4644 modest_window_zoom_plus (MODEST_WINDOW (window));
4648 modest_ui_actions_on_zoom_minus (GtkAction *action,
4649 ModestWindow *window)
4651 g_return_if_fail (MODEST_IS_WINDOW (window));
4653 modest_window_zoom_minus (MODEST_WINDOW (window));
4657 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
4658 ModestWindow *window)
4660 ModestWindowMgr *mgr;
4661 gboolean fullscreen, active;
4662 g_return_if_fail (MODEST_IS_WINDOW (window));
4664 mgr = modest_runtime_get_window_mgr ();
4666 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
4667 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4669 if (active != fullscreen) {
4670 modest_window_mgr_set_fullscreen_mode (mgr, active);
4671 #ifndef MODEST_TOOLKIT_HILDON2
4672 gtk_window_present (GTK_WINDOW (window));
4678 modest_ui_actions_on_change_fullscreen (GtkAction *action,
4679 ModestWindow *window)
4681 ModestWindowMgr *mgr;
4682 gboolean fullscreen;
4684 g_return_if_fail (MODEST_IS_WINDOW (window));
4686 mgr = modest_runtime_get_window_mgr ();
4687 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4688 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
4690 #ifndef MODEST_TOOLKIT_HILDON2
4691 gtk_window_present (GTK_WINDOW (window));
4696 * Used by modest_ui_actions_on_details to call do_headers_action
4699 headers_action_show_details (TnyHeader *header,
4700 ModestWindow *window,
4704 gboolean async_retrieval;
4707 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4708 async_retrieval = TRUE;
4709 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (window));
4711 async_retrieval = FALSE;
4713 modest_platform_run_header_details_dialog (GTK_WINDOW (window), header, async_retrieval, msg);
4715 g_object_unref (msg);
4719 * Show the header details in a ModestDetailsDialog widget
4722 modest_ui_actions_on_details (GtkAction *action,
4725 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4729 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
4733 header = tny_msg_get_header (msg);
4735 headers_action_show_details (header, win, NULL);
4736 g_object_unref (header);
4738 g_object_unref (msg);
4740 } else if (MODEST_IS_MAIN_WINDOW (win)) {
4741 GtkWidget *folder_view, *header_view;
4743 /* Check which widget has the focus */
4744 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4745 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4746 if (gtk_widget_is_focus (folder_view)) {
4747 TnyFolderStore *folder_store
4748 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4749 if (!folder_store) {
4750 g_warning ("%s: No item was selected.\n", __FUNCTION__);
4753 /* Show only when it's a folder */
4754 /* This function should not be called for account items,
4755 * because we dim the menu item for them. */
4756 if (TNY_IS_FOLDER (folder_store)) {
4757 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4758 TNY_FOLDER (folder_store));
4761 g_object_unref (folder_store);
4764 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4765 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4766 /* Show details of each header */
4767 do_headers_action (win, headers_action_show_details, header_view);
4769 #ifdef MODEST_TOOLKIT_HILDON2
4770 } else if (MODEST_IS_HEADER_WINDOW (win)) {
4772 GtkWidget *header_view;
4774 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
4775 folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
4777 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4779 g_object_unref (folder);
4786 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
4787 ModestMsgEditWindow *window)
4789 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4791 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
4795 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
4796 ModestMsgEditWindow *window)
4798 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4800 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
4804 modest_ui_actions_toggle_folders_view (GtkAction *action,
4805 ModestMainWindow *main_window)
4807 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
4809 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
4810 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
4812 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
4816 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
4817 ModestWindow *window)
4819 gboolean active, fullscreen = FALSE;
4820 ModestWindowMgr *mgr;
4822 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
4824 /* Check if we want to toggle the toolbar view in fullscreen
4826 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
4827 "ViewShowToolbarFullScreen")) {
4831 /* Toggle toolbar */
4832 mgr = modest_runtime_get_window_mgr ();
4833 modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
4837 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
4838 ModestMsgEditWindow *window)
4840 modest_msg_edit_window_select_font (window);
4845 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
4846 const gchar *display_name,
4849 /* don't update the display name if it was already set;
4850 * updating the display name apparently is expensive */
4851 const gchar* old_name = gtk_window_get_title (window);
4853 if (display_name == NULL)
4856 if (old_name && display_name && strcmp (old_name, display_name) == 0)
4857 return; /* don't do anything */
4859 /* This is usually used to change the title of the main window, which
4860 * is the one that holds the folder view. Note that this change can
4861 * happen even when the widget doesn't have the focus. */
4862 gtk_window_set_title (window, display_name);
4867 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
4869 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4870 modest_msg_edit_window_select_contacts (window);
4874 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
4876 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4877 modest_msg_edit_window_check_names (window, FALSE);
4880 #ifndef MODEST_TOOLKIT_HILDON2
4882 * This function is used to track changes in the selection of the
4883 * folder view that is inside the "move to" dialog to enable/disable
4884 * the OK button because we do not want the user to select a disallowed
4885 * destination for a folder.
4886 * The user also not desired to be able to use NEW button on items where
4887 * folder creation is not possibel.
4890 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
4891 TnyFolderStore *folder_store,
4895 GtkWidget *dialog = NULL;
4896 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
4897 gboolean moving_folder = FALSE;
4898 gboolean is_local_account = TRUE;
4899 GtkWidget *folder_view = NULL;
4900 ModestTnyFolderRules rules;
4902 g_return_if_fail (MODEST_IS_FOLDER_VIEW(self));
4907 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
4911 /* check if folder_store is an remote account */
4912 if (TNY_IS_ACCOUNT (folder_store)) {
4913 TnyAccount *local_account = NULL;
4914 TnyAccount *mmc_account = NULL;
4915 ModestTnyAccountStore *account_store = NULL;
4917 account_store = modest_runtime_get_account_store ();
4918 local_account = modest_tny_account_store_get_local_folders_account (account_store);
4919 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
4921 if ((gpointer) local_account != (gpointer) folder_store &&
4922 (gpointer) mmc_account != (gpointer) folder_store) {
4923 ModestProtocolType proto;
4924 proto = modest_tny_account_get_protocol_type (TNY_ACCOUNT (folder_store));
4925 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
4926 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
4928 is_local_account = FALSE;
4929 /* New button should be dimmed on remote
4931 new_sensitive = (modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
4933 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS));
4935 g_object_unref (local_account);
4937 /* It could not exist */
4939 g_object_unref (mmc_account);
4942 /* Check the target folder rules */
4943 if (TNY_IS_FOLDER (folder_store)) {
4944 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
4945 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
4946 ok_sensitive = FALSE;
4947 new_sensitive = FALSE;
4952 /* Check if we're moving a folder */
4953 if (MODEST_IS_MAIN_WINDOW (user_data)) {
4954 /* Get the widgets */
4955 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
4956 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4957 if (gtk_widget_is_focus (folder_view))
4958 moving_folder = TRUE;
4961 if (moving_folder) {
4962 TnyFolderStore *moved_folder = NULL, *parent = NULL;
4964 /* Get the folder to move */
4965 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4967 /* Check that we're not moving to the same folder */
4968 if (TNY_IS_FOLDER (moved_folder)) {
4969 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
4970 if (parent == folder_store)
4971 ok_sensitive = FALSE;
4972 g_object_unref (parent);
4975 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
4976 /* Do not allow to move to an account unless it's the
4977 local folders account */
4978 if (!is_local_account)
4979 ok_sensitive = FALSE;
4982 if (ok_sensitive && (moved_folder == folder_store)) {
4983 /* Do not allow to move to itself */
4984 ok_sensitive = FALSE;
4986 g_object_unref (moved_folder);
4988 TnyFolder *src_folder = NULL;
4990 /* Moving a message */
4991 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
4993 TnyHeader *header = NULL;
4994 header = modest_msg_view_window_get_header
4995 (MODEST_MSG_VIEW_WINDOW (user_data));
4996 if (!TNY_IS_HEADER(header))
4997 g_warning ("%s: could not get source header", __FUNCTION__);
4999 src_folder = tny_header_get_folder (header);
5002 g_object_unref (header);
5005 TNY_FOLDER (modest_folder_view_get_selected
5006 (MODEST_FOLDER_VIEW (folder_view)));
5009 if (TNY_IS_FOLDER(src_folder)) {
5010 /* Do not allow to move the msg to the same folder */
5011 /* Do not allow to move the msg to an account */
5012 if ((gpointer) src_folder == (gpointer) folder_store ||
5013 TNY_IS_ACCOUNT (folder_store))
5014 ok_sensitive = FALSE;
5015 g_object_unref (src_folder);
5017 g_warning ("%s: could not get source folder", __FUNCTION__);
5021 /* Set sensitivity of the OK and NEW button */
5022 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, ok_sensitive);
5023 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_GTK_RESPONSE_NEW_FOLDER, new_sensitive);
5028 on_move_to_dialog_response (GtkDialog *dialog,
5032 GtkWidget *parent_win;
5033 MoveToInfo *helper = NULL;
5034 ModestFolderView *folder_view;
5036 helper = (MoveToInfo *) user_data;
5038 parent_win = (GtkWidget *) helper->win;
5039 folder_view = MODEST_FOLDER_VIEW (g_object_get_data (G_OBJECT (dialog),
5040 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
5043 TnyFolderStore *dst_folder;
5044 TnyFolderStore *selected;
5046 case MODEST_GTK_RESPONSE_NEW_FOLDER:
5047 selected = modest_folder_view_get_selected (folder_view);
5048 modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view), selected);
5049 g_object_unref (selected);
5051 case GTK_RESPONSE_NONE:
5052 case GTK_RESPONSE_CANCEL:
5053 case GTK_RESPONSE_DELETE_EVENT:
5055 case GTK_RESPONSE_OK:
5056 dst_folder = modest_folder_view_get_selected (folder_view);
5058 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
5059 /* Clean list to move used for filtering */
5060 modest_folder_view_set_list_to_move (folder_view, NULL);
5062 modest_ui_actions_on_main_window_move_to (NULL,
5063 GTK_WIDGET (folder_view),
5065 MODEST_MAIN_WINDOW (parent_win));
5066 #ifdef MODEST_TOOLKIT_HILDON2
5067 } else if (MODEST_IS_FOLDER_WINDOW (parent_win)) {
5068 /* Clean list to move used for filtering */
5069 modest_folder_view_set_list_to_move (folder_view, NULL);
5071 modest_ui_actions_on_folder_window_move_to (GTK_WIDGET (folder_view),
5074 GTK_WINDOW (parent_win));
5077 /* if the user selected a root folder
5078 (account) then do not perform any action */
5079 if (TNY_IS_ACCOUNT (dst_folder)) {
5080 g_signal_stop_emission_by_name (dialog, "response");
5084 /* Clean list to move used for filtering */
5085 modest_folder_view_set_list_to_move (folder_view, NULL);
5087 /* Moving from headers window in edit mode */
5088 modest_ui_actions_on_window_move_to (NULL, helper->list,
5090 MODEST_WINDOW (parent_win));
5094 g_object_unref (dst_folder);
5098 g_warning ("%s unexpected response id %d", __FUNCTION__, response);
5101 /* Free the helper and exit */
5103 g_object_unref (helper->list);
5104 g_slice_free (MoveToInfo, helper);
5105 gtk_widget_destroy (GTK_WIDGET (dialog));
5109 create_move_to_dialog (GtkWindow *win,
5110 GtkWidget *folder_view,
5111 TnyList *list_to_move)
5113 GtkWidget *dialog, *tree_view = NULL;
5115 dialog = modest_platform_create_move_to_dialog (win, &tree_view);
5117 #ifndef MODEST_TOOLKIT_HILDON2
5118 /* Track changes in the selection to
5119 * disable the OK button whenever "Move to" is not possible
5120 * disbale NEW button whenever New is not possible */
5121 g_signal_connect (tree_view,
5122 "folder_selection_changed",
5123 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
5127 /* It could happen that we're trying to move a message from a
5128 window (msg window for example) after the main window was
5129 closed, so we can not just get the model of the folder
5131 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
5132 const gchar *visible_id = NULL;
5134 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5135 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5136 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
5137 MODEST_FOLDER_VIEW(tree_view));
5140 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
5142 /* Show the same account than the one that is shown in the main window */
5143 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(tree_view),
5146 const gchar *active_account_name = NULL;
5147 ModestAccountMgr *mgr = NULL;
5148 ModestAccountSettings *settings = NULL;
5149 ModestServerAccountSettings *store_settings = NULL;
5151 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5152 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5153 modest_folder_view_update_model (MODEST_FOLDER_VIEW (tree_view),
5154 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
5156 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
5157 mgr = modest_runtime_get_account_mgr ();
5158 settings = modest_account_mgr_load_account_settings (mgr, active_account_name);
5161 const gchar *store_account_name;
5162 store_settings = modest_account_settings_get_store_settings (settings);
5163 store_account_name = modest_server_account_settings_get_account_name (store_settings);
5165 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (tree_view),
5166 store_account_name);
5167 g_object_unref (store_settings);
5168 g_object_unref (settings);
5172 /* we keep a pointer to the embedded folder view, so we can
5173 * retrieve it with get_folder_view_from_move_to_dialog (see
5174 * above) later (needed for focus handling)
5176 g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, tree_view);
5178 /* Hide special folders */
5179 #ifndef MODEST_TOOLKIT_HILDON2
5180 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
5183 modest_folder_view_set_list_to_move (MODEST_FOLDER_VIEW (tree_view), list_to_move);
5184 #ifndef MODEST_TOOLKIT_HILDON2
5185 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
5188 gtk_widget_show (GTK_WIDGET (tree_view));
5194 * Shows a confirmation dialog to the user when we're moving messages
5195 * from a remote server to the local storage. Returns the dialog
5196 * response. If it's other kind of movement then it always returns
5199 * This one is used by the next functions:
5200 * modest_ui_actions_on_paste - commented out
5201 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
5204 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
5205 TnyFolder *dest_folder,
5209 gint response = GTK_RESPONSE_OK;
5210 TnyAccount *account = NULL;
5211 TnyFolder *src_folder = NULL;
5212 TnyIterator *iter = NULL;
5213 TnyHeader *header = NULL;
5215 /* return with OK if the destination is a remote folder */
5216 if (modest_tny_folder_is_remote_folder (dest_folder))
5217 return GTK_RESPONSE_OK;
5219 /* Get source folder */
5220 iter = tny_list_create_iterator (headers);
5221 header = TNY_HEADER (tny_iterator_get_current (iter));
5223 src_folder = tny_header_get_folder (header);
5224 g_object_unref (header);
5226 g_object_unref (iter);
5228 /* if no src_folder, message may be an attahcment */
5229 if (src_folder == NULL)
5230 return GTK_RESPONSE_CANCEL;
5232 /* If the source is a local or MMC folder */
5233 if (!modest_tny_folder_is_remote_folder (src_folder)) {
5234 g_object_unref (src_folder);
5235 return GTK_RESPONSE_OK;
5238 /* Get the account */
5239 account = tny_folder_get_account (src_folder);
5241 /* now if offline we ask the user */
5242 if(connect_to_get_msg (win, tny_list_get_length (headers), account))
5243 response = GTK_RESPONSE_OK;
5245 response = GTK_RESPONSE_CANCEL;
5248 g_object_unref (src_folder);
5249 g_object_unref (account);
5255 move_to_helper_destroyer (gpointer user_data)
5257 MoveToHelper *helper = (MoveToHelper *) user_data;
5259 /* Close the "Pasting" information banner */
5260 if (helper->banner) {
5261 gtk_widget_destroy (GTK_WIDGET (helper->banner));
5262 g_object_unref (helper->banner);
5264 if (gtk_tree_row_reference_valid (helper->reference)) {
5265 gtk_tree_row_reference_free (helper->reference);
5266 helper->reference = NULL;
5272 move_to_cb (ModestMailOperation *mail_op,
5275 MoveToHelper *helper = (MoveToHelper *) user_data;
5276 GObject *object = modest_mail_operation_get_source (mail_op);
5278 /* Note that the operation could have failed, in that case do
5280 if (modest_mail_operation_get_status (mail_op) !=
5281 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
5284 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
5285 ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
5287 if (!modest_msg_view_window_select_next_message (self) &&
5288 !modest_msg_view_window_select_previous_message (self)) {
5289 /* No more messages to view, so close this window */
5290 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
5292 } else if (MODEST_IS_MAIN_WINDOW (object) &&
5293 gtk_tree_row_reference_valid (helper->reference)) {
5294 GtkWidget *header_view;
5296 GtkTreeSelection *sel;
5298 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5299 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5300 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
5301 path = gtk_tree_row_reference_get_path (helper->reference);
5302 /* We need to unselect the previous one
5303 because we could be copying instead of
5305 gtk_tree_selection_unselect_all (sel);
5306 gtk_tree_selection_select_path (sel, path);
5307 gtk_tree_path_free (path);
5309 g_object_unref (object);
5312 /* Destroy the helper */
5313 move_to_helper_destroyer (helper);
5317 folder_move_to_cb (ModestMailOperation *mail_op,
5318 TnyFolder *new_folder,
5321 GtkWidget *folder_view;
5324 object = modest_mail_operation_get_source (mail_op);
5325 if (MODEST_IS_MAIN_WINDOW (object)) {
5326 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5327 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5328 g_object_ref (folder_view);
5329 g_object_unref (object);
5330 move_to_cb (mail_op, user_data);
5331 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), new_folder, FALSE);
5332 g_object_unref (folder_view);
5334 move_to_cb (mail_op, user_data);
5339 msgs_move_to_cb (ModestMailOperation *mail_op,
5342 move_to_cb (mail_op, user_data);
5346 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
5349 GObject *win = NULL;
5351 #ifndef MODEST_TOOLKIT_HILDON2
5352 ModestWindow *main_window = NULL;
5354 /* Disable next automatic folder selection */
5355 main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
5356 FALSE); /* don't create */
5358 GtkWidget *folder_view = NULL;
5360 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
5361 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5362 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
5364 if (user_data && TNY_IS_FOLDER (user_data)) {
5365 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
5366 TNY_FOLDER (user_data), FALSE);
5370 /* Show notification dialog only if the main window exists */
5371 win = modest_mail_operation_get_source (mail_op);
5372 modest_platform_run_information_dialog ((GtkWindow *) win,
5373 _("mail_in_ui_folder_move_target_error"),
5376 g_object_unref (win);
5380 open_msg_for_purge_cb (ModestMailOperation *mail_op,
5389 gint pending_purges = 0;
5390 gboolean some_purged = FALSE;
5391 ModestWindow *win = MODEST_WINDOW (user_data);
5392 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
5394 /* If there was any error */
5395 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
5396 modest_window_mgr_unregister_header (mgr, header);
5400 /* Once the message has been retrieved for purging, we check if
5401 * it's all ok for purging */
5403 parts = tny_simple_list_new ();
5404 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
5405 iter = tny_list_create_iterator (parts);
5407 while (!tny_iterator_is_done (iter)) {
5409 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5410 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
5411 if (tny_mime_part_is_purged (part))
5418 g_object_unref (part);
5420 tny_iterator_next (iter);
5422 g_object_unref (iter);
5425 if (pending_purges>0) {
5427 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
5429 if (response == GTK_RESPONSE_OK) {
5432 modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_me_inbox_remove_attachments"));
5433 iter = tny_list_create_iterator (parts);
5434 while (!tny_iterator_is_done (iter)) {
5437 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5438 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
5439 tny_mime_part_set_purged (part);
5442 g_object_unref (part);
5444 tny_iterator_next (iter);
5446 g_object_unref (iter);
5448 tny_msg_rewrite_cache (msg);
5450 gtk_widget_destroy (info);
5454 modest_window_mgr_unregister_header (mgr, header);
5456 g_object_unref (parts);
5460 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
5461 ModestMainWindow *win)
5463 GtkWidget *header_view;
5464 TnyList *header_list;
5466 TnyHeaderFlags flags;
5467 ModestWindow *msg_view_window = NULL;
5470 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5472 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
5473 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5475 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
5477 g_warning ("%s: no header selected", __FUNCTION__);
5481 if (tny_list_get_length (header_list) == 1) {
5482 TnyIterator *iter = tny_list_create_iterator (header_list);
5483 header = TNY_HEADER (tny_iterator_get_current (iter));
5484 g_object_unref (iter);
5488 if (!header || !TNY_IS_HEADER(header)) {
5489 g_warning ("%s: header is not valid", __FUNCTION__);
5493 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
5494 header, &msg_view_window);
5495 flags = tny_header_get_flags (header);
5496 if (!(flags & TNY_HEADER_FLAG_CACHED))
5499 if (msg_view_window != NULL)
5500 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
5502 /* do nothing; uid was registered before, so window is probably on it's way */
5503 g_warning ("debug: header %p has already been registered", header);
5506 ModestMailOperation *mail_op = NULL;
5507 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
5508 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
5509 modest_ui_actions_disk_operations_error_handler,
5511 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
5512 modest_mail_operation_get_msg (mail_op, header, FALSE, open_msg_for_purge_cb, win);
5514 g_object_unref (mail_op);
5517 g_object_unref (header);
5519 g_object_unref (header_list);
5523 * Checks if we need a connection to do the transfer and if the user
5524 * wants to connect to complete it
5527 modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
5528 TnyFolderStore *src_folder,
5530 TnyFolder *dst_folder,
5531 gboolean delete_originals,
5532 gboolean *need_connection,
5535 TnyAccount *src_account;
5536 gint uncached_msgs = 0;
5538 /* We don't need any further check if
5540 * 1- the source folder is local OR
5541 * 2- the device is already online
5543 if (!modest_tny_folder_store_is_remote (src_folder) ||
5544 tny_device_is_online (modest_runtime_get_device())) {
5545 *need_connection = FALSE;
5550 /* We must ask for a connection when
5552 * - the message(s) is not already cached OR
5553 * - the message(s) is cached but the leave_on_server setting
5554 * is FALSE (because we need to sync the source folder to
5555 * delete the message from the server (for IMAP we could do it
5556 * offline, it'll take place the next time we get a
5559 uncached_msgs = header_list_count_uncached_msgs (headers);
5560 src_account = get_account_from_folder_store (src_folder);
5561 if (uncached_msgs > 0) {
5565 *need_connection = TRUE;
5566 num_headers = tny_list_get_length (headers);
5567 msg = ngettext ("mcen_nc_get_msg", "mcen_nc_get_msgs", num_headers);
5569 if (modest_platform_run_confirmation_dialog (parent_window, msg) ==
5570 GTK_RESPONSE_CANCEL) {
5576 /* The transfer is possible and the user wants to */
5579 if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
5580 const gchar *account_name;
5581 gboolean leave_on_server;
5583 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
5584 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
5587 if (leave_on_server == TRUE) {
5588 *need_connection = FALSE;
5590 *need_connection = TRUE;
5593 *need_connection = FALSE;
5598 g_object_unref (src_account);
5602 xfer_messages_error_handler (ModestMailOperation *mail_op,
5606 const GError *error;
5608 win = modest_mail_operation_get_source (mail_op);
5609 error = modest_mail_operation_get_error (mail_op);
5611 if (error && is_memory_full_error ((GError *) error, mail_op)) {
5612 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
5613 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
5616 modest_platform_run_information_dialog ((GtkWindow *) win,
5617 _("mail_in_ui_folder_move_target_error"),
5621 g_object_unref (win);
5625 TnyFolderStore *dst_folder;
5630 * Utility function that transfer messages from both the main window
5631 * and the msg view window when using the "Move to" dialog
5634 xfer_messages_performer (gboolean canceled,
5636 GtkWindow *parent_window,
5637 TnyAccount *account,
5640 ModestWindow *win = MODEST_WINDOW (parent_window);
5641 TnyAccount *dst_account = NULL;
5642 gboolean dst_forbids_message_add = FALSE;
5643 XferMsgsHelper *helper;
5644 MoveToHelper *movehelper;
5645 ModestMailOperation *mail_op;
5647 helper = (XferMsgsHelper *) user_data;
5649 if (canceled || err) {
5650 if (!check_memory_full_error ((GtkWidget *) parent_window, err)) {
5651 /* Show the proper error message */
5652 modest_ui_actions_on_account_connection_error (parent_window, account);
5657 dst_account = tny_folder_get_account (TNY_FOLDER (helper->dst_folder));
5659 /* tinymail will return NULL for local folders it seems */
5660 dst_forbids_message_add = modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
5661 modest_tny_account_get_protocol_type (dst_account),
5662 MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
5663 g_object_unref (dst_account);
5665 if (dst_forbids_message_add) {
5666 modest_platform_information_banner (GTK_WIDGET (win),
5668 ngettext("mail_in_ui_folder_move_target_error",
5669 "mail_in_ui_folder_move_targets_error",
5670 tny_list_get_length (helper->headers)));
5674 movehelper = g_new0 (MoveToHelper, 1);
5676 #ifndef MODEST_TOOLKIT_HILDON2
5677 movehelper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
5678 _CS("ckct_nw_pasting"));
5679 if (movehelper->banner != NULL) {
5680 g_object_ref (movehelper->banner);
5681 gtk_widget_show (GTK_WIDGET (movehelper->banner));
5685 if (MODEST_IS_MAIN_WINDOW (win)) {
5686 GtkWidget *header_view =
5687 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
5688 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5689 movehelper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
5692 /* Perform the mail operation */
5693 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(win),
5694 xfer_messages_error_handler,
5696 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5699 modest_mail_operation_xfer_msgs (mail_op,
5701 TNY_FOLDER (helper->dst_folder),
5706 g_object_unref (G_OBJECT (mail_op));
5708 g_object_unref (helper->dst_folder);
5709 g_object_unref (helper->headers);
5710 g_slice_free (XferMsgsHelper, helper);
5714 TnyFolder *src_folder;
5715 TnyFolderStore *dst_folder;
5716 gboolean delete_original;
5717 GtkWidget *folder_view;
5721 on_move_folder_cb (gboolean canceled, GError *err, GtkWindow *parent_window,
5722 TnyAccount *account, gpointer user_data)
5724 MoveFolderInfo *info = (MoveFolderInfo*)user_data;
5725 GtkTreeSelection *sel;
5726 ModestMailOperation *mail_op = NULL;
5728 if (canceled || err || !MODEST_IS_WINDOW (parent_window)) {
5729 g_object_unref (G_OBJECT (info->src_folder));
5730 g_object_unref (G_OBJECT (info->dst_folder));
5735 MoveToHelper *helper = g_new0 (MoveToHelper, 1);
5736 #ifndef MODEST_TOOLKIT_HILDON2
5737 helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
5738 _CS("ckct_nw_pasting"));
5739 if (helper->banner != NULL) {
5740 g_object_ref (helper->banner);
5741 gtk_widget_show (GTK_WIDGET(helper->banner));
5744 /* Clean folder on header view before moving it */
5745 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
5746 gtk_tree_selection_unselect_all (sel);
5748 /* Let gtk events run. We need that the folder
5749 view frees its reference to the source
5750 folder *before* issuing the mail operation
5751 so we need the signal handler of selection
5752 changed to happen before the mail
5754 while (gtk_events_pending ())
5755 gtk_main_iteration (); */
5758 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
5759 modest_ui_actions_move_folder_error_handler,
5760 info->src_folder, NULL);
5761 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5764 /* Select *after* the changes */
5765 /* TODO: this function hangs UI after transfer */
5766 /* modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view), */
5767 /* TNY_FOLDER (src_folder), TRUE); */
5769 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
5770 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
5771 TNY_FOLDER (info->dst_folder), TRUE);
5773 modest_mail_operation_xfer_folder (mail_op,
5774 TNY_FOLDER (info->src_folder),
5776 info->delete_original,
5779 g_object_unref (G_OBJECT (info->src_folder));
5781 /* if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) { */
5784 /* Unref mail operation */
5785 g_object_unref (G_OBJECT (mail_op));
5786 g_object_unref (G_OBJECT (info->dst_folder));
5791 get_account_from_folder_store (TnyFolderStore *folder_store)
5793 if (TNY_IS_ACCOUNT (folder_store))
5794 return g_object_ref (folder_store);
5796 return tny_folder_get_account (TNY_FOLDER (folder_store));
5800 * UI handler for the "Move to" action when invoked from the
5804 modest_ui_actions_on_main_window_move_to (GtkAction *action,
5805 GtkWidget *folder_view,
5806 TnyFolderStore *dst_folder,
5807 ModestMainWindow *win)
5809 ModestHeaderView *header_view = NULL;
5810 TnyFolderStore *src_folder = NULL;
5812 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5814 /* Get the source folder */
5815 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5817 /* Get header view */
5818 header_view = (ModestHeaderView *)
5819 modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5821 /* Get folder or messages to transfer */
5822 if (gtk_widget_is_focus (folder_view)) {
5823 gboolean do_xfer = TRUE;
5825 /* Allow only to transfer folders to the local root folder */
5826 if (TNY_IS_ACCOUNT (dst_folder) &&
5827 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5828 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5830 } else if (!TNY_IS_FOLDER (src_folder)) {
5831 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5836 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5837 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5839 info->src_folder = g_object_ref (src_folder);
5840 info->dst_folder = g_object_ref (dst_folder);
5841 info->delete_original = TRUE;
5842 info->folder_view = folder_view;
5844 connect_info->callback = on_move_folder_cb;
5845 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5846 connect_info->data = info;
5848 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5849 TNY_FOLDER_STORE (src_folder),
5852 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
5855 headers = modest_header_view_get_selected_headers(header_view);
5857 /* Transfer the messages */
5858 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
5859 headers, TNY_FOLDER (dst_folder));
5861 g_object_unref (headers);
5865 g_object_unref (src_folder);
5868 #ifdef MODEST_TOOLKIT_HILDON2
5870 * UI handler for the "Move to" action when invoked from the
5871 * ModestFolderWindow
5874 modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
5875 TnyFolderStore *dst_folder,
5879 TnyFolderStore *src_folder = NULL;
5880 TnyIterator *iterator;
5882 if (tny_list_get_length (selection) != 1)
5885 iterator = tny_list_create_iterator (selection);
5886 src_folder = TNY_FOLDER_STORE (tny_iterator_get_current (iterator));
5887 g_object_unref (iterator);
5890 gboolean do_xfer = TRUE;
5892 /* Allow only to transfer folders to the local root folder */
5893 if (TNY_IS_ACCOUNT (dst_folder) &&
5894 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5895 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5898 modest_platform_run_information_dialog (win,
5899 _("mail_in_ui_folder_move_target_error"),
5901 } else if (!TNY_IS_FOLDER (src_folder)) {
5902 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5907 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5908 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5910 info->src_folder = g_object_ref (src_folder);
5911 info->dst_folder = g_object_ref (dst_folder);
5912 info->delete_original = TRUE;
5913 info->folder_view = folder_view;
5915 connect_info->callback = on_move_folder_cb;
5916 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5917 connect_info->data = info;
5919 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5920 TNY_FOLDER_STORE (src_folder),
5925 g_object_unref (src_folder);
5931 modest_ui_actions_transfer_messages_helper (GtkWindow *win,
5932 TnyFolder *src_folder,
5934 TnyFolder *dst_folder)
5936 gboolean need_connection = TRUE;
5937 gboolean do_xfer = TRUE;
5938 XferMsgsHelper *helper;
5940 g_return_if_fail (TNY_IS_FOLDER (src_folder));
5941 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
5942 g_return_if_fail (TNY_IS_LIST (headers));
5944 modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
5945 headers, TNY_FOLDER (dst_folder),
5946 TRUE, &need_connection,
5949 /* If we don't want to transfer just return */
5953 /* Create the helper */
5954 helper = g_slice_new (XferMsgsHelper);
5955 helper->dst_folder = g_object_ref (dst_folder);
5956 helper->headers = g_object_ref (headers);
5958 if (need_connection) {
5959 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5960 connect_info->callback = xfer_messages_performer;
5961 connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
5962 connect_info->data = helper;
5964 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5965 TNY_FOLDER_STORE (src_folder),
5968 TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
5969 xfer_messages_performer (FALSE, NULL, GTK_WINDOW (win),
5970 src_account, helper);
5971 g_object_unref (src_account);
5976 * UI handler for the "Move to" action when invoked from the
5977 * ModestMsgViewWindow
5980 modest_ui_actions_on_window_move_to (GtkAction *action,
5982 TnyFolderStore *dst_folder,
5985 TnyFolder *src_folder = NULL;
5987 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
5990 TnyHeader *header = NULL;
5993 iter = tny_list_create_iterator (headers);
5994 header = (TnyHeader *) tny_iterator_get_current (iter);
5995 src_folder = tny_header_get_folder (header);
5997 /* Transfer the messages */
5998 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
6000 TNY_FOLDER (dst_folder));
6003 g_object_unref (header);
6004 g_object_unref (iter);
6005 g_object_unref (src_folder);
6010 modest_ui_actions_on_move_to (GtkAction *action,
6013 modest_ui_actions_on_edit_mode_move_to (win);
6017 modest_ui_actions_on_edit_mode_move_to (ModestWindow *win)
6019 GtkWidget *dialog = NULL;
6020 MoveToInfo *helper = NULL;
6021 TnyList *list_to_move;
6023 g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
6025 #ifndef MODEST_TOOLKIT_HILDON2
6026 /* Get the main window if exists */
6027 ModestMainWindow *main_window;
6028 if (MODEST_IS_MAIN_WINDOW (win))
6029 main_window = MODEST_MAIN_WINDOW (win);
6032 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
6033 FALSE)); /* don't create */
6036 list_to_move = modest_platform_get_list_to_move (MODEST_WINDOW (win));
6041 if (tny_list_get_length (list_to_move) < 1) {
6042 g_object_unref (list_to_move);
6046 /* Create and run the dialog */
6047 dialog = create_move_to_dialog (GTK_WINDOW (win), NULL, list_to_move);
6048 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
6049 GTK_WINDOW (dialog),
6053 helper = g_slice_new0 (MoveToInfo);
6054 helper->list = list_to_move;
6057 /* Listen to response signal */
6058 g_signal_connect (dialog, "response", G_CALLBACK (on_move_to_dialog_response), helper);
6060 /* Show the dialog */
6061 gtk_widget_show (dialog);
6067 * Calls #HeadersFunc for each header already selected in the main
6068 * window or the message currently being shown in the msg view window
6071 do_headers_action (ModestWindow *win,
6075 TnyList *headers_list = NULL;
6076 TnyIterator *iter = NULL;
6077 TnyHeader *header = NULL;
6078 TnyFolder *folder = NULL;
6081 headers_list = get_selected_headers (win);
6085 /* Get the folder */
6086 iter = tny_list_create_iterator (headers_list);
6087 header = TNY_HEADER (tny_iterator_get_current (iter));
6089 folder = tny_header_get_folder (header);
6090 g_object_unref (header);
6093 /* Call the function for each header */
6094 while (!tny_iterator_is_done (iter)) {
6095 header = TNY_HEADER (tny_iterator_get_current (iter));
6096 func (header, win, user_data);
6097 g_object_unref (header);
6098 tny_iterator_next (iter);
6101 /* Trick: do a poke status in order to speed up the signaling
6104 tny_folder_poke_status (folder);
6105 g_object_unref (folder);
6109 g_object_unref (iter);
6110 g_object_unref (headers_list);
6114 modest_ui_actions_view_attachment (GtkAction *action,
6115 ModestWindow *window)
6117 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6118 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
6120 /* not supported window for this action */
6121 g_return_if_reached ();
6126 modest_ui_actions_save_attachments (GtkAction *action,
6127 ModestWindow *window)
6129 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6131 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
6134 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
6136 /* not supported window for this action */
6137 g_return_if_reached ();
6142 modest_ui_actions_remove_attachments (GtkAction *action,
6143 ModestWindow *window)
6145 if (MODEST_IS_MAIN_WINDOW (window)) {
6146 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
6147 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6148 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
6150 /* not supported window for this action */
6151 g_return_if_reached ();
6156 modest_ui_actions_on_settings (GtkAction *action,
6161 dialog = modest_platform_get_global_settings_dialog ();
6162 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
6163 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
6164 gtk_widget_show_all (dialog);
6166 gtk_dialog_run (GTK_DIALOG (dialog));
6168 gtk_widget_destroy (dialog);
6172 modest_ui_actions_on_help (GtkAction *action,
6175 /* Help app is not available at all in fremantle */
6176 #ifndef MODEST_TOOLKIT_HILDON2
6177 const gchar *help_id;
6179 g_return_if_fail (win && GTK_IS_WINDOW(win));
6181 help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
6184 modest_platform_show_help (GTK_WINDOW (win), help_id);
6189 modest_ui_actions_on_csm_help (GtkAction *action,
6192 /* Help app is not available at all in fremantle */
6193 #ifndef MODEST_TOOLKIT_HILDON2
6195 const gchar* help_id = NULL;
6196 GtkWidget *folder_view;
6197 TnyFolderStore *folder_store;
6199 g_return_if_fail (win && MODEST_IS_MAIN_WINDOW (win));
6201 /* Get selected folder */
6202 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
6203 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6204 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6206 /* Switch help_id */
6207 if (folder_store && TNY_IS_FOLDER (folder_store))
6208 help_id = modest_tny_folder_get_help_id (TNY_FOLDER (folder_store));
6211 g_object_unref (folder_store);
6214 modest_platform_show_help (GTK_WINDOW (win), help_id);
6216 modest_ui_actions_on_help (action, win);
6221 retrieve_contents_cb (ModestMailOperation *mail_op,
6228 /* We only need this callback to show an error in case of
6229 memory low condition */
6230 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
6231 g_debug ("%s: message failed to retrieve. Memory low?", __FUNCTION__);
6236 retrieve_msg_contents_performer (gboolean canceled,
6238 GtkWindow *parent_window,
6239 TnyAccount *account,
6242 ModestMailOperation *mail_op;
6243 TnyList *headers = TNY_LIST (user_data);
6245 if (err || canceled) {
6246 check_memory_full_error ((GtkWidget *) parent_window, err);
6250 /* Create mail operation */
6251 mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
6252 modest_ui_actions_disk_operations_error_handler,
6254 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
6255 modest_mail_operation_get_msgs_full (mail_op, headers, retrieve_contents_cb, NULL, NULL);
6258 g_object_unref (mail_op);
6260 g_object_unref (headers);
6261 g_object_unref (account);
6265 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
6266 ModestWindow *window)
6268 TnyList *headers = NULL;
6269 TnyAccount *account = NULL;
6270 TnyIterator *iter = NULL;
6271 TnyHeader *header = NULL;
6272 TnyFolder *folder = NULL;
6275 headers = get_selected_headers (window);
6279 /* Pick the account */
6280 iter = tny_list_create_iterator (headers);
6281 header = TNY_HEADER (tny_iterator_get_current (iter));
6282 folder = tny_header_get_folder (header);
6283 account = tny_folder_get_account (folder);
6284 g_object_unref (folder);
6285 g_object_unref (header);
6286 g_object_unref (iter);
6288 /* Connect and perform the message retrieval */
6289 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6290 g_object_ref (account),
6291 retrieve_msg_contents_performer,
6292 g_object_ref (headers));
6295 g_object_unref (account);
6296 g_object_unref (headers);
6300 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
6302 g_return_if_fail (MODEST_IS_WINDOW (window));
6305 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_TOOLBAR);
6309 modest_ui_actions_check_menu_dimming_rules (ModestWindow *window)
6311 g_return_if_fail (MODEST_IS_WINDOW (window));
6314 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_MENU);
6318 modest_ui_actions_on_email_menu_activated (GtkAction *action,
6319 ModestWindow *window)
6321 g_return_if_fail (MODEST_IS_WINDOW (window));
6324 modest_ui_actions_check_menu_dimming_rules (window);
6328 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
6329 ModestWindow *window)
6331 g_return_if_fail (MODEST_IS_WINDOW (window));
6334 modest_ui_actions_check_menu_dimming_rules (window);
6338 modest_ui_actions_on_view_menu_activated (GtkAction *action,
6339 ModestWindow *window)
6341 g_return_if_fail (MODEST_IS_WINDOW (window));
6344 modest_ui_actions_check_menu_dimming_rules (window);
6348 modest_ui_actions_on_format_menu_activated (GtkAction *action,
6349 ModestWindow *window)
6351 g_return_if_fail (MODEST_IS_WINDOW (window));
6354 modest_ui_actions_check_menu_dimming_rules (window);
6358 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
6359 ModestWindow *window)
6361 g_return_if_fail (MODEST_IS_WINDOW (window));
6364 modest_ui_actions_check_menu_dimming_rules (window);
6368 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
6369 ModestWindow *window)
6371 g_return_if_fail (MODEST_IS_WINDOW (window));
6374 modest_ui_actions_check_menu_dimming_rules (window);
6378 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
6379 ModestWindow *window)
6381 g_return_if_fail (MODEST_IS_WINDOW (window));
6384 modest_ui_actions_check_menu_dimming_rules (window);
6388 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
6389 ModestWindow *window)
6391 g_return_if_fail (MODEST_IS_WINDOW (window));
6394 modest_ui_actions_check_menu_dimming_rules (window);
6398 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
6399 ModestWindow *window)
6401 g_return_if_fail (MODEST_IS_WINDOW (window));
6404 modest_ui_actions_check_menu_dimming_rules (window);
6408 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
6410 g_return_if_fail (MODEST_IS_WINDOW (window));
6412 /* we check for low-mem; in that case, show a warning, and don't allow
6415 if (modest_platform_check_memory_low (window, TRUE))
6418 modest_platform_show_search_messages (GTK_WINDOW (window));
6422 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
6424 g_return_if_fail (MODEST_IS_WINDOW (win));
6427 /* we check for low-mem; in that case, show a warning, and don't allow
6428 * for the addressbook
6430 if (modest_platform_check_memory_low (win, TRUE))
6434 modest_platform_show_addressbook (GTK_WINDOW (win));
6439 modest_ui_actions_on_toggle_find_in_page (GtkAction *action,
6440 ModestWindow *window)
6443 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
6445 if (GTK_IS_TOGGLE_ACTION (action))
6446 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
6450 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window),
6455 on_send_receive_finished (ModestMailOperation *mail_op,
6458 GtkWidget *header_view, *folder_view;
6459 TnyFolderStore *folder_store;
6460 ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
6462 /* Set send/receive operation finished */
6463 modest_main_window_notify_send_receive_completed (main_win);
6465 /* Don't refresh the current folder if there were any errors */
6466 if (modest_mail_operation_get_status (mail_op) !=
6467 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
6470 /* Refresh the current folder if we're viewing a window. We do
6471 this because the user won't be able to see the new mails in
6472 the selected folder after a Send&Receive because it only
6473 performs a poke_status, i.e, only the number of read/unread
6474 messages is updated, but the new headers are not
6476 folder_view = modest_main_window_get_child_widget (main_win,
6477 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6481 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6483 /* Do not need to refresh INBOX again because the
6484 update_account does it always automatically */
6485 if (folder_store && TNY_IS_FOLDER (folder_store) &&
6486 tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
6487 ModestMailOperation *refresh_op;
6489 header_view = modest_main_window_get_child_widget (main_win,
6490 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6492 /* We do not need to set the contents style
6493 because it hasn't changed. We also do not
6494 need to save the widget status. Just force
6496 refresh_op = modest_mail_operation_new (G_OBJECT (main_win));
6497 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), refresh_op);
6498 modest_mail_operation_refresh_folder (refresh_op, TNY_FOLDER (folder_store),
6499 folder_refreshed_cb, main_win);
6500 g_object_unref (refresh_op);
6504 g_object_unref (folder_store);
6509 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
6515 const gchar* server_name = NULL;
6516 TnyTransportAccount *transport;
6517 gchar *message = NULL;
6518 ModestProtocol *protocol;
6520 /* Don't show anything if the user cancelled something or the
6521 * send receive request is not interactive. Authentication
6522 * errors are managed by the account store so no need to show
6523 * a dialog here again */
6524 if (err->code == TNY_SYSTEM_ERROR_CANCEL ||
6525 err->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
6526 !modest_tny_send_queue_get_requested_send_receive (MODEST_TNY_SEND_QUEUE (self)))
6530 /* Get the server name. Note that we could be using a
6531 connection specific transport account */
6532 transport = (TnyTransportAccount *)
6533 tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
6535 ModestTnyAccountStore *acc_store;
6536 const gchar *acc_name;
6537 TnyTransportAccount *conn_specific;
6539 acc_store = modest_runtime_get_account_store();
6540 acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
6541 conn_specific = (TnyTransportAccount *)
6542 modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
6543 if (conn_specific) {
6544 server_name = tny_account_get_hostname (TNY_ACCOUNT (conn_specific));
6545 g_object_unref (conn_specific);
6547 server_name = tny_account_get_hostname (TNY_ACCOUNT (transport));
6549 g_object_unref (transport);
6553 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
6554 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
6555 tny_account_get_proto (TNY_ACCOUNT (transport)));
6557 g_warning ("%s: Account with no proto", __FUNCTION__);
6561 /* Show the appropriate message text for the GError: */
6562 switch (err->code) {
6563 case TNY_SERVICE_ERROR_CONNECT:
6564 message = modest_protocol_get_translation (protocol,
6565 MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
6568 case TNY_SERVICE_ERROR_SEND:
6569 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6571 case TNY_SERVICE_ERROR_UNAVAILABLE:
6572 message = modest_protocol_get_translation (protocol,
6573 MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR,
6577 g_warning ("%s: unexpected ERROR %d",
6578 __FUNCTION__, err->code);
6579 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6583 modest_platform_run_information_dialog (NULL, message, FALSE);
6588 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
6593 ModestWindow *top_window = NULL;
6594 ModestWindowMgr *mgr = NULL;
6595 GtkWidget *header_view = NULL;
6596 TnyFolder *selected_folder = NULL;
6597 TnyFolderType folder_type;
6599 mgr = modest_runtime_get_window_mgr ();
6600 top_window = modest_window_mgr_get_current_top (mgr);
6605 #ifndef MODEST_TOOLKIT_HILDON2
6606 if (MODEST_IS_MAIN_WINDOW (top_window)) {
6607 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (top_window),
6608 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6611 if (MODEST_IS_HEADER_WINDOW (top_window)) {
6612 header_view = (GtkWidget *)
6613 modest_header_window_get_header_view (MODEST_HEADER_WINDOW (top_window));
6617 /* Get selected folder */
6619 selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
6620 if (!selected_folder)
6623 /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
6624 #if GTK_CHECK_VERSION(2, 8, 0)
6625 folder_type = modest_tny_folder_guess_folder_type (selected_folder);
6626 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
6627 GtkTreeViewColumn *tree_column;
6629 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
6630 TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
6632 gtk_tree_view_column_queue_resize (tree_column);
6634 #else /* #if GTK_CHECK_VERSION(2, 8, 0) */
6635 gtk_widget_queue_draw (header_view);
6638 #ifndef MODEST_TOOLKIT_HILDON2
6639 /* Rerun dimming rules, because the message could become deletable for example */
6640 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6641 MODEST_DIMMING_RULES_TOOLBAR);
6642 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6643 MODEST_DIMMING_RULES_MENU);
6647 g_object_unref (selected_folder);
6651 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
6652 TnyAccount *account)
6654 ModestProtocolType protocol_type;
6655 ModestProtocol *protocol;
6656 gchar *error_note = NULL;
6658 protocol_type = modest_tny_account_get_protocol_type (account);
6659 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6662 error_note = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, tny_account_get_hostname (account));
6663 if (error_note == NULL) {
6664 g_warning ("%s: This should not be reached", __FUNCTION__);
6666 modest_platform_run_information_dialog (parent_window, error_note, FALSE);
6667 g_free (error_note);
6672 modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
6676 TnyFolderStore *folder = NULL;
6677 TnyAccount *account = NULL;
6678 ModestProtocolType proto;
6679 ModestProtocol *protocol;
6680 TnyHeader *header = NULL;
6682 if (MODEST_IS_MAIN_WINDOW (win)) {
6683 GtkWidget *header_view;
6684 TnyList* headers = NULL;
6686 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
6687 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6688 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6689 if (!headers || tny_list_get_length (headers) == 0) {
6691 g_object_unref (headers);
6694 iter = tny_list_create_iterator (headers);
6695 header = TNY_HEADER (tny_iterator_get_current (iter));
6696 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6697 g_object_unref (iter);
6698 g_object_unref (headers);
6699 #ifdef MODEST_TOOLKIT_HILDON2
6700 } else if (MODEST_IS_HEADER_WINDOW (win)) {
6701 GtkWidget *header_view;
6702 TnyList* headers = NULL;
6704 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
6705 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6706 if (!headers || tny_list_get_length (headers) == 0) {
6708 g_object_unref (headers);
6711 iter = tny_list_create_iterator (headers);
6712 header = TNY_HEADER (tny_iterator_get_current (iter));
6714 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6716 g_warning ("List should contain headers");
6718 g_object_unref (iter);
6719 g_object_unref (headers);
6721 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
6722 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
6724 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6727 if (!header || !folder)
6730 /* Get the account type */
6731 account = tny_folder_get_account (TNY_FOLDER (folder));
6732 proto = modest_tny_account_get_protocol_type (account);
6733 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6736 subject = tny_header_dup_subject (header);
6737 msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
6741 msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
6747 g_object_unref (account);
6749 g_object_unref (folder);
6751 g_object_unref (header);
6757 modest_ui_actions_on_delete_account (GtkWindow *parent_window,
6758 const gchar *account_name,
6759 const gchar *account_title)
6761 ModestAccountMgr *account_mgr;
6764 ModestProtocol *protocol;
6765 gboolean removed = FALSE;
6767 g_return_val_if_fail (account_name, FALSE);
6768 g_return_val_if_fail (account_title, FALSE);
6770 account_mgr = modest_runtime_get_account_mgr();
6772 /* The warning text depends on the account type: */
6773 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6774 modest_account_mgr_get_store_protocol (account_mgr,
6776 txt = modest_protocol_get_translation (protocol,
6777 MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX,
6780 txt = g_strdup_printf (_("emev_nc_delete_mailbox"), account_title);
6782 response = modest_platform_run_confirmation_dialog (parent_window, txt);
6786 if (response == GTK_RESPONSE_OK) {
6787 /* Remove account. If it succeeds then it also removes
6788 the account from the ModestAccountView: */
6789 gboolean is_default = FALSE;
6790 gchar *default_account_name = modest_account_mgr_get_default_account (account_mgr);
6791 if (default_account_name && (strcmp (default_account_name, account_name) == 0))
6793 g_free (default_account_name);
6795 removed = modest_account_mgr_remove_account (account_mgr, account_name);
6797 g_warning ("%s: modest_account_mgr_remove_account() failed.\n", __FUNCTION__);
6803 modest_ui_actions_on_fetch_images (GtkAction *action,
6804 ModestWindow *window)
6806 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
6808 modest_msg_view_window_fetch_images (MODEST_MSG_VIEW_WINDOW (window));
6813 modest_ui_actions_on_reload_message (const gchar *msg_id)
6815 ModestWindow *window = NULL;
6817 g_return_if_fail (msg_id && msg_id[0] != '\0');
6818 if (!modest_window_mgr_find_registered_message_uid (modest_runtime_get_window_mgr (),
6824 if (window == NULL || !MODEST_IS_MSG_VIEW_WINDOW (window))
6827 modest_msg_view_window_reload (MODEST_MSG_VIEW_WINDOW (window));