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 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW "move-to-dialog-folder-view"
93 typedef struct _GetMsgAsyncHelper {
95 ModestMailOperation *mail_op;
102 typedef enum _ReplyForwardAction {
106 } ReplyForwardAction;
108 typedef struct _ReplyForwardHelper {
109 guint reply_forward_type;
110 ReplyForwardAction action;
113 GtkWidget *parent_window;
115 } ReplyForwardHelper;
117 typedef struct _MoveToHelper {
118 GtkTreeRowReference *reference;
122 typedef struct _PasteAsAttachmentHelper {
123 ModestMsgEditWindow *window;
125 } PasteAsAttachmentHelper;
133 * The do_headers_action uses this kind of functions to perform some
134 * action to each member of a list of headers
136 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
138 static void do_headers_action (ModestWindow *win,
142 static void open_msg_cb (ModestMailOperation *mail_op,
149 static void reply_forward_cb (ModestMailOperation *mail_op,
156 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
158 static void folder_refreshed_cb (ModestMailOperation *mail_op,
162 static void on_send_receive_finished (ModestMailOperation *mail_op,
165 static gint header_list_count_uncached_msgs (TnyList *header_list);
167 static gboolean connect_to_get_msg (ModestWindow *win,
168 gint num_of_uncached_msgs,
169 TnyAccount *account);
171 static gboolean remote_folder_has_leave_on_server (TnyFolderStore *folder);
173 static void do_create_folder (GtkWindow *window,
174 TnyFolderStore *parent_folder,
175 const gchar *suggested_name);
177 static TnyAccount *get_account_from_folder_store (TnyFolderStore *folder_store);
179 static void modest_ui_actions_on_main_window_move_to (GtkAction *action,
180 GtkWidget *folder_view,
181 TnyFolderStore *dst_folder,
182 ModestMainWindow *win);
183 #ifdef MODEST_TOOLKIT_HILDON2
184 static void modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
185 TnyFolderStore *dst_folder,
190 static void modest_ui_actions_on_window_move_to (GtkAction *action,
191 TnyList *list_to_move,
192 TnyFolderStore *dst_folder,
196 * This function checks whether a TnyFolderStore is a pop account
199 remote_folder_has_leave_on_server (TnyFolderStore *folder)
204 g_return_val_if_fail (TNY_IS_FOLDER_STORE (folder), FALSE);
206 account = get_account_from_folder_store (folder);
207 result = (modest_protocol_registry_protocol_type_has_leave_on_server (modest_runtime_get_protocol_registry (),
208 modest_tny_account_get_protocol_type (account)));
209 g_object_unref (account);
214 /* FIXME: this should be merged with the similar code in modest-account-view-window */
215 /* Show the account creation wizard dialog.
216 * returns: TRUE if an account was created. FALSE if the user cancelled.
219 modest_ui_actions_run_account_setup_wizard (ModestWindow *win)
221 gboolean result = FALSE;
223 gint dialog_response;
225 /* there is no such wizard yet */
226 wizard = GTK_WINDOW (modest_platform_get_account_settings_wizard ());
227 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (wizard), (GtkWindow *) win);
229 #ifndef MODEST_TOOLKIT_HILDON2
230 /* always present a main window in the background
231 * we do it here, so we cannot end up with two wizards (as this
232 * function might be called in modest_window_mgr_get_main_window as well */
234 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
235 TRUE); /* create if not existent */
239 ModestWindowMgr *mgr;
241 mgr = modest_runtime_get_window_mgr ();
243 window_list = modest_window_mgr_get_window_list (mgr);
244 if (window_list == NULL) {
245 win = MODEST_WINDOW (modest_accounts_window_new ());
246 if (modest_window_mgr_register_window (mgr, win, NULL)) {
247 gtk_widget_show_all (GTK_WIDGET (win));
249 gtk_widget_destroy (GTK_WIDGET (win));
254 g_list_free (window_list);
260 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
262 /* make sure the mainwindow is visible. We need to present the
263 wizard again to give it the focus back. show_all are needed
264 in order to get the widgets properly drawn (MainWindow main
265 paned won't be in its right position and the dialog will be
267 #ifndef MODEST_TOOLKIT_HILDON2
268 gtk_widget_show_all (GTK_WIDGET (win));
269 gtk_widget_show_all (GTK_WIDGET (wizard));
270 gtk_window_present (GTK_WINDOW (win));
271 gtk_window_present (GTK_WINDOW (wizard));
274 dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
275 gtk_widget_destroy (GTK_WIDGET (wizard));
276 if (gtk_events_pending ())
277 gtk_main_iteration ();
279 if (dialog_response == GTK_RESPONSE_CANCEL) {
282 /* Check whether an account was created: */
283 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
290 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
293 const gchar *authors[] = {
294 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
297 about = gtk_about_dialog_new ();
298 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
299 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
300 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
301 _("Copyright (c) 2006, Nokia Corporation\n"
302 "All rights reserved."));
303 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
304 _("a modest e-mail client\n\n"
305 "design and implementation: Dirk-Jan C. Binnema\n"
306 "contributions from the fine people at KC and Ig\n"
307 "uses the tinymail email framework written by Philip van Hoof"));
308 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
309 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
310 gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
311 gtk_window_set_modal (GTK_WINDOW (about), TRUE);
313 gtk_dialog_run (GTK_DIALOG (about));
314 gtk_widget_destroy(about);
318 * Gets the list of currently selected messages. If the win is the
319 * main window, then it returns a newly allocated list of the headers
320 * selected in the header view. If win is the msg view window, then
321 * the value returned is a list with just a single header.
323 * The caller of this funcion must free the list.
326 get_selected_headers (ModestWindow *win)
328 if (MODEST_IS_MAIN_WINDOW(win)) {
329 GtkWidget *header_view;
331 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
332 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
333 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
335 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
336 /* for MsgViewWindows, we simply return a list with one element */
338 TnyList *list = NULL;
340 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
341 if (header != NULL) {
342 list = tny_simple_list_new ();
343 tny_list_prepend (list, G_OBJECT(header));
344 g_object_unref (G_OBJECT(header));
349 #ifdef MODEST_TOOLKIT_HILDON2
350 } else if (MODEST_IS_HEADER_WINDOW (win)) {
351 GtkWidget *header_view;
353 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
354 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
360 static GtkTreeRowReference *
361 get_next_after_selected_headers (ModestHeaderView *header_view)
363 GtkTreeSelection *sel;
364 GList *selected_rows, *node;
366 GtkTreeRowReference *result;
369 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
370 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
371 selected_rows = gtk_tree_selection_get_selected_rows (sel, NULL);
373 if (selected_rows == NULL)
376 node = g_list_last (selected_rows);
377 path = gtk_tree_path_copy ((GtkTreePath *) node->data);
378 gtk_tree_path_next (path);
380 result = gtk_tree_row_reference_new (model, path);
382 gtk_tree_path_free (path);
383 g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
384 g_list_free (selected_rows);
390 headers_action_mark_as_read (TnyHeader *header,
394 TnyHeaderFlags flags;
396 g_return_if_fail (TNY_IS_HEADER(header));
398 flags = tny_header_get_flags (header);
399 if (flags & TNY_HEADER_FLAG_SEEN) return;
400 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
404 headers_action_mark_as_unread (TnyHeader *header,
408 TnyHeaderFlags flags;
410 g_return_if_fail (TNY_IS_HEADER(header));
412 flags = tny_header_get_flags (header);
413 if (flags & TNY_HEADER_FLAG_SEEN) {
414 tny_header_unset_flag (header, TNY_HEADER_FLAG_SEEN);
418 /** After deleing a message that is currently visible in a window,
419 * show the next message from the list, or close the window if there are no more messages.
422 modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
424 /* Close msg view window or select next */
425 if (!modest_msg_view_window_select_next_message (win) &&
426 !modest_msg_view_window_select_previous_message (win)) {
428 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
434 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
436 modest_ui_actions_on_edit_mode_delete_message (win);
440 modest_ui_actions_on_edit_mode_delete_message (ModestWindow *win)
442 TnyList *header_list = NULL;
443 TnyIterator *iter = NULL;
444 TnyHeader *header = NULL;
445 gchar *message = NULL;
448 ModestWindowMgr *mgr;
449 GtkWidget *header_view = NULL;
450 gboolean retval = TRUE;
452 g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
454 /* Check first if the header view has the focus */
455 if (MODEST_IS_MAIN_WINDOW (win)) {
457 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
458 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
459 if (!gtk_widget_is_focus (header_view))
463 /* Get the headers, either from the header view (if win is the main window),
464 * or from the message view window: */
465 header_list = get_selected_headers (win);
466 if (!header_list) return FALSE;
468 /* Check if any of the headers are already opened, or in the process of being opened */
469 if (MODEST_IS_MAIN_WINDOW (win)) {
470 gint opened_headers = 0;
472 iter = tny_list_create_iterator (header_list);
473 mgr = modest_runtime_get_window_mgr ();
474 while (!tny_iterator_is_done (iter)) {
475 header = TNY_HEADER (tny_iterator_get_current (iter));
477 if (modest_window_mgr_find_registered_header (mgr, header, NULL))
479 g_object_unref (header);
481 tny_iterator_next (iter);
483 g_object_unref (iter);
485 if (opened_headers > 0) {
488 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"),
491 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg, FALSE);
494 g_object_unref (header_list);
500 if (tny_list_get_length(header_list) == 1) {
501 iter = tny_list_create_iterator (header_list);
502 header = TNY_HEADER (tny_iterator_get_current (iter));
505 subject = tny_header_dup_subject (header);
507 subject = g_strdup (_("mail_va_no_subject"));
508 desc = g_strdup_printf ("%s", subject);
510 g_object_unref (header);
513 g_object_unref (iter);
515 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
516 tny_list_get_length(header_list)), desc);
518 /* Confirmation dialog */
519 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
523 if (response == GTK_RESPONSE_OK) {
524 ModestWindowMgr *mgr = NULL;
525 GtkTreeModel *model = NULL;
526 GtkTreeSelection *sel = NULL;
527 GList *sel_list = NULL, *tmp = NULL;
528 GtkTreeRowReference *next_row_reference = NULL;
529 GtkTreeRowReference *prev_row_reference = NULL;
530 GtkTreePath *next_path = NULL;
531 GtkTreePath *prev_path = NULL;
532 ModestMailOperation *mail_op = NULL;
534 /* Find last selected row */
535 if (MODEST_IS_MAIN_WINDOW (win)) {
536 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
537 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
538 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
539 for (tmp=sel_list; tmp; tmp=tmp->next) {
540 if (tmp->next == NULL) {
541 prev_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
542 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
544 gtk_tree_path_prev (prev_path);
545 gtk_tree_path_next (next_path);
547 prev_row_reference = gtk_tree_row_reference_new (model, prev_path);
548 next_row_reference = gtk_tree_row_reference_new (model, next_path);
553 /* Disable window dimming management */
554 modest_window_disable_dimming (win);
556 /* Remove each header. If it's a view window header_view == NULL */
557 mail_op = modest_mail_operation_new ((GObject *) win);
558 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
560 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
561 g_object_unref (mail_op);
563 /* Enable window dimming management */
565 gtk_tree_selection_unselect_all (sel);
567 modest_window_enable_dimming (win);
569 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
570 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
572 /* Get main window */
573 mgr = modest_runtime_get_window_mgr ();
574 } else if (MODEST_IS_MAIN_WINDOW (win)) {
575 /* Select next or previous row */
576 if (gtk_tree_row_reference_valid (next_row_reference)) {
577 gtk_tree_selection_select_path (sel, next_path);
579 else if (gtk_tree_row_reference_valid (prev_row_reference)) {
580 gtk_tree_selection_select_path (sel, prev_path);
584 if (gtk_tree_row_reference_valid (next_row_reference))
585 gtk_tree_row_reference_free (next_row_reference);
586 if (next_path != NULL)
587 gtk_tree_path_free (next_path);
588 if (gtk_tree_row_reference_valid (prev_row_reference))
589 gtk_tree_row_reference_free (prev_row_reference);
590 if (prev_path != NULL)
591 gtk_tree_path_free (prev_path);
594 /* Update toolbar dimming state */
595 modest_ui_actions_check_menu_dimming_rules (win);
596 modest_ui_actions_check_toolbar_dimming_rules (win);
599 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
600 g_list_free (sel_list);
609 g_object_unref (header_list);
617 /* delete either message or folder, based on where we are */
619 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
621 g_return_if_fail (MODEST_IS_WINDOW(win));
623 /* Check first if the header view has the focus */
624 if (MODEST_IS_MAIN_WINDOW (win)) {
626 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
627 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
628 if (gtk_widget_is_focus (w)) {
629 modest_ui_actions_on_delete_folder (action, MODEST_WINDOW(win));
633 modest_ui_actions_on_delete_message (action, win);
637 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
639 ModestWindowMgr *mgr = NULL;
641 #ifdef MODEST_PLATFORM_MAEMO
642 modest_osso_save_state();
643 #endif /* MODEST_PLATFORM_MAEMO */
645 g_debug ("closing down, clearing %d item(s) from operation queue",
646 modest_mail_operation_queue_num_elements
647 (modest_runtime_get_mail_operation_queue()));
649 /* cancel all outstanding operations */
650 modest_mail_operation_queue_cancel_all
651 (modest_runtime_get_mail_operation_queue());
653 g_debug ("queue has been cleared");
656 /* Check if there are opened editing windows */
657 mgr = modest_runtime_get_window_mgr ();
658 modest_window_mgr_close_all_windows (mgr);
660 /* note: when modest-tny-account-store is finalized,
661 it will automatically set all network connections
664 /* gtk_main_quit (); */
668 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
672 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
674 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
675 /* gtk_widget_destroy (GTK_WIDGET (win)); */
676 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
677 /* gboolean ret_value; */
678 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
679 /* } else if (MODEST_IS_WINDOW (win)) { */
680 /* gtk_widget_destroy (GTK_WIDGET (win)); */
682 /* g_return_if_reached (); */
687 modest_ui_actions_add_to_contacts (GtkAction *action, ModestWindow *win)
689 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
691 modest_msg_view_window_add_to_contacts (MODEST_MSG_VIEW_WINDOW (win));
695 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
697 GtkClipboard *clipboard = NULL;
698 gchar *selection = NULL;
700 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
701 selection = gtk_clipboard_wait_for_text (clipboard);
703 /* Question: why is the clipboard being used here?
704 * It doesn't really make a lot of sense. */
708 modest_address_book_add_address (selection);
714 modest_ui_actions_on_new_account (GtkAction *action,
715 ModestWindow *window)
717 if (!modest_ui_actions_run_account_setup_wizard (window)) {
718 g_debug ("%s: wizard was already running", __FUNCTION__);
723 modest_ui_actions_on_accounts (GtkAction *action,
726 /* This is currently only implemented for Maemo */
727 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
728 if (!modest_ui_actions_run_account_setup_wizard (win))
729 g_debug ("%s: wizard was already running", __FUNCTION__);
733 /* Show the list of accounts */
734 GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
736 /* The accounts dialog must be modal */
737 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (account_win), (GtkWindow *) win);
738 modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
743 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
745 /* This is currently only implemented for Maemo,
746 * because it requires an API (libconic) to detect different connection
749 #ifndef MODEST_TOOLKIT_GTK /* Defined in config.h */
751 /* Create the window if necessary: */
752 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
753 modest_connection_specific_smtp_window_fill_with_connections (
754 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
755 modest_runtime_get_account_mgr());
757 /* Show the window: */
758 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
759 GTK_WINDOW (specific_window), (GtkWindow *) win);
760 gtk_widget_show (specific_window);
761 #endif /* !MODEST_TOOLKIT_GTK */
765 count_part_size (const gchar *part)
767 GnomeVFSURI *vfs_uri;
768 gchar *escaped_filename;
770 GnomeVFSFileInfo *info;
773 /* Estimation of attachment size if we cannot get it from file info */
776 vfs_uri = gnome_vfs_uri_new (part);
778 escaped_filename = g_path_get_basename (gnome_vfs_uri_get_path (vfs_uri));
779 filename = gnome_vfs_unescape_string_for_display (escaped_filename);
780 g_free (escaped_filename);
781 gnome_vfs_uri_unref (vfs_uri);
783 info = gnome_vfs_file_info_new ();
785 if (gnome_vfs_get_file_info (part,
787 GNOME_VFS_FILE_INFO_GET_MIME_TYPE)
789 if (info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) {
794 gnome_vfs_file_info_unref (info);
800 count_parts_size (GSList *parts)
805 for (node = parts; node != NULL; node = g_slist_next (node)) {
806 result += count_part_size ((const gchar *) node->data);
813 modest_ui_actions_compose_msg(ModestWindow *win,
816 const gchar *bcc_str,
817 const gchar *subject_str,
818 const gchar *body_str,
820 gboolean set_as_modified)
822 gchar *account_name = NULL;
823 const gchar *mailbox;
825 TnyAccount *account = NULL;
826 TnyFolder *folder = NULL;
827 gchar *from_str = NULL, *signature = NULL, *body = NULL;
828 gchar *recipient = NULL;
829 gboolean use_signature = FALSE;
830 ModestWindow *msg_win = NULL;
831 ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
832 ModestTnyAccountStore *store = modest_runtime_get_account_store();
833 GnomeVFSFileSize total_size, allowed_size;
834 guint64 available_disk, expected_size, parts_size;
837 /* we check for low-mem */
838 if (modest_platform_check_memory_low (win, TRUE))
841 available_disk = modest_utils_get_available_space (NULL);
842 parts_count = g_slist_length (attachments);
843 parts_size = count_parts_size (attachments);
844 expected_size = modest_tny_msg_estimate_size (body, NULL, parts_count, parts_size);
846 /* Double check: disk full condition or message too big */
847 if (available_disk < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE ||
848 expected_size > available_disk) {
849 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
850 modest_platform_system_banner (NULL, NULL, msg);
856 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
857 modest_platform_run_information_dialog (
859 _("mail_ib_error_attachment_size"),
865 #ifdef MODEST_TOOLKIT_HILDON2
867 account_name = g_strdup (modest_window_get_active_account(win));
870 account_name = modest_account_mgr_get_default_account(mgr);
873 g_printerr ("modest: no account found\n");
878 mailbox = modest_window_get_active_mailbox (win);
881 account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
883 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
886 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
888 g_printerr ("modest: failed to find Drafts folder\n");
891 from_str = modest_account_mgr_get_from_string (mgr, account_name, mailbox);
893 g_printerr ("modest: failed get from string for '%s'\n", account_name);
897 recipient = modest_text_utils_get_email_address (from_str);
898 signature = modest_account_mgr_get_signature_from_recipient (mgr, recipient, &use_signature);
900 if (body_str != NULL) {
901 body = use_signature ? g_strconcat(body_str, "\n",
902 MODEST_TEXT_UTILS_SIGNATURE_MARKER,
903 "\n", signature, NULL) : g_strdup(body_str);
905 body = use_signature ? g_strconcat("\n", MODEST_TEXT_UTILS_SIGNATURE_MARKER,
906 "\n", signature, NULL) : g_strdup("");
909 msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, NULL, NULL, body, NULL, NULL, NULL);
911 g_printerr ("modest: failed to create new msg\n");
915 /* Create and register edit window */
916 /* This is destroyed by TODO. */
918 allowed_size = MODEST_MAX_ATTACHMENT_SIZE;
919 msg_win = modest_msg_edit_window_new (msg, account_name, mailbox, FALSE);
921 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win, win)) {
922 gtk_widget_destroy (GTK_WIDGET (msg_win));
925 modest_msg_edit_window_set_modified (MODEST_MSG_EDIT_WINDOW (msg_win), set_as_modified);
926 gtk_widget_show_all (GTK_WIDGET (msg_win));
928 while (attachments) {
929 GnomeVFSFileSize att_size;
931 modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
932 attachments->data, allowed_size);
933 total_size += att_size;
935 if (att_size > allowed_size) {
936 g_debug ("%s: total size: %u",
937 __FUNCTION__, (unsigned int)total_size);
940 allowed_size -= att_size;
942 attachments = g_slist_next(attachments);
949 g_free (account_name);
951 g_object_unref (G_OBJECT(account));
953 g_object_unref (G_OBJECT(folder));
955 g_object_unref (G_OBJECT(msg));
959 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
961 /* if there are no accounts yet, just show the wizard */
962 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
963 if (!modest_ui_actions_run_account_setup_wizard (win))
966 modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL, FALSE);
971 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
975 ModestMailOperationStatus status;
977 /* If there is no message or the operation was not successful */
978 status = modest_mail_operation_get_status (mail_op);
979 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
982 /* If it's a memory low issue, then show a banner */
983 error = modest_mail_operation_get_error (mail_op);
984 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
985 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
986 GObject *source = modest_mail_operation_get_source (mail_op);
987 modest_platform_run_information_dialog (GTK_IS_WINDOW (source) ? GTK_WINDOW (source) : NULL,
988 _KR("memr_ib_operation_disabled"),
990 g_object_unref (source);
993 if (error && ((error->code == TNY_SERVICE_ERROR_NO_SUCH_MESSAGE) ||
994 error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE)) {
995 gchar *subject, *msg, *format = NULL;
998 subject = header?tny_header_dup_subject (header):NULL;
1000 subject = g_strdup (_("mail_va_no_subject"));
1002 account = modest_mail_operation_get_account (mail_op);
1004 ModestProtocol *protocol;
1005 ModestProtocolType proto;
1006 proto = modest_tny_account_get_protocol_type (account);
1007 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (), proto);
1009 format = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
1010 g_object_unref (account);
1014 format = g_strdup (_("emev_ni_ui_imap_message_not_available_in_server"));
1016 msg = g_strdup_printf (format, subject);
1017 modest_platform_run_information_dialog (NULL, msg, FALSE);
1023 /* Remove the header from the preregistered uids */
1024 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1037 } OpenMsgBannerInfo;
1040 GtkTreeModel *model;
1042 ModestWindow *caller_window;
1043 OpenMsgBannerInfo *banner_info;
1044 GtkTreeRowReference *rowref;
1048 open_msg_banner_idle (gpointer userdata)
1050 OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) userdata;
1052 gdk_threads_enter ();
1053 banner_info->idle_handler = 0;
1054 banner_info->banner = modest_platform_animation_banner (NULL, NULL, banner_info->message);
1055 if (banner_info->banner)
1056 g_object_ref (banner_info->banner);
1058 gdk_threads_leave ();
1064 get_header_view_from_window (ModestWindow *window)
1066 GtkWidget *header_view;
1068 if (MODEST_IS_MAIN_WINDOW (window)) {
1069 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
1070 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1071 #ifdef MODEST_TOOLKIT_HILDON2
1072 } else if (MODEST_IS_HEADER_WINDOW (window)){
1073 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
1083 get_info_from_header (TnyHeader *header, gboolean *is_draft, gboolean *can_open)
1086 gchar *account = NULL;
1087 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
1092 folder = tny_header_get_folder (header);
1093 /* Gets folder type (OUTBOX headers will be opened in edit window */
1094 if (modest_tny_folder_is_local_folder (folder)) {
1095 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1096 if (folder_type == TNY_FOLDER_TYPE_INVALID)
1097 g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
1100 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
1101 TnyTransportAccount *traccount = NULL;
1102 ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
1103 traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
1105 ModestTnySendQueue *send_queue = NULL;
1106 ModestTnySendQueueStatus status;
1108 account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
1109 TNY_ACCOUNT(traccount)));
1110 send_queue = modest_runtime_get_send_queue(traccount, TRUE);
1111 if (TNY_IS_SEND_QUEUE (send_queue)) {
1112 msg_id = modest_tny_send_queue_get_msg_id (header);
1113 status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
1115 /* Only open messages in outbox with the editor if they are in Failed state */
1116 if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
1119 #ifdef MODEST_TOOLKIT_HILDON2
1121 /* In Fremantle we can not
1122 open any message from
1123 outbox which is not in
1129 g_object_unref(traccount);
1131 g_warning("Cannot get transport account for message in outbox!!");
1133 } else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
1134 *is_draft = TRUE; /* Open in editor if the message is in the Drafts folder */
1138 TnyAccount *acc = tny_folder_get_account (folder);
1141 g_strdup (modest_tny_account_get_parent_modest_account_name_for_server_account (acc));
1142 g_object_unref (acc);
1146 g_object_unref (folder);
1152 open_msg_cb (ModestMailOperation *mail_op,
1159 ModestWindowMgr *mgr = NULL;
1160 ModestWindow *parent_win = NULL;
1161 ModestWindow *win = NULL;
1162 gchar *account = NULL;
1163 gboolean open_in_editor = FALSE;
1165 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1167 /* Do nothing if there was any problem with the mail
1168 operation. The error will be shown by the error_handler of
1169 the mail operation */
1170 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1173 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
1175 /* Mark header as read */
1176 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
1178 account = get_info_from_header (header, &open_in_editor, &can_open);
1182 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
1184 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1186 if (open_in_editor) {
1187 ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
1188 gchar *from_header = NULL, *acc_name;
1189 gchar *mailbox = NULL;
1191 from_header = tny_header_dup_from (header);
1193 /* we cannot edit without a valid account... */
1194 if (!modest_account_mgr_has_accounts(mgr, TRUE)) {
1195 if (!modest_ui_actions_run_account_setup_wizard(parent_win)) {
1196 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1198 g_free (from_header);
1203 acc_name = modest_utils_get_account_name_from_recipient (from_header, &mailbox);
1204 g_free (from_header);
1210 win = modest_msg_edit_window_new (msg, account, mailbox, TRUE);
1214 gchar *uid = modest_tny_folder_get_header_unique_id (header);
1215 const gchar *mailbox = NULL;
1217 if (parent_win && MODEST_IS_WINDOW (parent_win))
1218 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_win));
1220 if (helper->rowref && helper->model) {
1221 win = modest_msg_view_window_new_with_header_model (msg, account, mailbox, (const gchar*) uid,
1222 helper->model, helper->rowref);
1224 win = modest_msg_view_window_new_for_attachment (msg, account, mailbox, (const gchar*) uid);
1229 /* Register and show new window */
1231 mgr = modest_runtime_get_window_mgr ();
1232 if (!modest_window_mgr_register_window (mgr, win, NULL)) {
1233 gtk_widget_destroy (GTK_WIDGET (win));
1236 gtk_widget_show_all (GTK_WIDGET(win));
1239 /* Update toolbar dimming state */
1240 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
1241 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
1247 g_object_unref (parent_win);
1251 modest_ui_actions_disk_operations_error_handler (ModestMailOperation *mail_op,
1254 const GError *error;
1255 GObject *win = NULL;
1256 ModestMailOperationStatus status;
1258 win = modest_mail_operation_get_source (mail_op);
1259 error = modest_mail_operation_get_error (mail_op);
1260 status = modest_mail_operation_get_status (mail_op);
1262 /* If the mail op has been cancelled then it's not an error:
1263 don't show any message */
1264 if (status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
1265 TnyAccount *account = modest_mail_operation_get_account (mail_op);
1266 if (modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
1267 (GError *) error, account)) {
1268 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
1269 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
1271 } else if (error->code == TNY_SYSTEM_ERROR_MEMORY) {
1272 modest_platform_information_banner ((GtkWidget *) win,
1273 NULL, _("emev_ui_imap_inbox_select_error"));
1274 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
1275 error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1276 modest_platform_information_banner ((GtkWidget *) win,
1277 NULL, _CS ("sfil_ni_unable_to_open_file_not_found"));
1278 } else if (user_data) {
1279 modest_platform_information_banner ((GtkWidget *) win,
1283 g_object_unref (account);
1287 g_object_unref (win);
1291 * Returns the account a list of headers belongs to. It returns a
1292 * *new* reference so don't forget to unref it
1295 get_account_from_header_list (TnyList *headers)
1297 TnyAccount *account = NULL;
1299 if (tny_list_get_length (headers) > 0) {
1300 TnyIterator *iter = tny_list_create_iterator (headers);
1301 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1302 TnyFolder *folder = tny_header_get_folder (header);
1305 g_object_unref (header);
1307 while (!tny_iterator_is_done (iter)) {
1308 header = TNY_HEADER (tny_iterator_get_current (iter));
1309 folder = tny_header_get_folder (header);
1312 g_object_unref (header);
1314 tny_iterator_next (iter);
1319 account = tny_folder_get_account (folder);
1320 g_object_unref (folder);
1324 g_object_unref (header);
1326 g_object_unref (iter);
1332 get_account_from_header (TnyHeader *header)
1334 TnyAccount *account = NULL;
1337 folder = tny_header_get_folder (header);
1340 account = tny_folder_get_account (folder);
1341 g_object_unref (folder);
1347 caller_win_destroyed (OpenMsgHelper *helper, GObject *object)
1349 if (helper->caller_window)
1350 helper->caller_window = NULL;
1354 open_msg_helper_destroyer (gpointer user_data)
1356 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1358 if (helper->caller_window) {
1359 g_object_weak_unref ((GObject *) helper->caller_window, (GWeakNotify) caller_win_destroyed, helper);
1360 helper->caller_window = NULL;
1363 if (helper->banner_info) {
1364 g_free (helper->banner_info->message);
1365 if (helper->banner_info->idle_handler > 0) {
1366 g_source_remove (helper->banner_info->idle_handler);
1367 helper->banner_info->idle_handler = 0;
1369 if (helper->banner_info->banner != NULL) {
1370 gtk_widget_destroy (helper->banner_info->banner);
1371 g_object_unref (helper->banner_info->banner);
1372 helper->banner_info->banner = NULL;
1374 g_slice_free (OpenMsgBannerInfo, helper->banner_info);
1375 helper->banner_info = NULL;
1377 g_object_unref (helper->model);
1378 g_object_unref (helper->header);
1379 gtk_tree_row_reference_free (helper->rowref);
1380 g_slice_free (OpenMsgHelper, helper);
1384 open_msg_performer(gboolean canceled,
1386 GtkWindow *parent_window,
1387 TnyAccount *account,
1390 ModestMailOperation *mail_op = NULL;
1391 gchar *error_msg = NULL;
1392 ModestProtocolType proto;
1393 TnyConnectionStatus status;
1394 OpenMsgHelper *helper = NULL;
1395 ModestProtocol *protocol;
1396 ModestProtocolRegistry *protocol_registry;
1399 helper = (OpenMsgHelper *) user_data;
1401 status = tny_account_get_connection_status (account);
1402 if (err || canceled || helper->caller_window == NULL) {
1403 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1404 /* Free the helper */
1405 open_msg_helper_destroyer (helper);
1407 /* In disk full conditions we could get this error here */
1408 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
1409 (GtkWidget *) parent_window, err,
1415 /* Get the error message depending on the protocol */
1416 proto = modest_tny_account_get_protocol_type (account);
1417 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
1418 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
1421 protocol_registry = modest_runtime_get_protocol_registry ();
1422 subject = tny_header_dup_subject (helper->header);
1424 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, proto);
1425 error_msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
1429 if (error_msg == NULL) {
1430 error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1433 #ifndef MODEST_TOOLKIT_HILDON2
1434 gboolean show_open_draft = FALSE;
1435 if (modest_protocol_registry_protocol_type_has_tag (protocol_registry,
1437 MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS)) {
1439 TnyFolderType folder_type;
1441 folder = tny_header_get_folder (helper->header);
1442 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1443 show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
1444 g_object_unref (folder);
1448 #ifdef MODEST_TOOLKIT_HILDON2
1451 gchar *account_name = get_info_from_header (helper->header, &is_draft, &can_open);
1454 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1455 g_free (account_name);
1456 open_msg_helper_destroyer (helper);
1461 ModestWindow *window;
1462 GtkWidget *header_view;
1465 header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
1466 uid = modest_tny_folder_get_header_unique_id (helper->header);
1468 const gchar *mailbox = NULL;
1469 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_window));
1470 window = modest_msg_view_window_new_from_header_view
1471 (MODEST_HEADER_VIEW (header_view), account_name, mailbox, uid, helper->rowref);
1472 if (window != NULL) {
1473 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr (),
1475 gtk_widget_destroy (GTK_WIDGET (window));
1477 gtk_widget_show_all (GTK_WIDGET(window));
1481 g_free (account_name);
1483 open_msg_helper_destroyer (helper);
1486 g_free (account_name);
1488 /* Create the mail operation */
1490 modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
1491 modest_ui_actions_disk_operations_error_handler,
1492 g_strdup (error_msg), g_free);
1493 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1497 #ifndef MODEST_TOOLKIT_HILDON2
1498 if (show_open_draft) {
1499 helper->banner_info = g_slice_new (OpenMsgBannerInfo);
1500 helper->banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
1501 helper->banner_info->banner = NULL;
1502 helper->banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle,
1503 helper->banner_info);
1509 headers = TNY_LIST (tny_simple_list_new ());
1510 tny_list_prepend (headers, G_OBJECT (helper->header));
1511 modest_mail_operation_get_msgs_full (mail_op,
1515 open_msg_helper_destroyer);
1516 g_object_unref (headers);
1523 g_object_unref (mail_op);
1524 g_object_unref (account);
1528 * This function is used by both modest_ui_actions_on_open and
1529 * modest_ui_actions_on_header_activated. This way we always do the
1530 * same when trying to open messages.
1533 open_msg_from_header (TnyHeader *header, GtkTreeRowReference *rowref, ModestWindow *win)
1535 ModestWindowMgr *mgr = NULL;
1536 TnyAccount *account;
1537 gboolean cached = FALSE;
1539 GtkWidget *header_view = NULL;
1540 OpenMsgHelper *helper;
1541 ModestWindow *window;
1543 g_return_if_fail (header != NULL && rowref != NULL);
1545 mgr = modest_runtime_get_window_mgr ();
1548 header_view = get_header_view_from_window (MODEST_WINDOW (win));
1549 if (header_view == NULL)
1552 /* Get the account */
1553 account = get_account_from_header (header);
1558 found = modest_window_mgr_find_registered_header (mgr, header, &window);
1560 /* Do not open again the message and present the
1561 window to the user */
1564 #ifndef MODEST_TOOLKIT_HILDON2
1565 gtk_window_present (GTK_WINDOW (window));
1568 /* the header has been registered already, we don't do
1569 * anything but wait for the window to come up*/
1570 g_debug ("header %p already registered, waiting for window", header);
1575 /* Open each message */
1576 cached = tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED;
1578 /* Allways download if we are online. */
1579 if (!tny_device_is_online (modest_runtime_get_device ())) {
1582 /* If ask for user permission to download the messages */
1583 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1584 _("mcen_nc_get_msg"));
1586 /* End if the user does not want to continue */
1587 if (response == GTK_RESPONSE_CANCEL) {
1593 /* We register the window for opening */
1594 modest_window_mgr_register_header (mgr, header, NULL);
1596 /* Create the helper. We need to get a reference to the model
1597 here because it could change while the message is readed
1598 (the user could switch between folders) */
1599 helper = g_slice_new (OpenMsgHelper);
1600 helper->model = g_object_ref (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)));
1601 helper->caller_window = win;
1602 g_object_weak_ref ((GObject *) helper->caller_window, (GWeakNotify) caller_win_destroyed, helper);
1603 helper->header = g_object_ref (header);
1604 helper->rowref = gtk_tree_row_reference_copy (rowref);
1605 helper->banner_info = NULL;
1607 /* Connect to the account and perform */
1609 modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
1610 open_msg_performer, helper);
1612 /* Call directly the performer, do not need to connect */
1613 open_msg_performer (FALSE, NULL, (GtkWindow *) win,
1614 g_object_ref (account), helper);
1619 g_object_unref (account);
1623 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1630 /* we check for low-mem; in that case, show a warning, and don't allow
1633 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1637 headers = get_selected_headers (win);
1641 headers_count = tny_list_get_length (headers);
1642 if (headers_count != 1) {
1643 if (headers_count > 1) {
1644 /* Don't allow activation if there are more than one message selected */
1645 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
1648 g_object_unref (headers);
1652 iter = tny_list_create_iterator (headers);
1653 header = TNY_HEADER (tny_iterator_get_current (iter));
1654 g_object_unref (iter);
1658 open_msg_from_header (header, NULL, win);
1659 g_object_unref (header);
1662 g_object_unref(headers);
1666 rf_helper_window_closed (gpointer data,
1669 ReplyForwardHelper *helper = (ReplyForwardHelper *) data;
1671 helper->parent_window = NULL;
1674 static ReplyForwardHelper*
1675 create_reply_forward_helper (ReplyForwardAction action,
1677 guint reply_forward_type,
1680 ReplyForwardHelper *rf_helper = NULL;
1681 const gchar *active_acc = modest_window_get_active_account (win);
1682 const gchar *active_mailbox = modest_window_get_active_mailbox (win);
1684 rf_helper = g_slice_new0 (ReplyForwardHelper);
1685 rf_helper->reply_forward_type = reply_forward_type;
1686 rf_helper->action = action;
1687 rf_helper->parent_window = (MODEST_IS_WINDOW (win)) ? GTK_WIDGET (win) : NULL;
1688 rf_helper->header = (header) ? g_object_ref (header) : NULL;
1689 rf_helper->account_name = (active_acc) ?
1690 g_strdup (active_acc) :
1691 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1692 rf_helper->mailbox = g_strdup (active_mailbox);
1694 /* Note that window could be destroyed just AFTER calling
1695 register_window so we must ensure that this pointer does
1696 not hold invalid references */
1697 if (rf_helper->parent_window)
1698 g_object_weak_ref (G_OBJECT (rf_helper->parent_window),
1699 rf_helper_window_closed, rf_helper);
1705 free_reply_forward_helper (gpointer data)
1707 ReplyForwardHelper *helper;
1709 helper = (ReplyForwardHelper *) data;
1710 g_free (helper->account_name);
1711 g_free (helper->mailbox);
1713 g_object_unref (helper->header);
1714 if (helper->parent_window)
1715 g_object_weak_unref (G_OBJECT (helper->parent_window),
1716 rf_helper_window_closed, helper);
1717 g_slice_free (ReplyForwardHelper, helper);
1721 reply_forward_cb (ModestMailOperation *mail_op,
1728 TnyMsg *new_msg = NULL;
1729 ReplyForwardHelper *rf_helper;
1730 ModestWindow *msg_win = NULL;
1731 ModestEditType edit_type;
1733 TnyAccount *account = NULL;
1734 ModestWindowMgr *mgr = NULL;
1735 gchar *signature = NULL;
1736 gboolean use_signature;
1739 /* If there was any error. The mail operation could be NULL,
1740 this means that we already have the message downloaded and
1741 that we didn't do a mail operation to retrieve it */
1742 rf_helper = (ReplyForwardHelper *) user_data;
1743 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1746 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1747 rf_helper->account_name, rf_helper->mailbox);
1748 recipient = modest_text_utils_get_email_address (from);
1749 signature = modest_account_mgr_get_signature_from_recipient (modest_runtime_get_account_mgr(),
1754 /* Create reply mail */
1755 switch (rf_helper->action) {
1756 /* Use the msg_header to ensure that we have all the
1757 information. The summary can lack some data */
1758 TnyHeader *msg_header;
1760 msg_header = tny_msg_get_header (msg);
1762 modest_tny_msg_create_reply_msg (msg, msg_header, from,
1763 (use_signature) ? signature : NULL,
1764 rf_helper->reply_forward_type,
1765 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1766 g_object_unref (msg_header);
1768 case ACTION_REPLY_TO_ALL:
1769 msg_header = tny_msg_get_header (msg);
1771 modest_tny_msg_create_reply_msg (msg, msg_header, from,
1772 (use_signature) ? signature : NULL,
1773 rf_helper->reply_forward_type,
1774 MODEST_TNY_MSG_REPLY_MODE_ALL);
1775 edit_type = MODEST_EDIT_TYPE_REPLY;
1776 g_object_unref (msg_header);
1778 case ACTION_FORWARD:
1780 modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL,
1781 rf_helper->reply_forward_type);
1782 edit_type = MODEST_EDIT_TYPE_FORWARD;
1785 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1787 g_return_if_reached ();
1795 g_warning ("%s: failed to create message\n", __FUNCTION__);
1799 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1800 rf_helper->account_name,
1801 TNY_ACCOUNT_TYPE_STORE);
1803 g_warning ("%s: failed to get tnyaccount for '%s'\n", __FUNCTION__, rf_helper->account_name);
1807 /* Create and register the windows */
1808 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, rf_helper->mailbox, FALSE);
1809 mgr = modest_runtime_get_window_mgr ();
1810 modest_window_mgr_register_window (mgr, msg_win, (ModestWindow *) rf_helper->parent_window);
1812 /* Note that register_window could have deleted the account */
1813 if (MODEST_IS_WINDOW (rf_helper->parent_window)) {
1814 gdouble parent_zoom;
1816 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1817 modest_window_set_zoom (msg_win, parent_zoom);
1820 /* Show edit window */
1821 gtk_widget_show_all (GTK_WIDGET (msg_win));
1824 /* We always unregister the header because the message is
1825 forwarded or replied so the original one is no longer
1827 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1830 g_object_unref (G_OBJECT (new_msg));
1832 g_object_unref (G_OBJECT (account));
1833 free_reply_forward_helper (rf_helper);
1836 /* Checks a list of headers. If any of them are not currently
1837 * downloaded (CACHED) then returns TRUE else returns FALSE.
1840 header_list_count_uncached_msgs (TnyList *header_list)
1843 gint uncached_messages = 0;
1845 iter = tny_list_create_iterator (header_list);
1846 while (!tny_iterator_is_done (iter)) {
1849 header = TNY_HEADER (tny_iterator_get_current (iter));
1851 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1852 uncached_messages ++;
1853 g_object_unref (header);
1856 tny_iterator_next (iter);
1858 g_object_unref (iter);
1860 return uncached_messages;
1863 /* Returns FALSE if the user does not want to download the
1864 * messages. Returns TRUE if the user allowed the download.
1867 connect_to_get_msg (ModestWindow *win,
1868 gint num_of_uncached_msgs,
1869 TnyAccount *account)
1871 GtkResponseType response;
1873 /* Allways download if we are online. */
1874 if (tny_device_is_online (modest_runtime_get_device ()))
1877 /* If offline, then ask for user permission to download the messages */
1878 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1879 ngettext("mcen_nc_get_msg",
1881 num_of_uncached_msgs));
1883 if (response == GTK_RESPONSE_CANCEL)
1886 return modest_platform_connect_and_wait((GtkWindow *) win, account);
1890 reply_forward_performer (gboolean canceled,
1892 GtkWindow *parent_window,
1893 TnyAccount *account,
1896 ReplyForwardHelper *rf_helper = NULL;
1897 ModestMailOperation *mail_op;
1899 rf_helper = (ReplyForwardHelper *) user_data;
1901 if (canceled || err) {
1902 free_reply_forward_helper (rf_helper);
1906 /* Retrieve the message */
1907 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), rf_helper->header, NULL);
1908 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (parent_window),
1909 modest_ui_actions_disk_operations_error_handler,
1911 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1912 modest_mail_operation_get_msg (mail_op, rf_helper->header, TRUE, reply_forward_cb, rf_helper);
1915 g_object_unref(mail_op);
1919 * Common code for the reply and forward actions
1922 reply_forward (ReplyForwardAction action, ModestWindow *win)
1924 ReplyForwardHelper *rf_helper = NULL;
1925 guint reply_forward_type;
1927 g_return_if_fail (MODEST_IS_WINDOW(win));
1929 /* we check for low-mem; in that case, show a warning, and don't allow
1930 * reply/forward (because it could potentially require a lot of memory */
1931 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1935 /* we need an account when editing */
1936 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1937 if (!modest_ui_actions_run_account_setup_wizard (win))
1941 reply_forward_type =
1942 modest_conf_get_int (modest_runtime_get_conf (),
1943 (action == ACTION_FORWARD) ?
1944 MODEST_CONF_FORWARD_TYPE :
1945 MODEST_CONF_REPLY_TYPE,
1948 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1950 TnyHeader *header = NULL;
1951 /* Get header and message. Do not free them here, the
1952 reply_forward_cb must do it */
1953 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1954 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
1956 if (msg && header) {
1958 rf_helper = create_reply_forward_helper (action, win,
1959 reply_forward_type, header);
1960 reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
1962 g_warning("%s: no message or header found in viewer\n", __FUNCTION__);
1966 g_object_unref (msg);
1968 g_object_unref (header);
1970 TnyHeader *header = NULL;
1972 gboolean do_retrieve = TRUE;
1973 TnyList *header_list = NULL;
1975 header_list = get_selected_headers (win);
1978 /* Check that only one message is selected for replying */
1979 if (tny_list_get_length (header_list) != 1) {
1980 modest_platform_information_banner ((win) ? GTK_WIDGET (win) : NULL,
1981 NULL, _("mcen_ib_select_one_message"));
1982 g_object_unref (header_list);
1986 /* Only reply/forward to one message */
1987 iter = tny_list_create_iterator (header_list);
1988 header = TNY_HEADER (tny_iterator_get_current (iter));
1989 g_object_unref (iter);
1991 /* Retrieve messages */
1992 do_retrieve = (action == ACTION_FORWARD) ||
1993 (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1996 TnyAccount *account = NULL;
1997 TnyFolder *folder = NULL;
1998 gdouble download = TRUE;
1999 guint uncached_msgs = 0;
2001 folder = tny_header_get_folder (header);
2003 goto do_retrieve_frees;
2004 account = tny_folder_get_account (folder);
2006 goto do_retrieve_frees;
2008 uncached_msgs = header_list_count_uncached_msgs (header_list);
2010 if (uncached_msgs > 0) {
2011 /* Allways download if we are online. */
2012 if (!tny_device_is_online (modest_runtime_get_device ())) {
2015 /* If ask for user permission to download the messages */
2016 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2017 ngettext("mcen_nc_get_msg",
2021 /* End if the user does not want to continue */
2022 if (response == GTK_RESPONSE_CANCEL)
2029 rf_helper = create_reply_forward_helper (action, win,
2030 reply_forward_type, header);
2031 if (uncached_msgs > 0) {
2032 modest_platform_connect_and_perform (GTK_WINDOW (win),
2034 reply_forward_performer,
2037 reply_forward_performer (FALSE, NULL, GTK_WINDOW (win),
2038 account, rf_helper);
2043 g_object_unref (account);
2045 g_object_unref (folder);
2047 reply_forward_cb (NULL, header, FALSE, NULL, NULL, rf_helper);
2050 g_object_unref (header_list);
2051 g_object_unref (header);
2056 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
2058 g_return_if_fail (MODEST_IS_WINDOW(win));
2060 reply_forward (ACTION_REPLY, win);
2064 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
2066 g_return_if_fail (MODEST_IS_WINDOW(win));
2068 reply_forward (ACTION_FORWARD, win);
2072 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
2074 g_return_if_fail (MODEST_IS_WINDOW(win));
2076 reply_forward (ACTION_REPLY_TO_ALL, win);
2080 modest_ui_actions_on_next (GtkAction *action,
2081 ModestWindow *window)
2083 if (MODEST_IS_MAIN_WINDOW (window)) {
2084 GtkWidget *header_view;
2086 header_view = modest_main_window_get_child_widget (
2087 MODEST_MAIN_WINDOW(window),
2088 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2092 modest_header_view_select_next (
2093 MODEST_HEADER_VIEW(header_view));
2094 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2095 modest_msg_view_window_select_next_message (
2096 MODEST_MSG_VIEW_WINDOW (window));
2098 g_return_if_reached ();
2103 modest_ui_actions_on_prev (GtkAction *action,
2104 ModestWindow *window)
2106 g_return_if_fail (MODEST_IS_WINDOW(window));
2108 if (MODEST_IS_MAIN_WINDOW (window)) {
2109 GtkWidget *header_view;
2110 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2111 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2115 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
2116 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2117 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
2119 g_return_if_reached ();
2124 modest_ui_actions_on_sort (GtkAction *action,
2125 ModestWindow *window)
2127 GtkWidget *header_view = NULL;
2129 g_return_if_fail (MODEST_IS_WINDOW(window));
2131 if (MODEST_IS_MAIN_WINDOW (window)) {
2132 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2133 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2134 #ifdef MODEST_TOOLKIT_HILDON2
2135 } else if (MODEST_IS_HEADER_WINDOW (window)) {
2136 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
2141 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
2146 /* Show sorting dialog */
2147 modest_utils_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
2151 new_messages_arrived (ModestMailOperation *self,
2152 TnyList *new_headers,
2156 gboolean show_visual_notifications;
2158 source = modest_mail_operation_get_source (self);
2159 show_visual_notifications = (source) ? FALSE : TRUE;
2161 g_object_unref (source);
2163 /* Notify new messages have been downloaded. If the
2164 send&receive was invoked by the user then do not show any
2165 visual notification, only play a sound and activate the LED
2166 (for the Maemo version) */
2167 if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0) {
2169 /* We only notify about really new messages (not seen) we get */
2170 TnyList *actually_new_list;
2171 TnyIterator *iterator;
2172 actually_new_list = TNY_LIST (tny_simple_list_new ());
2173 for (iterator = tny_list_create_iterator (new_headers);
2174 !tny_iterator_is_done (iterator);
2175 tny_iterator_next (iterator)) {
2177 TnyHeaderFlags flags;
2178 header = TNY_HEADER (tny_iterator_get_current (iterator));
2179 flags = tny_header_get_flags (header);
2181 if (!(flags & TNY_HEADER_FLAG_SEEN)) {
2182 tny_list_append (actually_new_list, G_OBJECT (header));
2184 g_object_unref (header);
2186 g_object_unref (iterator);
2188 if (tny_list_get_length (actually_new_list) > 0) {
2189 GList *new_headers_list = NULL;
2191 new_headers_list = modest_utils_create_notification_list_from_header_list (actually_new_list);
2193 /* Send notifications */
2194 if (new_headers_list) {
2195 modest_platform_on_new_headers_received (new_headers_list,
2196 show_visual_notifications);
2198 modest_utils_free_notification_list (new_headers_list);
2201 g_object_unref (actually_new_list);
2207 retrieve_all_messages_cb (GObject *source,
2209 guint retrieve_limit)
2215 window = GTK_WINDOW (source);
2216 msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"),
2217 num_msgs, retrieve_limit);
2219 /* Ask the user if they want to retrieve all the messages */
2221 modest_platform_run_confirmation_dialog_with_buttons (window, msg,
2222 _("mcen_bd_get_all"),
2223 _("mcen_bd_newest_only"));
2224 /* Free and return */
2226 return (response == GTK_RESPONSE_ACCEPT) ? TRUE : FALSE;
2230 TnyAccount *account;
2232 gchar *account_name;
2233 gboolean poke_status;
2234 gboolean interactive;
2235 ModestMailOperation *mail_op;
2239 do_send_receive_performer (gboolean canceled,
2241 GtkWindow *parent_window,
2242 TnyAccount *account,
2245 SendReceiveInfo *info;
2247 info = (SendReceiveInfo *) user_data;
2249 if (err || canceled) {
2250 /* In disk full conditions we could get this error here */
2251 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
2252 (GtkWidget *) parent_window, err,
2255 if (info->mail_op) {
2256 modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (),
2262 /* Set send/receive operation in progress */
2263 if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
2264 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
2267 if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
2268 g_signal_connect (G_OBJECT (info->mail_op), "operation-finished",
2269 G_CALLBACK (on_send_receive_finished),
2272 /* Send & receive. */
2273 modest_mail_operation_update_account (info->mail_op, info->account_name, info->poke_status, info->interactive,
2274 (info->win) ? retrieve_all_messages_cb : NULL,
2275 new_messages_arrived, info->win);
2280 g_object_unref (G_OBJECT (info->mail_op));
2281 if (info->account_name)
2282 g_free (info->account_name);
2284 g_object_unref (info->win);
2286 g_object_unref (info->account);
2287 g_slice_free (SendReceiveInfo, info);
2291 * This function performs the send & receive required actions. The
2292 * window is used to create the mail operation. Typically it should
2293 * always be the main window, but we pass it as argument in order to
2297 modest_ui_actions_do_send_receive (const gchar *account_name,
2298 gboolean force_connection,
2299 gboolean poke_status,
2300 gboolean interactive,
2303 gchar *acc_name = NULL;
2304 SendReceiveInfo *info;
2305 ModestTnyAccountStore *acc_store;
2306 TnyAccount *account;
2308 /* If no account name was provided then get the current account, and if
2309 there is no current account then pick the default one: */
2310 if (!account_name) {
2312 acc_name = g_strdup (modest_window_get_active_account (win));
2314 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
2316 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2320 acc_name = g_strdup (account_name);
2323 acc_store = modest_runtime_get_account_store ();
2324 account = modest_tny_account_store_get_server_account (acc_store, acc_name, TNY_ACCOUNT_TYPE_STORE);
2328 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2332 /* Do not automatically refresh accounts that are flagged as
2333 NO_AUTO_UPDATE. This could be useful for accounts that
2334 handle their own update times */
2336 ModestProtocolType proto = modest_tny_account_get_protocol_type (account);
2337 if (proto != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
2338 const gchar *tag = MODEST_PROTOCOL_REGISTRY_NO_AUTO_UPDATE_PROTOCOLS;
2339 ModestProtocolRegistry *registry = modest_runtime_get_protocol_registry ();
2341 if (modest_protocol_registry_protocol_type_has_tag (registry, proto, tag)) {
2342 g_debug ("%s no auto update allowed for account %s", __FUNCTION__, account_name);
2343 g_object_unref (account);
2350 /* Create the info for the connect and perform */
2351 info = g_slice_new (SendReceiveInfo);
2352 info->account_name = acc_name;
2353 info->win = (win) ? g_object_ref (win) : NULL;
2354 info->poke_status = poke_status;
2355 info->interactive = interactive;
2356 info->account = account;
2357 /* We need to create the operation here, because otherwise it
2358 could happen that the queue emits the queue-empty signal
2359 while we're trying to connect the account */
2360 info->mail_op = modest_mail_operation_new_with_error_handling ((info->win) ? G_OBJECT (info->win) : NULL,
2361 modest_ui_actions_disk_operations_error_handler,
2363 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), info->mail_op);
2365 /* Invoke the connect and perform */
2366 modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
2367 force_connection, info->account,
2368 do_send_receive_performer, info);
2373 modest_ui_actions_do_cancel_send (const gchar *account_name,
2376 TnyTransportAccount *transport_account;
2377 TnySendQueue *send_queue = NULL;
2378 GError *error = NULL;
2380 /* Get transport account */
2382 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2383 (modest_runtime_get_account_store(),
2385 TNY_ACCOUNT_TYPE_TRANSPORT));
2386 if (!transport_account) {
2387 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2392 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account, TRUE));
2393 if (!TNY_IS_SEND_QUEUE(send_queue)) {
2394 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
2395 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2396 "modest: could not find send queue for account\n");
2398 /* Cancel the current send */
2399 tny_account_cancel (TNY_ACCOUNT (transport_account));
2401 /* Suspend all pending messages */
2402 tny_send_queue_cancel (send_queue, TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, &error);
2406 if (transport_account != NULL)
2407 g_object_unref (G_OBJECT (transport_account));
2411 modest_ui_actions_cancel_send_all (ModestWindow *win)
2413 GSList *account_names, *iter;
2415 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2418 iter = account_names;
2420 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
2421 iter = g_slist_next (iter);
2424 modest_account_mgr_free_account_names (account_names);
2425 account_names = NULL;
2429 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
2432 /* Check if accounts exist */
2433 gboolean accounts_exist =
2434 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2436 /* If not, allow the user to create an account before trying to send/receive. */
2437 if (!accounts_exist)
2438 modest_ui_actions_on_accounts (NULL, win);
2440 /* Cancel all sending operaitons */
2441 modest_ui_actions_cancel_send_all (win);
2445 * Refreshes all accounts. This function will be used by automatic
2449 modest_ui_actions_do_send_receive_all (ModestWindow *win,
2450 gboolean force_connection,
2451 gboolean poke_status,
2452 gboolean interactive)
2454 GSList *account_names, *iter;
2456 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2459 iter = account_names;
2461 modest_ui_actions_do_send_receive ((const char*) iter->data,
2463 poke_status, interactive, win);
2464 iter = g_slist_next (iter);
2467 modest_account_mgr_free_account_names (account_names);
2468 account_names = NULL;
2472 * Handler of the click on Send&Receive button in the main toolbar
2475 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
2477 /* Check if accounts exist */
2478 gboolean accounts_exist;
2481 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2483 /* If not, allow the user to create an account before trying to send/receive. */
2484 if (!accounts_exist)
2485 modest_ui_actions_on_accounts (NULL, win);
2487 /* Refresh the current folder. The if is always TRUE it's just an extra check */
2488 if (MODEST_IS_MAIN_WINDOW (win)) {
2489 GtkWidget *folder_view;
2490 TnyFolderStore *folder_store;
2493 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2494 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2498 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2501 g_object_unref (folder_store);
2502 /* Refresh the active account. Force the connection if needed
2503 and poke the status of all folders */
2504 modest_ui_actions_do_send_receive (NULL, TRUE, TRUE, TRUE, win);
2505 #ifdef MODEST_TOOLKIT_HILDON2
2506 } else if (MODEST_IS_ACCOUNTS_WINDOW (win)) {
2507 modest_ui_actions_do_send_receive_all (win, TRUE, TRUE, TRUE);
2510 const gchar *active_account;
2511 active_account = modest_window_get_active_account (MODEST_WINDOW (win));
2513 modest_ui_actions_do_send_receive (active_account, TRUE, TRUE, TRUE, win);
2520 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
2523 GtkWidget *header_view;
2525 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2527 header_view = modest_main_window_get_child_widget (main_window,
2528 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2532 conf = modest_runtime_get_conf ();
2534 /* what is saved/restored is depending on the style; thus; we save with
2535 * old style, then update the style, and restore for this new style
2537 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
2539 if (modest_header_view_get_style
2540 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
2541 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2542 MODEST_HEADER_VIEW_STYLE_TWOLINES);
2544 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2545 MODEST_HEADER_VIEW_STYLE_DETAILS);
2547 modest_widget_memory_restore (conf, G_OBJECT(header_view),
2548 MODEST_CONF_HEADER_VIEW_KEY);
2553 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
2555 ModestMainWindow *main_window)
2557 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2558 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2560 /* in the case the folder is empty, show the empty folder message and focus
2562 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
2563 if (modest_header_view_is_empty (header_view)) {
2564 TnyFolder *folder = modest_header_view_get_folder (header_view);
2565 GtkWidget *folder_view =
2566 modest_main_window_get_child_widget (main_window,
2567 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2568 if (folder != NULL) {
2569 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
2570 g_object_unref (folder);
2572 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
2576 /* If no header has been selected then exit */
2581 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
2582 gtk_widget_grab_focus (GTK_WIDGET(header_view));
2584 /* Update toolbar dimming state */
2585 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2586 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2590 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
2593 ModestWindow *window)
2595 GtkWidget *open_widget;
2596 GtkTreeRowReference *rowref;
2598 g_return_if_fail (MODEST_IS_WINDOW(window));
2599 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2600 g_return_if_fail (TNY_IS_HEADER (header));
2602 if (modest_header_view_count_selected_headers (header_view) > 1) {
2603 /* Don't allow activation if there are more than one message selected */
2604 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
2608 /* we check for low-mem; in that case, show a warning, and don't allow
2609 * activating headers
2611 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
2614 if (MODEST_IS_MAIN_WINDOW (window)) {
2615 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
2616 open_widget = modest_window_get_action_widget (MODEST_WINDOW (window), "/MenuBar/EmailMenu/EmailOpenMenu");
2617 if (!GTK_WIDGET_IS_SENSITIVE (open_widget))
2621 rowref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)), path);
2622 open_msg_from_header (header, rowref, MODEST_WINDOW (window));
2623 gtk_tree_row_reference_free (rowref);
2627 set_active_account_from_tny_account (TnyAccount *account,
2628 ModestWindow *window)
2630 const gchar *server_acc_name = tny_account_get_id (account);
2632 /* We need the TnyAccount provided by the
2633 account store because that is the one that
2634 knows the name of the Modest account */
2635 TnyAccount *modest_server_account =
2636 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
2637 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
2639 if (!modest_server_account) {
2640 g_warning ("%s: could not get tny account\n", __FUNCTION__);
2644 /* Update active account, but only if it's not a pseudo-account */
2645 if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
2646 (!modest_tny_account_is_memory_card_account(modest_server_account))) {
2647 const gchar *modest_acc_name =
2648 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
2649 if (modest_acc_name)
2650 modest_window_set_active_account (window, modest_acc_name);
2653 g_object_unref (modest_server_account);
2658 folder_refreshed_cb (ModestMailOperation *mail_op,
2662 ModestMainWindow *win = NULL;
2663 GtkWidget *folder_view, *header_view;
2664 const GError *error;
2666 g_return_if_fail (TNY_IS_FOLDER (folder));
2668 win = MODEST_MAIN_WINDOW (user_data);
2670 /* Check if the operation failed due to memory low conditions */
2671 error = modest_mail_operation_get_error (mail_op);
2672 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
2673 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
2674 modest_platform_run_information_dialog (GTK_WINDOW (win),
2675 _KR("memr_ib_operation_disabled"),
2681 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2683 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2686 TnyFolderStore *current_folder;
2688 current_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2689 if (current_folder) {
2690 gboolean different = ((TnyFolderStore *) folder != current_folder);
2691 g_object_unref (current_folder);
2697 /* Check if folder is empty and set headers view contents style */
2698 if ((tny_folder_get_all_count (folder) == 0) ||
2699 modest_header_view_is_empty (MODEST_HEADER_VIEW (header_view)))
2700 modest_main_window_set_contents_style (win,
2701 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2705 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2706 TnyFolderStore *folder_store,
2708 ModestMainWindow *main_window)
2710 GtkWidget *header_view;
2712 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2714 header_view = modest_main_window_get_child_widget(main_window,
2715 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2720 if (TNY_IS_ACCOUNT (folder_store)) {
2722 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2724 /* Show account details */
2725 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2728 if (TNY_IS_FOLDER (folder_store) && selected) {
2729 TnyAccount *account;
2731 /* Update the active account */
2732 account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2734 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2735 g_object_unref (account);
2739 /* Set the header style by default, it could
2740 be changed later by the refresh callback to
2742 modest_main_window_set_contents_style (main_window,
2743 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2745 /* Set folder on header view. This function
2746 will call tny_folder_refresh_async so we
2747 pass a callback that will be called when
2748 finished. We use that callback to set the
2749 empty view if there are no messages */
2750 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2751 TNY_FOLDER (folder_store),
2753 MODEST_WINDOW (main_window),
2754 folder_refreshed_cb,
2757 /* Restore configuration. We need to do this
2758 *after* the set_folder because the widget
2759 memory asks the header view about its
2761 modest_widget_memory_restore (modest_runtime_get_conf (),
2762 G_OBJECT(header_view),
2763 MODEST_CONF_HEADER_VIEW_KEY);
2765 /* No need to save the header view
2766 configuration for Maemo because it only
2767 saves the sorting stuff and that it's
2768 already being done by the sort
2769 dialog. Remove it when the GNOME version
2770 has the same behaviour */
2771 #ifdef MODEST_TOOLKIT_GTK
2772 if (modest_main_window_get_contents_style (main_window) ==
2773 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2774 modest_widget_memory_save (modest_runtime_get_conf (),
2775 G_OBJECT (header_view),
2776 MODEST_CONF_HEADER_VIEW_KEY);
2778 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2782 /* Update dimming state */
2783 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2784 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2788 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2795 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2797 online = tny_device_is_online (modest_runtime_get_device());
2800 /* already online -- the item is simply not there... */
2801 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2803 GTK_MESSAGE_WARNING,
2805 _("The %s you selected cannot be found"),
2807 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2808 gtk_dialog_run (GTK_DIALOG(dialog));
2810 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2813 _("mcen_bd_dialog_cancel"),
2814 GTK_RESPONSE_REJECT,
2815 _("mcen_bd_dialog_ok"),
2816 GTK_RESPONSE_ACCEPT,
2818 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2819 "Do you want to get online?"), item);
2820 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
2821 gtk_label_new (txt), FALSE, FALSE, 0);
2822 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2825 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2826 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2827 /* TODO: Comment about why is this commented out: */
2828 /* modest_platform_connect_and_wait (); */
2831 gtk_widget_destroy (dialog);
2835 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2838 /* g_debug ("%s %s", __FUNCTION__, link); */
2843 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2846 modest_platform_activate_uri (link);
2850 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2853 modest_platform_show_uri_popup (link);
2857 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2860 /* we check for low-mem; in that case, show a warning, and don't allow
2861 * viewing attachments
2863 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
2866 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2870 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2871 const gchar *address,
2874 /* g_debug ("%s %s", __FUNCTION__, address); */
2878 on_save_to_drafts_cb (ModestMailOperation *mail_op,
2879 TnyMsg *saved_draft,
2882 ModestMsgEditWindow *edit_window;
2884 /* TODO: in hildon 2 we have to dim and undim the header views while we're saving */
2885 #ifndef MODEST_TOOLKIT_HILDON2
2886 ModestMainWindow *win;
2888 /* FIXME. Make the header view sensitive again. This is a
2889 * temporary hack. See modest_ui_actions_on_save_to_drafts()
2891 win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2892 modest_runtime_get_window_mgr(), FALSE));
2894 GtkWidget *hdrview = modest_main_window_get_child_widget(
2895 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2896 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2900 edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2902 /* Set draft is there was no error */
2903 if (!modest_mail_operation_get_error (mail_op))
2904 modest_msg_edit_window_set_draft (edit_window, saved_draft);
2906 g_object_unref(edit_window);
2910 enough_space_for_message (ModestMsgEditWindow *edit_window,
2913 guint64 available_disk, expected_size;
2918 available_disk = modest_utils_get_available_space (NULL);
2919 modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2920 expected_size = modest_tny_msg_estimate_size (data->plain_body,
2925 /* Double check: disk full condition or message too big */
2926 if (available_disk < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE ||
2927 expected_size > available_disk) {
2928 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
2929 modest_platform_information_banner (NULL, NULL, msg);
2936 * djcb: if we're in low-memory state, we only allow for
2937 * saving messages smaller than
2938 * MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE (see modest-defs.h) this
2939 * should still allow for sending anything critical...
2941 if ((expected_size > MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE) &&
2942 modest_platform_check_memory_low (MODEST_WINDOW(edit_window), TRUE))
2946 * djcb: we also make sure that the attachments are smaller than the max size
2947 * this is for the case where we'd try to forward a message with attachments
2948 * bigger than our max allowed size, or sending an message from drafts which
2949 * somehow got past our checks when attaching.
2951 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
2952 modest_platform_run_information_dialog (
2953 GTK_WINDOW(edit_window),
2954 _("mail_ib_error_attachment_size"),
2963 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2965 TnyTransportAccount *transport_account;
2966 ModestMailOperation *mail_operation;
2968 gchar *account_name;
2969 ModestAccountMgr *account_mgr;
2970 gboolean had_error = FALSE;
2971 ModestMainWindow *win = NULL;
2973 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
2975 data = modest_msg_edit_window_get_msg_data (edit_window);
2978 if (!enough_space_for_message (edit_window, data)) {
2979 modest_msg_edit_window_free_msg_data (edit_window, data);
2983 account_name = g_strdup (data->account_name);
2984 account_mgr = modest_runtime_get_account_mgr();
2986 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2988 account_name = modest_account_mgr_get_default_account (account_mgr);
2989 if (!account_name) {
2990 g_printerr ("modest: no account found\n");
2991 modest_msg_edit_window_free_msg_data (edit_window, data);
2995 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2996 account_name = g_strdup (data->account_name);
3000 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3001 (modest_runtime_get_account_store (),
3003 TNY_ACCOUNT_TYPE_TRANSPORT));
3004 if (!transport_account) {
3005 g_printerr ("modest: no transport account found for '%s'\n", account_name);
3006 g_free (account_name);
3007 modest_msg_edit_window_free_msg_data (edit_window, data);
3011 /* Create the mail operation */
3012 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler,
3014 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3016 modest_mail_operation_save_to_drafts (mail_operation,
3028 data->priority_flags,
3031 on_save_to_drafts_cb,
3032 g_object_ref(edit_window));
3034 #ifdef MODEST_TOOLKIT_HILDON2
3035 /* In hildon2 we always show the information banner on saving to drafts.
3036 * It will be a system information banner in this case.
3038 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3039 modest_platform_information_banner (NULL, NULL, text);
3042 /* Use the main window as the parent of the banner, if the
3043 main window does not exist it won't be shown, if the parent
3044 window exists then it's properly shown. We don't use the
3045 editor window because it could be closed (save to drafts
3046 could happen after closing the window */
3047 win = (ModestMainWindow *)
3048 modest_window_mgr_get_main_window( modest_runtime_get_window_mgr(), FALSE);
3050 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3051 modest_platform_information_banner (GTK_WIDGET (win), NULL, text);
3055 modest_msg_edit_window_set_modified (edit_window, FALSE);
3058 g_free (account_name);
3059 g_object_unref (G_OBJECT (transport_account));
3060 g_object_unref (G_OBJECT (mail_operation));
3062 modest_msg_edit_window_free_msg_data (edit_window, data);
3065 * If the drafts folder is selected then make the header view
3066 * insensitive while the message is being saved to drafts
3067 * (it'll be sensitive again in on_save_to_drafts_cb()). This
3068 * is not very clean but it avoids letting the drafts folder
3069 * in an inconsistent state: the user could edit the message
3070 * being saved and undesirable things would happen.
3071 * In the average case the user won't notice anything at
3072 * all. In the worst case (the user is editing a really big
3073 * file from Drafts) the header view will be insensitive
3074 * during the saving process (10 or 20 seconds, depending on
3075 * the message). Anyway this is just a quick workaround: once
3076 * we find a better solution it should be removed
3077 * See NB#65125 (commend #18) for details.
3079 if (!had_error && win != NULL) {
3080 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
3081 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
3083 TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
3085 if (modest_tny_folder_is_local_folder(folder)) {
3086 TnyFolderType folder_type;
3087 folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
3088 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
3089 GtkWidget *hdrview = modest_main_window_get_child_widget(
3090 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3091 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
3095 if (folder != NULL) g_object_unref(folder);
3102 /* For instance, when clicking the Send toolbar button when editing a message: */
3104 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
3106 TnyTransportAccount *transport_account = NULL;
3107 gboolean had_error = FALSE;
3109 ModestAccountMgr *account_mgr;
3110 gchar *account_name;
3111 ModestMailOperation *mail_operation;
3114 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
3116 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
3119 data = modest_msg_edit_window_get_msg_data (edit_window);
3121 if (data->subject == NULL || data->subject[0] == '\0') {
3122 /* Empty subject -> no send */
3123 modest_msg_edit_window_free_msg_data (edit_window, data);
3127 recipients = g_strconcat (data->to?data->to:"",
3128 data->cc?data->cc:"",
3129 data->bcc?data->bcc:"",
3131 if (recipients == NULL || recipients[0] == '\0') {
3132 /* Empty subject -> no send */
3133 g_free (recipients);
3134 modest_msg_edit_window_free_msg_data (edit_window, data);
3137 g_free (recipients);
3140 if (!enough_space_for_message (edit_window, data)) {
3141 modest_msg_edit_window_free_msg_data (edit_window, data);
3145 account_mgr = modest_runtime_get_account_mgr();
3146 account_name = g_strdup (data->account_name);
3148 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
3151 account_name = modest_account_mgr_get_default_account (account_mgr);
3153 if (!account_name) {
3154 modest_msg_edit_window_free_msg_data (edit_window, data);
3155 /* Run account setup wizard */
3156 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window))) {
3161 /* Get the currently-active transport account for this modest account: */
3162 if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
3164 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3165 (modest_runtime_get_account_store (),
3166 account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
3169 if (!transport_account) {
3170 modest_msg_edit_window_free_msg_data (edit_window, data);
3171 /* Run account setup wizard */
3172 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
3177 /* Create the mail operation */
3178 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler, NULL, NULL);
3179 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3181 modest_mail_operation_send_new_mail (mail_operation,
3195 data->priority_flags);
3197 if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3198 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
3200 if (modest_mail_operation_get_error (mail_operation) != NULL) {
3201 const GError *error = modest_mail_operation_get_error (mail_operation);
3202 if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3203 error->code == MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED) {
3204 g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_operation))->message);
3205 modest_platform_information_banner (NULL, NULL, _CS("sfil_ni_not_enough_memory"));
3211 g_free (account_name);
3212 g_object_unref (G_OBJECT (transport_account));
3213 g_object_unref (G_OBJECT (mail_operation));
3215 modest_msg_edit_window_free_msg_data (edit_window, data);
3218 modest_msg_edit_window_set_sent (edit_window, TRUE);
3220 /* Save settings and close the window: */
3221 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
3228 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
3229 ModestMsgEditWindow *window)
3231 ModestMsgEditFormatState *format_state = NULL;
3233 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3234 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3236 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3239 format_state = modest_msg_edit_window_get_format_state (window);
3240 g_return_if_fail (format_state != NULL);
3242 format_state->bold = gtk_toggle_action_get_active (action);
3243 modest_msg_edit_window_set_format_state (window, format_state);
3244 g_free (format_state);
3249 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
3250 ModestMsgEditWindow *window)
3252 ModestMsgEditFormatState *format_state = NULL;
3254 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3255 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3257 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3260 format_state = modest_msg_edit_window_get_format_state (window);
3261 g_return_if_fail (format_state != NULL);
3263 format_state->italics = gtk_toggle_action_get_active (action);
3264 modest_msg_edit_window_set_format_state (window, format_state);
3265 g_free (format_state);
3270 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
3271 ModestMsgEditWindow *window)
3273 ModestMsgEditFormatState *format_state = NULL;
3275 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3276 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3278 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3281 format_state = modest_msg_edit_window_get_format_state (window);
3282 g_return_if_fail (format_state != NULL);
3284 format_state->bullet = gtk_toggle_action_get_active (action);
3285 modest_msg_edit_window_set_format_state (window, format_state);
3286 g_free (format_state);
3291 modest_ui_actions_on_change_justify (GtkRadioAction *action,
3292 GtkRadioAction *selected,
3293 ModestMsgEditWindow *window)
3295 ModestMsgEditFormatState *format_state = NULL;
3296 GtkJustification value;
3298 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3300 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3303 value = gtk_radio_action_get_current_value (selected);
3305 format_state = modest_msg_edit_window_get_format_state (window);
3306 g_return_if_fail (format_state != NULL);
3308 format_state->justification = value;
3309 modest_msg_edit_window_set_format_state (window, format_state);
3310 g_free (format_state);
3314 modest_ui_actions_on_select_editor_color (GtkAction *action,
3315 ModestMsgEditWindow *window)
3317 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3318 g_return_if_fail (GTK_IS_ACTION (action));
3320 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3323 modest_msg_edit_window_select_color (window);
3327 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
3328 ModestMsgEditWindow *window)
3330 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3331 g_return_if_fail (GTK_IS_ACTION (action));
3333 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3336 modest_msg_edit_window_select_background_color (window);
3340 modest_ui_actions_on_insert_image (GObject *object,
3341 ModestMsgEditWindow *window)
3343 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3346 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3349 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3352 modest_msg_edit_window_insert_image (window);
3356 modest_ui_actions_on_attach_file (GtkAction *action,
3357 ModestMsgEditWindow *window)
3359 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3360 g_return_if_fail (GTK_IS_ACTION (action));
3362 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3365 modest_msg_edit_window_offer_attach_file (window);
3369 modest_ui_actions_on_remove_attachments (GtkAction *action,
3370 ModestMsgEditWindow *window)
3372 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3374 modest_msg_edit_window_remove_attachments (window, NULL);
3378 do_create_folder_cb (ModestMailOperation *mail_op,
3379 TnyFolderStore *parent_folder,
3380 TnyFolder *new_folder,
3383 gchar *suggested_name = (gchar *) user_data;
3384 GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
3385 const GError *error;
3387 error = modest_mail_operation_get_error (mail_op);
3389 gboolean disk_full = FALSE;
3390 TnyAccount *account;
3391 /* Show an error. If there was some problem writing to
3392 disk, show it, otherwise show the generic folder
3393 create error. We do it here and not in an error
3394 handler because the call to do_create_folder will
3395 stop the main loop in a gtk_dialog_run and then,
3396 the message won't be shown until that dialog is
3398 account = modest_mail_operation_get_account (mail_op);
3401 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3402 (GtkWidget *) source_win,
3405 _("mail_in_ui_folder_create_error_memory"));
3406 g_object_unref (account);
3409 /* Show an error and try again if there is no
3410 full memory condition */
3411 modest_platform_information_banner ((GtkWidget *) source_win, NULL,
3412 _("mail_in_ui_folder_create_error"));
3413 do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
3417 /* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
3418 * FIXME: any other? */
3419 GtkWidget *folder_view;
3421 if (MODEST_IS_MAIN_WINDOW(source_win))
3423 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
3424 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3426 folder_view = GTK_WIDGET(g_object_get_data (G_OBJECT (source_win),
3427 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
3429 /* Select the newly created folder. It could happen
3430 that the widget is no longer there (i.e. the window
3431 has been destroyed, so we need to check this */
3433 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
3435 g_object_unref (new_folder);
3437 /* Free. Note that the first time it'll be NULL so noop */
3438 g_free (suggested_name);
3439 g_object_unref (source_win);
3444 TnyFolderStore *parent;
3445 } CreateFolderConnect;
3448 do_create_folder_performer (gboolean canceled,
3450 GtkWindow *parent_window,
3451 TnyAccount *account,
3454 CreateFolderConnect *helper = (CreateFolderConnect *) user_data;
3455 ModestMailOperation *mail_op;
3457 if (canceled || err) {
3458 /* In disk full conditions we could get this error here */
3459 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3460 (GtkWidget *) parent_window, err,
3461 NULL, _("mail_in_ui_folder_create_error_memory"));
3463 /* This happens if we have selected the outbox folder
3465 if (err->code == TNY_SERVICE_ERROR_UNKNOWN &&
3466 TNY_IS_MERGE_FOLDER (helper->parent)) {
3467 /* Show an error and retry */
3468 modest_platform_information_banner ((GtkWidget *) parent_window,
3470 _("mail_in_ui_folder_create_error"));
3472 do_create_folder (parent_window, helper->parent, helper->folder_name);
3478 mail_op = modest_mail_operation_new ((GObject *) parent_window);
3479 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3481 modest_mail_operation_create_folder (mail_op,
3483 (const gchar *) helper->folder_name,
3484 do_create_folder_cb,
3485 g_strdup (helper->folder_name));
3486 g_object_unref (mail_op);
3490 g_object_unref (helper->parent);
3491 if (helper->folder_name)
3492 g_free (helper->folder_name);
3493 g_slice_free (CreateFolderConnect, helper);
3498 do_create_folder (GtkWindow *parent_window,
3499 TnyFolderStore *suggested_parent,
3500 const gchar *suggested_name)
3503 gchar *folder_name = NULL;
3504 TnyFolderStore *parent_folder = NULL;
3506 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
3508 (gchar *) suggested_name,
3512 if (result == GTK_RESPONSE_ACCEPT && parent_folder) {
3513 CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderConnect);
3514 helper->folder_name = g_strdup (folder_name);
3515 helper->parent = g_object_ref (parent_folder);
3517 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
3520 do_create_folder_performer,
3525 g_free (folder_name);
3527 g_object_unref (parent_folder);
3531 modest_ui_actions_create_folder(GtkWidget *parent_window,
3532 GtkWidget *folder_view,
3533 TnyFolderStore *parent_folder)
3535 if (!parent_folder) {
3536 #ifdef MODEST_TOOLKIT_HILDON2
3537 ModestTnyAccountStore *acc_store;
3539 acc_store = modest_runtime_get_account_store ();
3541 parent_folder = (TnyFolderStore *)
3542 modest_tny_account_store_get_local_folders_account (acc_store);
3544 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3548 if (parent_folder) {
3549 do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
3550 g_object_unref (parent_folder);
3555 modest_ui_actions_on_new_folder (GtkAction *action, ModestWindow *window)
3558 g_return_if_fail (MODEST_IS_WINDOW(window));
3560 if (MODEST_IS_MAIN_WINDOW (window)) {
3561 GtkWidget *folder_view;
3563 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3564 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3568 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3569 #ifdef MODEST_TOOLKIT_HILDON2
3570 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3571 GtkWidget *folder_view;
3573 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3574 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3577 g_assert_not_reached ();
3582 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
3585 const GError *error = NULL;
3586 gchar *message = NULL;
3588 TnyAccount *account = modest_mail_operation_get_account (mail_op);
3590 /* Get error message */
3591 error = modest_mail_operation_get_error (mail_op);
3593 g_return_if_reached ();
3595 mem_full = modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
3596 (GError *) error, account);
3598 message = g_strdup_printf (_KR("cerm_device_memory_full"), "");
3599 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3600 error->code == MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS) {
3601 message = _CS("ckdg_ib_folder_already_exists");
3602 } else if (error->domain == TNY_ERROR_DOMAIN &&
3603 error->code == TNY_SERVICE_ERROR_STATE) {
3604 /* This means that the folder is already in use (a
3605 message is opened for example */
3606 message = _("emev_ni_internal_error");
3608 message = _CS("ckdg_ib_unable_to_rename");
3611 /* We don't set a parent for the dialog because the dialog
3612 will be destroyed so the banner won't appear */
3613 modest_platform_information_banner (NULL, NULL, message);
3616 g_object_unref (account);
3622 TnyFolderStore *folder;
3627 on_rename_folder_cb (ModestMailOperation *mail_op,
3628 TnyFolder *new_folder,
3631 ModestFolderView *folder_view;
3633 /* If the window was closed when renaming a folder, or if
3634 * it's not a main window this will happen */
3635 if (!MODEST_IS_FOLDER_VIEW (user_data))
3638 folder_view = MODEST_FOLDER_VIEW (user_data);
3639 /* Note that if the rename fails new_folder will be NULL */
3641 modest_folder_view_select_folder (folder_view, new_folder, FALSE);
3643 modest_folder_view_select_first_inbox_or_local (folder_view);
3645 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
3649 on_rename_folder_performer (gboolean canceled,
3651 GtkWindow *parent_window,
3652 TnyAccount *account,
3655 ModestMailOperation *mail_op = NULL;
3656 GtkTreeSelection *sel = NULL;
3657 GtkWidget *folder_view = NULL;
3658 RenameFolderInfo *data = (RenameFolderInfo*)user_data;
3660 if (canceled || err) {
3661 /* In disk full conditions we could get this error here */
3662 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3663 (GtkWidget *) parent_window, err,
3668 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3669 modest_ui_actions_rename_folder_error_handler,
3670 parent_window, NULL);
3672 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3675 if (MODEST_IS_MAIN_WINDOW(parent_window)) {
3677 folder_view = modest_main_window_get_child_widget (
3678 MODEST_MAIN_WINDOW (parent_window),
3679 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3681 #ifdef MODEST_TOOLKIT_HILDON2
3682 else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3683 ModestFolderWindow *folder_window = (ModestFolderWindow *) parent_window;
3684 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (folder_window));
3688 /* Clear the folders view */
3689 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3690 gtk_tree_selection_unselect_all (sel);
3692 /* Actually rename the folder */
3693 modest_mail_operation_rename_folder (mail_op,
3694 TNY_FOLDER (data->folder),
3695 (const gchar *) (data->new_name),
3696 on_rename_folder_cb,
3698 g_object_unref (mail_op);
3701 g_object_unref (data->folder);
3702 g_free (data->new_name);
3707 modest_ui_actions_on_rename_folder (GtkAction *action,
3708 ModestWindow *window)
3710 modest_ui_actions_on_edit_mode_rename_folder (window);
3714 modest_ui_actions_on_edit_mode_rename_folder (ModestWindow *window)
3716 TnyFolderStore *folder;
3717 GtkWidget *folder_view;
3718 gboolean do_rename = TRUE;
3720 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3722 if (MODEST_IS_MAIN_WINDOW (window)) {
3723 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3724 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3728 #ifdef MODEST_TOOLKIT_HILDON2
3729 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3730 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3736 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3741 if (TNY_IS_FOLDER (folder)) {
3742 gchar *folder_name = NULL;
3744 const gchar *current_name;
3745 TnyFolderStore *parent;
3747 current_name = tny_folder_get_name (TNY_FOLDER (folder));
3748 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
3749 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (window),
3750 parent, current_name,
3752 g_object_unref (parent);
3754 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
3757 RenameFolderInfo *rename_folder_data = g_new0 (RenameFolderInfo, 1);
3758 rename_folder_data->folder = g_object_ref (folder);
3759 rename_folder_data->new_name = folder_name;
3760 modest_platform_connect_if_remote_and_perform (GTK_WINDOW(window), TRUE,
3761 folder, on_rename_folder_performer, rename_folder_data);
3764 g_object_unref (folder);
3769 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
3772 GObject *win = modest_mail_operation_get_source (mail_op);
3774 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
3775 _("mail_in_ui_folder_delete_error"),
3777 g_object_unref (win);
3781 TnyFolderStore *folder;
3782 gboolean move_to_trash;
3786 on_delete_folder_cb (gboolean canceled,
3788 GtkWindow *parent_window,
3789 TnyAccount *account,
3792 DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
3793 GtkWidget *folder_view;
3794 ModestMailOperation *mail_op;
3795 GtkTreeSelection *sel;
3797 if (!MODEST_IS_WINDOW(parent_window) || canceled || (err!=NULL)) {
3798 /* Note that the connection process can fail due to
3799 memory low conditions as it can not successfully
3800 store the summary */
3801 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3802 (GtkWidget*) parent_window, err,
3804 g_debug ("Error connecting when trying to delete a folder");
3805 g_object_unref (G_OBJECT (info->folder));
3810 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
3811 folder_view = modest_main_window_get_child_widget (
3812 MODEST_MAIN_WINDOW (parent_window),
3813 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3814 #ifdef MODEST_TOOLKIT_HILDON2
3815 } else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3816 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (parent_window)));
3819 g_object_unref (G_OBJECT (info->folder));
3824 /* Unselect the folder before deleting it to free the headers */
3825 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3826 gtk_tree_selection_unselect_all (sel);
3828 /* Create the mail operation */
3830 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3831 modest_ui_actions_delete_folder_error_handler,
3834 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3836 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
3838 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
3840 g_object_unref (G_OBJECT (mail_op));
3841 g_object_unref (G_OBJECT (info->folder));
3846 delete_folder (ModestWindow *window, gboolean move_to_trash)
3848 TnyFolderStore *folder;
3849 GtkWidget *folder_view;
3853 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3855 if (MODEST_IS_MAIN_WINDOW (window)) {
3857 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3858 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3859 #ifdef MODEST_TOOLKIT_HILDON2
3860 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3861 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3869 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3874 /* Show an error if it's an account */
3875 if (!TNY_IS_FOLDER (folder)) {
3876 modest_platform_run_information_dialog (GTK_WINDOW (window),
3877 _("mail_in_ui_folder_delete_error"),
3879 g_object_unref (G_OBJECT (folder));
3884 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
3885 tny_folder_get_name (TNY_FOLDER (folder)));
3886 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
3887 (const gchar *) message);
3890 if (response == GTK_RESPONSE_OK) {
3891 DeleteFolderInfo *info;
3892 info = g_new0(DeleteFolderInfo, 1);
3893 info->folder = folder;
3894 info->move_to_trash = move_to_trash;
3895 g_object_ref (G_OBJECT (info->folder));
3896 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder));
3897 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (window),
3899 TNY_FOLDER_STORE (account),
3900 on_delete_folder_cb, info);
3901 g_object_unref (account);
3906 g_object_unref (G_OBJECT (folder));
3910 modest_ui_actions_on_delete_folder (GtkAction *action,
3911 ModestWindow *window)
3913 modest_ui_actions_on_edit_mode_delete_folder (window);
3917 modest_ui_actions_on_edit_mode_delete_folder (ModestWindow *window)
3919 g_return_val_if_fail (MODEST_IS_WINDOW(window), TRUE);
3921 return delete_folder (window, FALSE);
3925 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
3927 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3929 delete_folder (MODEST_WINDOW (main_window), TRUE);
3933 typedef struct _PasswordDialogFields {
3934 GtkWidget *username;
3935 GtkWidget *password;
3937 } PasswordDialogFields;
3940 password_dialog_check_field (GtkEditable *editable,
3941 PasswordDialogFields *fields)
3944 gboolean any_value_empty = FALSE;
3946 #ifdef MODEST_TOOLKIT_HILDON2
3947 value = hildon_entry_get_text (HILDON_ENTRY (fields->username));
3949 value = gtk_entry_get_text (GTK_ENTRY (fields->username));
3951 if ((value == NULL) || value[0] == '\0') {
3952 any_value_empty = TRUE;
3954 #ifdef MODEST_TOOLKIT_HILDON2
3955 value = hildon_entry_get_text (HILDON_ENTRY (fields->password));
3957 value = gtk_entry_get_text (GTK_ENTRY (fields->password));
3959 if ((value == NULL) || value[0] == '\0') {
3960 any_value_empty = TRUE;
3962 gtk_dialog_set_response_sensitive (GTK_DIALOG (fields->dialog), GTK_RESPONSE_ACCEPT, !any_value_empty);
3966 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
3967 const gchar* server_account_name,
3972 ModestMainWindow *main_window)
3974 g_return_if_fail(server_account_name);
3975 gboolean completed = FALSE;
3976 PasswordDialogFields *fields = NULL;
3978 /* Initalize output parameters: */
3985 #ifndef MODEST_TOOLKIT_GTK
3986 /* Maemo uses a different (awkward) button order,
3987 * It should probably just use gtk_alternative_dialog_button_order ().
3989 #ifdef MODEST_TOOLKIT_HILDON2
3991 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3994 _HL("wdgt_bd_done"),
3995 GTK_RESPONSE_ACCEPT,
3997 gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
3998 HILDON_MARGIN_DOUBLE);
4001 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4004 _("mcen_bd_dialog_ok"),
4005 GTK_RESPONSE_ACCEPT,
4006 _("mcen_bd_dialog_cancel"),
4007 GTK_RESPONSE_REJECT,
4009 #endif /* MODEST_TOOLKIT_HILDON2 */
4012 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4016 GTK_RESPONSE_REJECT,
4018 GTK_RESPONSE_ACCEPT,
4020 #endif /* MODEST_TOOLKIT_GTK */
4022 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog), NULL);
4024 gchar *server_name = modest_account_mgr_get_server_account_hostname (
4025 modest_runtime_get_account_mgr(), server_account_name);
4026 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
4027 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
4030 gtk_widget_destroy (dialog);
4034 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
4035 GtkWidget *label = gtk_label_new (txt);
4036 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4038 g_free (server_name);
4039 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
4044 gchar *initial_username = modest_account_mgr_get_server_account_username (
4045 modest_runtime_get_account_mgr(), server_account_name);
4047 #ifdef MODEST_TOOLKIT_HILDON2
4048 GtkWidget *entry_username = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4049 if (initial_username)
4050 hildon_entry_set_text (HILDON_ENTRY (entry_username), initial_username);
4052 GtkWidget *entry_username = gtk_entry_new ();
4053 if (initial_username)
4054 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
4056 /* Dim this if a connection has ever succeeded with this username,
4057 * as per the UI spec: */
4058 /* const gboolean username_known = */
4059 /* modest_account_mgr_get_server_account_username_has_succeeded( */
4060 /* modest_runtime_get_account_mgr(), server_account_name); */
4061 /* gtk_widget_set_sensitive (entry_username, !username_known); */
4063 /* We drop the username sensitive code and disallow changing it here
4064 * as tinymail does not support really changing the username in the callback
4066 gtk_widget_set_sensitive (entry_username, FALSE);
4068 #ifndef MODEST_TOOLKIT_GTK
4069 /* Auto-capitalization is the default, so let's turn it off: */
4070 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
4072 /* Create a size group to be used by all captions.
4073 * Note that HildonCaption does not create a default size group if we do not specify one.
4074 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
4075 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
4077 #ifdef MODEST_TOOLKIT_HILDON2
4078 GtkWidget *caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4079 _("mail_fi_username"), FALSE,
4082 GtkWidget *caption = hildon_caption_new (sizegroup,
4083 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
4085 gtk_widget_show (entry_username);
4086 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4087 FALSE, FALSE, MODEST_MARGIN_HALF);
4088 gtk_widget_show (caption);
4090 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
4092 #endif /* !MODEST_TOOLKIT_GTK */
4095 #ifdef MODEST_TOOLKIT_HILDON2
4096 GtkWidget *entry_password = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4098 GtkWidget *entry_password = gtk_entry_new ();
4100 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
4101 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
4103 #ifndef MODEST_TOOLKIT_GTK
4104 /* Auto-capitalization is the default, so let's turn it off: */
4105 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
4106 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
4108 #ifdef MODEST_TOOLKIT_HILDON2
4109 caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4110 _("mail_fi_password"), FALSE,
4113 caption = hildon_caption_new (sizegroup,
4114 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
4116 gtk_widget_show (entry_password);
4117 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4118 FALSE, FALSE, MODEST_MARGIN_HALF);
4119 gtk_widget_show (caption);
4120 g_object_unref (sizegroup);
4122 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
4124 #endif /* !MODEST_TOOLKIT_GTK */
4126 if (initial_username != NULL)
4127 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
4129 /* This is not in the Maemo UI spec:
4130 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
4131 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
4135 fields = g_slice_new0 (PasswordDialogFields);
4136 fields->username = entry_username;
4137 fields->password = entry_password;
4138 fields->dialog = dialog;
4140 g_signal_connect (entry_username, "changed", G_CALLBACK (password_dialog_check_field), fields);
4141 g_signal_connect (entry_password, "changed", G_CALLBACK (password_dialog_check_field), fields);
4142 password_dialog_check_field (NULL, fields);
4144 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
4146 while (!completed) {
4148 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
4150 #ifdef MODEST_TOOLKIT_HILDON2
4151 *username = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_username)));
4153 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
4156 /* Note that an empty field becomes the "" string */
4157 if (*username && strlen (*username) > 0) {
4158 modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
4159 server_account_name,
4163 const gboolean username_was_changed =
4164 (strcmp (*username, initial_username) != 0);
4165 if (username_was_changed) {
4166 g_warning ("%s: tinymail does not yet support changing the "
4167 "username in the get_password() callback.\n", __FUNCTION__);
4173 modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
4174 _("mcen_ib_username_pw_incorrect"));
4180 #ifdef MODEST_TOOLKIT_HILDON2
4181 *password = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_password)));
4183 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
4186 /* We do not save the password in the configuration,
4187 * because this function is only called for passwords that should
4188 * not be remembered:
4189 modest_server_account_set_password (
4190 modest_runtime_get_account_mgr(), server_account_name,
4197 #ifndef MODEST_TOOLKIT_HILDON2
4198 /* Set parent to NULL or the banner will disappear with its parent dialog */
4199 modest_platform_information_banner(NULL, NULL, _("mail_ib_login_cancelled"));
4211 /* This is not in the Maemo UI spec:
4212 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
4218 g_free (initial_username);
4219 gtk_widget_destroy (dialog);
4220 g_slice_free (PasswordDialogFields, fields);
4222 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
4226 modest_ui_actions_on_cut (GtkAction *action,
4227 ModestWindow *window)
4229 GtkWidget *focused_widget;
4230 GtkClipboard *clipboard;
4232 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4233 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4234 if (GTK_IS_EDITABLE (focused_widget)) {
4235 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
4236 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4237 gtk_clipboard_store (clipboard);
4238 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4239 GtkTextBuffer *buffer;
4241 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4242 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4243 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
4244 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4245 gtk_clipboard_store (clipboard);
4247 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4248 TnyList *header_list = modest_header_view_get_selected_headers (
4249 MODEST_HEADER_VIEW (focused_widget));
4250 gboolean continue_download = FALSE;
4251 gint num_of_unc_msgs;
4253 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4255 if (num_of_unc_msgs) {
4256 TnyAccount *account = get_account_from_header_list (header_list);
4258 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4259 g_object_unref (account);
4263 if (num_of_unc_msgs == 0 || continue_download) {
4264 /* modest_platform_information_banner (
4265 NULL, NULL, _CS("mcen_ib_getting_items"));*/
4266 modest_header_view_cut_selection (
4267 MODEST_HEADER_VIEW (focused_widget));
4270 g_object_unref (header_list);
4271 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4272 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
4277 modest_ui_actions_on_copy (GtkAction *action,
4278 ModestWindow *window)
4280 GtkClipboard *clipboard;
4281 GtkWidget *focused_widget;
4282 gboolean copied = TRUE;
4284 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4285 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4287 if (GTK_IS_LABEL (focused_widget)) {
4289 selection = modest_text_utils_label_get_selection (GTK_LABEL (focused_widget));
4290 gtk_clipboard_set_text (clipboard, selection, -1);
4292 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4293 gtk_clipboard_store (clipboard);
4294 } else if (GTK_IS_EDITABLE (focused_widget)) {
4295 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
4296 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4297 gtk_clipboard_store (clipboard);
4298 } else if (GTK_IS_HTML (focused_widget)) {
4301 sel = gtk_html_get_selection_html (GTK_HTML (focused_widget), &len);
4302 if ((sel == NULL) || (sel[0] == '\0')) {
4305 gtk_html_copy (GTK_HTML (focused_widget));
4306 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4307 gtk_clipboard_store (clipboard);
4309 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4310 GtkTextBuffer *buffer;
4311 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4312 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4313 gtk_text_buffer_copy_clipboard (buffer, clipboard);
4314 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4315 gtk_clipboard_store (clipboard);
4317 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4318 TnyList *header_list = modest_header_view_get_selected_headers (
4319 MODEST_HEADER_VIEW (focused_widget));
4320 gboolean continue_download = FALSE;
4321 gint num_of_unc_msgs;
4323 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4325 if (num_of_unc_msgs) {
4326 TnyAccount *account = get_account_from_header_list (header_list);
4328 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4329 g_object_unref (account);
4333 if (num_of_unc_msgs == 0 || continue_download) {
4334 modest_platform_information_banner (
4335 NULL, NULL, _CS("mcen_ib_getting_items"));
4336 modest_header_view_copy_selection (
4337 MODEST_HEADER_VIEW (focused_widget));
4341 g_object_unref (header_list);
4343 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4344 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
4347 /* Show information banner if there was a copy to clipboard */
4349 modest_platform_information_banner (
4350 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
4354 modest_ui_actions_on_undo (GtkAction *action,
4355 ModestWindow *window)
4357 ModestEmailClipboard *clipboard = NULL;
4359 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4360 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
4361 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4362 /* Clear clipboard source */
4363 clipboard = modest_runtime_get_email_clipboard ();
4364 modest_email_clipboard_clear (clipboard);
4367 g_return_if_reached ();
4372 modest_ui_actions_on_redo (GtkAction *action,
4373 ModestWindow *window)
4375 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4376 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
4379 g_return_if_reached ();
4385 destroy_information_note (ModestMailOperation *mail_op,
4388 /* destroy information note */
4389 gtk_widget_destroy (GTK_WIDGET(user_data));
4393 destroy_folder_information_note (ModestMailOperation *mail_op,
4394 TnyFolder *new_folder,
4397 /* destroy information note */
4398 gtk_widget_destroy (GTK_WIDGET(user_data));
4403 paste_as_attachment_free (gpointer data)
4405 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
4407 if (helper->banner) {
4408 gtk_widget_destroy (helper->banner);
4409 g_object_unref (helper->banner);
4415 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
4420 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
4421 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
4426 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
4431 modest_ui_actions_on_paste (GtkAction *action,
4432 ModestWindow *window)
4434 GtkWidget *focused_widget = NULL;
4435 GtkWidget *inf_note = NULL;
4436 ModestMailOperation *mail_op = NULL;
4438 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4439 if (GTK_IS_EDITABLE (focused_widget)) {
4440 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
4441 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4442 ModestEmailClipboard *e_clipboard = NULL;
4443 e_clipboard = modest_runtime_get_email_clipboard ();
4444 if (modest_email_clipboard_cleared (e_clipboard)) {
4445 GtkTextBuffer *buffer;
4446 GtkClipboard *clipboard;
4448 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4449 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4450 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
4451 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4452 ModestMailOperation *mail_op;
4453 TnyFolder *src_folder = NULL;
4454 TnyList *data = NULL;
4456 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
4457 helper->window = MODEST_MSG_EDIT_WINDOW (window);
4458 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4459 _CS("ckct_nw_pasting"));
4460 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
4461 mail_op = modest_mail_operation_new (G_OBJECT (window));
4462 if (helper->banner != NULL) {
4463 g_object_ref (G_OBJECT (helper->banner));
4464 gtk_widget_show (GTK_WIDGET (helper->banner));
4468 modest_mail_operation_get_msgs_full (mail_op,
4470 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
4472 paste_as_attachment_free);
4476 g_object_unref (data);
4478 g_object_unref (src_folder);
4481 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4482 ModestEmailClipboard *clipboard = NULL;
4483 TnyFolder *src_folder = NULL;
4484 TnyFolderStore *folder_store = NULL;
4485 TnyList *data = NULL;
4486 gboolean delete = FALSE;
4488 /* Check clipboard source */
4489 clipboard = modest_runtime_get_email_clipboard ();
4490 if (modest_email_clipboard_cleared (clipboard))
4493 /* Get elements to paste */
4494 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
4496 /* Create a new mail operation */
4497 mail_op = modest_mail_operation_new (G_OBJECT(window));
4499 /* Get destination folder */
4500 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
4502 /* transfer messages */
4506 /* Ask for user confirmation */
4508 modest_ui_actions_msgs_move_to_confirmation (window,
4509 TNY_FOLDER (folder_store),
4513 if (response == GTK_RESPONSE_OK) {
4514 /* Launch notification */
4515 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4516 _CS("ckct_nw_pasting"));
4517 if (inf_note != NULL) {
4518 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4519 gtk_widget_show (GTK_WIDGET(inf_note));
4522 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4523 modest_mail_operation_xfer_msgs (mail_op,
4525 TNY_FOLDER (folder_store),
4527 destroy_information_note,
4530 g_object_unref (mail_op);
4533 } else if (src_folder != NULL) {
4534 /* Launch notification */
4535 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4536 _CS("ckct_nw_pasting"));
4537 if (inf_note != NULL) {
4538 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4539 gtk_widget_show (GTK_WIDGET(inf_note));
4542 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4543 modest_mail_operation_xfer_folder (mail_op,
4547 destroy_folder_information_note,
4553 g_object_unref (data);
4554 if (src_folder != NULL)
4555 g_object_unref (src_folder);
4556 if (folder_store != NULL)
4557 g_object_unref (folder_store);
4563 modest_ui_actions_on_select_all (GtkAction *action,
4564 ModestWindow *window)
4566 GtkWidget *focused_widget;
4568 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4569 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
4570 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
4571 } else if (GTK_IS_LABEL (focused_widget)) {
4572 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
4573 } else if (GTK_IS_EDITABLE (focused_widget)) {
4574 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
4575 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4576 GtkTextBuffer *buffer;
4577 GtkTextIter start, end;
4579 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4580 gtk_text_buffer_get_start_iter (buffer, &start);
4581 gtk_text_buffer_get_end_iter (buffer, &end);
4582 gtk_text_buffer_select_range (buffer, &start, &end);
4583 } else if (GTK_IS_HTML (focused_widget)) {
4584 gtk_html_select_all (GTK_HTML (focused_widget));
4585 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4586 GtkWidget *header_view = focused_widget;
4587 GtkTreeSelection *selection = NULL;
4589 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
4590 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
4591 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4594 /* Disable window dimming management */
4595 modest_window_disable_dimming (MODEST_WINDOW(window));
4597 /* Select all messages */
4598 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
4599 gtk_tree_selection_select_all (selection);
4601 /* Set focuse on header view */
4602 gtk_widget_grab_focus (header_view);
4604 /* Enable window dimming management */
4605 modest_window_enable_dimming (MODEST_WINDOW(window));
4606 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
4607 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
4613 modest_ui_actions_on_mark_as_read (GtkAction *action,
4614 ModestWindow *window)
4616 g_return_if_fail (MODEST_IS_WINDOW(window));
4618 /* Mark each header as read */
4619 do_headers_action (window, headers_action_mark_as_read, NULL);
4623 modest_ui_actions_on_mark_as_unread (GtkAction *action,
4624 ModestWindow *window)
4626 g_return_if_fail (MODEST_IS_WINDOW(window));
4628 /* Mark each header as read */
4629 do_headers_action (window, headers_action_mark_as_unread, NULL);
4633 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
4634 GtkRadioAction *selected,
4635 ModestWindow *window)
4639 value = gtk_radio_action_get_current_value (selected);
4640 if (MODEST_IS_WINDOW (window)) {
4641 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
4646 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
4647 GtkRadioAction *selected,
4648 ModestWindow *window)
4650 TnyHeaderFlags flags;
4651 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4653 flags = gtk_radio_action_get_current_value (selected);
4654 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
4658 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
4659 GtkRadioAction *selected,
4660 ModestWindow *window)
4664 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4666 file_format = gtk_radio_action_get_current_value (selected);
4667 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
4672 modest_ui_actions_on_zoom_plus (GtkAction *action,
4673 ModestWindow *window)
4675 g_return_if_fail (MODEST_IS_WINDOW (window));
4677 modest_window_zoom_plus (MODEST_WINDOW (window));
4681 modest_ui_actions_on_zoom_minus (GtkAction *action,
4682 ModestWindow *window)
4684 g_return_if_fail (MODEST_IS_WINDOW (window));
4686 modest_window_zoom_minus (MODEST_WINDOW (window));
4690 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
4691 ModestWindow *window)
4693 ModestWindowMgr *mgr;
4694 gboolean fullscreen, active;
4695 g_return_if_fail (MODEST_IS_WINDOW (window));
4697 mgr = modest_runtime_get_window_mgr ();
4699 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
4700 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4702 if (active != fullscreen) {
4703 modest_window_mgr_set_fullscreen_mode (mgr, active);
4704 #ifndef MODEST_TOOLKIT_HILDON2
4705 gtk_window_present (GTK_WINDOW (window));
4711 modest_ui_actions_on_change_fullscreen (GtkAction *action,
4712 ModestWindow *window)
4714 ModestWindowMgr *mgr;
4715 gboolean fullscreen;
4717 g_return_if_fail (MODEST_IS_WINDOW (window));
4719 mgr = modest_runtime_get_window_mgr ();
4720 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4721 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
4723 #ifndef MODEST_TOOLKIT_HILDON2
4724 gtk_window_present (GTK_WINDOW (window));
4729 * Used by modest_ui_actions_on_details to call do_headers_action
4732 headers_action_show_details (TnyHeader *header,
4733 ModestWindow *window,
4737 gboolean async_retrieval;
4740 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4741 async_retrieval = TRUE;
4742 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (window));
4744 async_retrieval = FALSE;
4746 modest_platform_run_header_details_dialog (GTK_WINDOW (window), header, async_retrieval, msg);
4748 g_object_unref (msg);
4752 * Show the header details in a ModestDetailsDialog widget
4755 modest_ui_actions_on_details (GtkAction *action,
4758 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4762 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
4766 header = tny_msg_get_header (msg);
4768 headers_action_show_details (header, win, NULL);
4769 g_object_unref (header);
4771 g_object_unref (msg);
4773 } else if (MODEST_IS_MAIN_WINDOW (win)) {
4774 GtkWidget *folder_view, *header_view;
4776 /* Check which widget has the focus */
4777 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4778 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4779 if (gtk_widget_is_focus (folder_view)) {
4780 TnyFolderStore *folder_store
4781 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4782 if (!folder_store) {
4783 g_warning ("%s: No item was selected.\n", __FUNCTION__);
4786 /* Show only when it's a folder */
4787 /* This function should not be called for account items,
4788 * because we dim the menu item for them. */
4789 if (TNY_IS_FOLDER (folder_store)) {
4790 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4791 TNY_FOLDER (folder_store));
4794 g_object_unref (folder_store);
4797 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4798 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4799 /* Show details of each header */
4800 do_headers_action (win, headers_action_show_details, header_view);
4802 #ifdef MODEST_TOOLKIT_HILDON2
4803 } else if (MODEST_IS_HEADER_WINDOW (win)) {
4805 GtkWidget *header_view;
4807 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
4808 folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
4810 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4812 g_object_unref (folder);
4819 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
4820 ModestMsgEditWindow *window)
4822 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4824 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
4828 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
4829 ModestMsgEditWindow *window)
4831 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4833 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
4837 modest_ui_actions_toggle_folders_view (GtkAction *action,
4838 ModestMainWindow *main_window)
4840 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
4842 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
4843 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
4845 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
4849 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
4850 ModestWindow *window)
4852 gboolean active, fullscreen = FALSE;
4853 ModestWindowMgr *mgr;
4855 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
4857 /* Check if we want to toggle the toolbar view in fullscreen
4859 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
4860 "ViewShowToolbarFullScreen")) {
4864 /* Toggle toolbar */
4865 mgr = modest_runtime_get_window_mgr ();
4866 modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
4870 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
4871 ModestMsgEditWindow *window)
4873 modest_msg_edit_window_select_font (window);
4878 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
4879 const gchar *display_name,
4882 /* don't update the display name if it was already set;
4883 * updating the display name apparently is expensive */
4884 const gchar* old_name = gtk_window_get_title (window);
4886 if (display_name == NULL)
4889 if (old_name && display_name && strcmp (old_name, display_name) == 0)
4890 return; /* don't do anything */
4892 /* This is usually used to change the title of the main window, which
4893 * is the one that holds the folder view. Note that this change can
4894 * happen even when the widget doesn't have the focus. */
4895 gtk_window_set_title (window, display_name);
4900 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
4902 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4903 modest_msg_edit_window_select_contacts (window);
4907 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
4909 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4910 modest_msg_edit_window_check_names (window, FALSE);
4913 #ifndef MODEST_TOOLKIT_HILDON2
4915 * This function is used to track changes in the selection of the
4916 * folder view that is inside the "move to" dialog to enable/disable
4917 * the OK button because we do not want the user to select a disallowed
4918 * destination for a folder.
4919 * The user also not desired to be able to use NEW button on items where
4920 * folder creation is not possibel.
4923 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
4924 TnyFolderStore *folder_store,
4928 GtkWidget *dialog = NULL;
4929 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
4930 gboolean moving_folder = FALSE;
4931 gboolean is_local_account = TRUE;
4932 GtkWidget *folder_view = NULL;
4933 ModestTnyFolderRules rules;
4935 g_return_if_fail (MODEST_IS_FOLDER_VIEW(self));
4940 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
4944 /* check if folder_store is an remote account */
4945 if (TNY_IS_ACCOUNT (folder_store)) {
4946 TnyAccount *local_account = NULL;
4947 TnyAccount *mmc_account = NULL;
4948 ModestTnyAccountStore *account_store = NULL;
4950 account_store = modest_runtime_get_account_store ();
4951 local_account = modest_tny_account_store_get_local_folders_account (account_store);
4952 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
4954 if ((gpointer) local_account != (gpointer) folder_store &&
4955 (gpointer) mmc_account != (gpointer) folder_store) {
4956 ModestProtocolType proto;
4957 proto = modest_tny_account_get_protocol_type (TNY_ACCOUNT (folder_store));
4958 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
4959 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
4961 is_local_account = FALSE;
4962 /* New button should be dimmed on remote
4964 new_sensitive = (modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
4966 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS));
4968 g_object_unref (local_account);
4970 /* It could not exist */
4972 g_object_unref (mmc_account);
4975 /* Check the target folder rules */
4976 if (TNY_IS_FOLDER (folder_store)) {
4977 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
4978 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
4979 ok_sensitive = FALSE;
4980 new_sensitive = FALSE;
4985 /* Check if we're moving a folder */
4986 if (MODEST_IS_MAIN_WINDOW (user_data)) {
4987 /* Get the widgets */
4988 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
4989 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4990 if (gtk_widget_is_focus (folder_view))
4991 moving_folder = TRUE;
4994 if (moving_folder) {
4995 TnyFolderStore *moved_folder = NULL, *parent = NULL;
4997 /* Get the folder to move */
4998 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5000 /* Check that we're not moving to the same folder */
5001 if (TNY_IS_FOLDER (moved_folder)) {
5002 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
5003 if (parent == folder_store)
5004 ok_sensitive = FALSE;
5005 g_object_unref (parent);
5008 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
5009 /* Do not allow to move to an account unless it's the
5010 local folders account */
5011 if (!is_local_account)
5012 ok_sensitive = FALSE;
5015 if (ok_sensitive && (moved_folder == folder_store)) {
5016 /* Do not allow to move to itself */
5017 ok_sensitive = FALSE;
5019 g_object_unref (moved_folder);
5021 TnyFolder *src_folder = NULL;
5023 /* Moving a message */
5024 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
5026 TnyHeader *header = NULL;
5027 header = modest_msg_view_window_get_header
5028 (MODEST_MSG_VIEW_WINDOW (user_data));
5029 if (!TNY_IS_HEADER(header))
5030 g_warning ("%s: could not get source header", __FUNCTION__);
5032 src_folder = tny_header_get_folder (header);
5035 g_object_unref (header);
5038 TNY_FOLDER (modest_folder_view_get_selected
5039 (MODEST_FOLDER_VIEW (folder_view)));
5042 if (TNY_IS_FOLDER(src_folder)) {
5043 /* Do not allow to move the msg to the same folder */
5044 /* Do not allow to move the msg to an account */
5045 if ((gpointer) src_folder == (gpointer) folder_store ||
5046 TNY_IS_ACCOUNT (folder_store))
5047 ok_sensitive = FALSE;
5048 g_object_unref (src_folder);
5050 g_warning ("%s: could not get source folder", __FUNCTION__);
5054 /* Set sensitivity of the OK and NEW button */
5055 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, ok_sensitive);
5056 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_GTK_RESPONSE_NEW_FOLDER, new_sensitive);
5061 on_move_to_dialog_response (GtkDialog *dialog,
5065 GtkWidget *parent_win;
5066 MoveToInfo *helper = NULL;
5067 ModestFolderView *folder_view;
5068 gboolean unset_edit_mode = FALSE;
5070 helper = (MoveToInfo *) user_data;
5072 parent_win = (GtkWidget *) helper->win;
5073 folder_view = MODEST_FOLDER_VIEW (g_object_get_data (G_OBJECT (dialog),
5074 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
5077 TnyFolderStore *dst_folder;
5078 TnyFolderStore *selected;
5080 case MODEST_GTK_RESPONSE_NEW_FOLDER:
5081 selected = modest_folder_view_get_selected (folder_view);
5082 modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view), selected);
5083 g_object_unref (selected);
5085 case GTK_RESPONSE_NONE:
5086 case GTK_RESPONSE_CANCEL:
5087 case GTK_RESPONSE_DELETE_EVENT:
5089 case GTK_RESPONSE_OK:
5090 dst_folder = modest_folder_view_get_selected (folder_view);
5092 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
5093 /* Clean list to move used for filtering */
5094 modest_folder_view_set_list_to_move (folder_view, NULL);
5096 modest_ui_actions_on_main_window_move_to (NULL,
5097 GTK_WIDGET (folder_view),
5099 MODEST_MAIN_WINDOW (parent_win));
5100 #ifdef MODEST_TOOLKIT_HILDON2
5101 } else if (MODEST_IS_FOLDER_WINDOW (parent_win)) {
5102 /* Clean list to move used for filtering */
5103 modest_folder_view_set_list_to_move (folder_view, NULL);
5105 modest_ui_actions_on_folder_window_move_to (GTK_WIDGET (folder_view),
5108 GTK_WINDOW (parent_win));
5111 /* if the user selected a root folder
5112 (account) then do not perform any action */
5113 if (TNY_IS_ACCOUNT (dst_folder)) {
5114 g_signal_stop_emission_by_name (dialog, "response");
5118 /* Clean list to move used for filtering */
5119 modest_folder_view_set_list_to_move (folder_view, NULL);
5121 /* Moving from headers window in edit mode */
5122 modest_ui_actions_on_window_move_to (NULL, helper->list,
5124 MODEST_WINDOW (parent_win));
5128 g_object_unref (dst_folder);
5130 unset_edit_mode = TRUE;
5133 g_warning ("%s unexpected response id %d", __FUNCTION__, response);
5136 /* Free the helper and exit */
5138 g_object_unref (helper->list);
5139 if (unset_edit_mode) {
5140 #ifdef MODEST_TOOLKIT_HILDON2
5141 modest_hildon2_window_unset_edit_mode (MODEST_HILDON2_WINDOW (helper->win));
5144 g_slice_free (MoveToInfo, helper);
5145 gtk_widget_destroy (GTK_WIDGET (dialog));
5149 create_move_to_dialog (GtkWindow *win,
5150 GtkWidget *folder_view,
5151 TnyList *list_to_move)
5153 GtkWidget *dialog, *tree_view = NULL;
5155 dialog = modest_platform_create_move_to_dialog (win, &tree_view);
5157 #ifndef MODEST_TOOLKIT_HILDON2
5158 /* Track changes in the selection to
5159 * disable the OK button whenever "Move to" is not possible
5160 * disbale NEW button whenever New is not possible */
5161 g_signal_connect (tree_view,
5162 "folder_selection_changed",
5163 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
5167 /* It could happen that we're trying to move a message from a
5168 window (msg window for example) after the main window was
5169 closed, so we can not just get the model of the folder
5171 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
5172 const gchar *visible_id = NULL;
5174 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5175 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5176 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
5177 MODEST_FOLDER_VIEW(tree_view));
5180 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
5182 /* Show the same account than the one that is shown in the main window */
5183 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(tree_view),
5186 const gchar *active_account_name = NULL;
5187 ModestAccountMgr *mgr = NULL;
5188 ModestAccountSettings *settings = NULL;
5189 ModestServerAccountSettings *store_settings = NULL;
5191 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5192 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5193 modest_folder_view_update_model (MODEST_FOLDER_VIEW (tree_view),
5194 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
5196 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
5197 mgr = modest_runtime_get_account_mgr ();
5198 settings = modest_account_mgr_load_account_settings (mgr, active_account_name);
5201 const gchar *store_account_name;
5202 store_settings = modest_account_settings_get_store_settings (settings);
5203 store_account_name = modest_server_account_settings_get_account_name (store_settings);
5205 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (tree_view),
5206 store_account_name);
5207 g_object_unref (store_settings);
5208 g_object_unref (settings);
5212 /* we keep a pointer to the embedded folder view, so we can
5213 * retrieve it with get_folder_view_from_move_to_dialog (see
5214 * above) later (needed for focus handling)
5216 g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, tree_view);
5218 /* Hide special folders */
5219 #ifndef MODEST_TOOLKIT_HILDON2
5220 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
5223 modest_folder_view_set_list_to_move (MODEST_FOLDER_VIEW (tree_view), list_to_move);
5224 #ifndef MODEST_TOOLKIT_HILDON2
5225 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
5228 gtk_widget_show (GTK_WIDGET (tree_view));
5234 * Shows a confirmation dialog to the user when we're moving messages
5235 * from a remote server to the local storage. Returns the dialog
5236 * response. If it's other kind of movement then it always returns
5239 * This one is used by the next functions:
5240 * modest_ui_actions_on_paste - commented out
5241 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
5244 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
5245 TnyFolder *dest_folder,
5249 gint response = GTK_RESPONSE_OK;
5250 TnyAccount *account = NULL;
5251 TnyFolder *src_folder = NULL;
5252 TnyIterator *iter = NULL;
5253 TnyHeader *header = NULL;
5255 /* return with OK if the destination is a remote folder */
5256 if (modest_tny_folder_is_remote_folder (dest_folder))
5257 return GTK_RESPONSE_OK;
5259 /* Get source folder */
5260 iter = tny_list_create_iterator (headers);
5261 header = TNY_HEADER (tny_iterator_get_current (iter));
5263 src_folder = tny_header_get_folder (header);
5264 g_object_unref (header);
5266 g_object_unref (iter);
5268 /* if no src_folder, message may be an attahcment */
5269 if (src_folder == NULL)
5270 return GTK_RESPONSE_CANCEL;
5272 /* If the source is a local or MMC folder */
5273 if (!modest_tny_folder_is_remote_folder (src_folder)) {
5274 g_object_unref (src_folder);
5275 return GTK_RESPONSE_OK;
5278 /* Get the account */
5279 account = tny_folder_get_account (src_folder);
5281 /* now if offline we ask the user */
5282 if(connect_to_get_msg (win, tny_list_get_length (headers), account))
5283 response = GTK_RESPONSE_OK;
5285 response = GTK_RESPONSE_CANCEL;
5288 g_object_unref (src_folder);
5289 g_object_unref (account);
5295 move_to_helper_destroyer (gpointer user_data)
5297 MoveToHelper *helper = (MoveToHelper *) user_data;
5299 /* Close the "Pasting" information banner */
5300 if (helper->banner) {
5301 gtk_widget_destroy (GTK_WIDGET (helper->banner));
5302 g_object_unref (helper->banner);
5304 if (gtk_tree_row_reference_valid (helper->reference)) {
5305 gtk_tree_row_reference_free (helper->reference);
5306 helper->reference = NULL;
5312 move_to_cb (ModestMailOperation *mail_op,
5315 MoveToHelper *helper = (MoveToHelper *) user_data;
5316 GObject *object = modest_mail_operation_get_source (mail_op);
5318 /* Note that the operation could have failed, in that case do
5320 if (modest_mail_operation_get_status (mail_op) !=
5321 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
5324 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
5325 ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
5327 if (!modest_msg_view_window_select_next_message (self) &&
5328 !modest_msg_view_window_select_previous_message (self)) {
5329 /* No more messages to view, so close this window */
5330 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
5332 } else if (MODEST_IS_MAIN_WINDOW (object) &&
5333 gtk_tree_row_reference_valid (helper->reference)) {
5334 GtkWidget *header_view;
5336 GtkTreeSelection *sel;
5338 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5339 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5340 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
5341 path = gtk_tree_row_reference_get_path (helper->reference);
5342 /* We need to unselect the previous one
5343 because we could be copying instead of
5345 gtk_tree_selection_unselect_all (sel);
5346 gtk_tree_selection_select_path (sel, path);
5347 gtk_tree_path_free (path);
5349 g_object_unref (object);
5352 /* Destroy the helper */
5353 move_to_helper_destroyer (helper);
5357 folder_move_to_cb (ModestMailOperation *mail_op,
5358 TnyFolder *new_folder,
5361 GtkWidget *folder_view;
5364 object = modest_mail_operation_get_source (mail_op);
5365 if (MODEST_IS_MAIN_WINDOW (object)) {
5366 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5367 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5368 g_object_ref (folder_view);
5369 g_object_unref (object);
5370 move_to_cb (mail_op, user_data);
5371 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), new_folder, FALSE);
5372 g_object_unref (folder_view);
5374 move_to_cb (mail_op, user_data);
5379 msgs_move_to_cb (ModestMailOperation *mail_op,
5382 move_to_cb (mail_op, user_data);
5386 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
5389 GObject *win = NULL;
5390 const GError *error;
5391 TnyAccount *account = NULL;
5393 #ifndef MODEST_TOOLKIT_HILDON2
5394 ModestWindow *main_window = NULL;
5396 /* Disable next automatic folder selection */
5397 main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
5398 FALSE); /* don't create */
5400 /* Show notification dialog only if the main window exists */
5402 GtkWidget *folder_view = NULL;
5404 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
5405 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5406 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
5408 if (user_data && TNY_IS_FOLDER (user_data)) {
5409 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
5410 TNY_FOLDER (user_data), FALSE);
5414 win = modest_mail_operation_get_source (mail_op);
5415 error = modest_mail_operation_get_error (mail_op);
5417 if (TNY_IS_FOLDER (user_data))
5418 account = modest_tny_folder_get_account (TNY_FOLDER (user_data));
5419 else if (TNY_IS_ACCOUNT (user_data))
5420 account = g_object_ref (user_data);
5422 /* If it's not a disk full error then show a generic error */
5423 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5424 (GtkWidget *) win, (GError *) error,
5426 modest_platform_run_information_dialog ((GtkWindow *) win,
5427 _("mail_in_ui_folder_move_target_error"),
5430 g_object_unref (account);
5432 g_object_unref (win);
5436 open_msg_for_purge_cb (ModestMailOperation *mail_op,
5445 gint pending_purges = 0;
5446 gboolean some_purged = FALSE;
5447 ModestWindow *win = MODEST_WINDOW (user_data);
5448 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
5450 /* If there was any error */
5451 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
5452 modest_window_mgr_unregister_header (mgr, header);
5456 /* Once the message has been retrieved for purging, we check if
5457 * it's all ok for purging */
5459 parts = tny_simple_list_new ();
5460 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
5461 iter = tny_list_create_iterator (parts);
5463 while (!tny_iterator_is_done (iter)) {
5465 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5466 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
5467 if (tny_mime_part_is_purged (part))
5474 g_object_unref (part);
5476 tny_iterator_next (iter);
5478 g_object_unref (iter);
5481 if (pending_purges>0) {
5483 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
5485 if (response == GTK_RESPONSE_OK) {
5488 modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_me_inbox_remove_attachments"));
5489 iter = tny_list_create_iterator (parts);
5490 while (!tny_iterator_is_done (iter)) {
5493 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5494 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
5495 tny_mime_part_set_purged (part);
5498 g_object_unref (part);
5500 tny_iterator_next (iter);
5502 g_object_unref (iter);
5504 tny_msg_rewrite_cache (msg);
5506 gtk_widget_destroy (info);
5510 modest_window_mgr_unregister_header (mgr, header);
5512 g_object_unref (parts);
5516 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
5517 ModestMainWindow *win)
5519 GtkWidget *header_view;
5520 TnyList *header_list;
5522 TnyHeaderFlags flags;
5523 ModestWindow *msg_view_window = NULL;
5526 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5528 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
5529 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5531 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
5533 g_warning ("%s: no header selected", __FUNCTION__);
5537 if (tny_list_get_length (header_list) == 1) {
5538 TnyIterator *iter = tny_list_create_iterator (header_list);
5539 header = TNY_HEADER (tny_iterator_get_current (iter));
5540 g_object_unref (iter);
5544 if (!header || !TNY_IS_HEADER(header)) {
5545 g_warning ("%s: header is not valid", __FUNCTION__);
5549 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
5550 header, &msg_view_window);
5551 flags = tny_header_get_flags (header);
5552 if (!(flags & TNY_HEADER_FLAG_CACHED))
5555 if (msg_view_window != NULL)
5556 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
5558 /* do nothing; uid was registered before, so window is probably on it's way */
5559 g_debug ("header %p has already been registered", header);
5562 ModestMailOperation *mail_op = NULL;
5563 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
5564 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
5565 modest_ui_actions_disk_operations_error_handler,
5567 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
5568 modest_mail_operation_get_msg (mail_op, header, FALSE, open_msg_for_purge_cb, win);
5570 g_object_unref (mail_op);
5573 g_object_unref (header);
5575 g_object_unref (header_list);
5579 * Checks if we need a connection to do the transfer and if the user
5580 * wants to connect to complete it
5583 modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
5584 TnyFolderStore *src_folder,
5586 TnyFolder *dst_folder,
5587 gboolean delete_originals,
5588 gboolean *need_connection,
5591 TnyAccount *src_account;
5592 gint uncached_msgs = 0;
5594 /* We don't need any further check if
5596 * 1- the source folder is local OR
5597 * 2- the device is already online
5599 if (!modest_tny_folder_store_is_remote (src_folder) ||
5600 tny_device_is_online (modest_runtime_get_device())) {
5601 *need_connection = FALSE;
5606 /* We must ask for a connection when
5608 * - the message(s) is not already cached OR
5609 * - the message(s) is cached but the leave_on_server setting
5610 * is FALSE (because we need to sync the source folder to
5611 * delete the message from the server (for IMAP we could do it
5612 * offline, it'll take place the next time we get a
5615 uncached_msgs = header_list_count_uncached_msgs (headers);
5616 src_account = get_account_from_folder_store (src_folder);
5617 if (uncached_msgs > 0) {
5621 *need_connection = TRUE;
5622 num_headers = tny_list_get_length (headers);
5623 msg = ngettext ("mcen_nc_get_msg", "mcen_nc_get_msgs", num_headers);
5625 if (modest_platform_run_confirmation_dialog (parent_window, msg) ==
5626 GTK_RESPONSE_CANCEL) {
5632 /* The transfer is possible and the user wants to */
5635 if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
5636 const gchar *account_name;
5637 gboolean leave_on_server;
5639 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
5640 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
5643 if (leave_on_server == TRUE) {
5644 *need_connection = FALSE;
5646 *need_connection = TRUE;
5649 *need_connection = FALSE;
5654 g_object_unref (src_account);
5658 xfer_messages_error_handler (ModestMailOperation *mail_op,
5662 const GError *error;
5663 TnyAccount *account;
5665 win = modest_mail_operation_get_source (mail_op);
5666 error = modest_mail_operation_get_error (mail_op);
5667 account = modest_mail_operation_get_account (mail_op);
5669 if (error && modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
5670 (GError *) error, account)) {
5671 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
5672 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
5675 modest_platform_run_information_dialog ((GtkWindow *) win,
5676 _("mail_in_ui_folder_move_target_error"),
5680 g_object_unref (account);
5682 g_object_unref (win);
5686 TnyFolderStore *dst_folder;
5691 * Utility function that transfer messages from both the main window
5692 * and the msg view window when using the "Move to" dialog
5695 xfer_messages_performer (gboolean canceled,
5697 GtkWindow *parent_window,
5698 TnyAccount *account,
5701 ModestWindow *win = MODEST_WINDOW (parent_window);
5702 TnyAccount *dst_account = NULL;
5703 gboolean dst_forbids_message_add = FALSE;
5704 XferMsgsHelper *helper;
5705 MoveToHelper *movehelper;
5706 ModestMailOperation *mail_op;
5708 helper = (XferMsgsHelper *) user_data;
5710 if (canceled || err) {
5711 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5712 (GtkWidget *) parent_window, err,
5714 /* Show the proper error message */
5715 modest_ui_actions_on_account_connection_error (parent_window, account);
5720 dst_account = tny_folder_get_account (TNY_FOLDER (helper->dst_folder));
5722 /* tinymail will return NULL for local folders it seems */
5723 dst_forbids_message_add = modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
5724 modest_tny_account_get_protocol_type (dst_account),
5725 MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
5726 g_object_unref (dst_account);
5728 if (dst_forbids_message_add) {
5729 modest_platform_information_banner (GTK_WIDGET (win),
5731 ngettext("mail_in_ui_folder_move_target_error",
5732 "mail_in_ui_folder_move_targets_error",
5733 tny_list_get_length (helper->headers)));
5737 movehelper = g_new0 (MoveToHelper, 1);
5739 #ifndef MODEST_TOOLKIT_HILDON2
5740 movehelper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
5741 _CS("ckct_nw_pasting"));
5742 if (movehelper->banner != NULL) {
5743 g_object_ref (movehelper->banner);
5744 gtk_widget_show (GTK_WIDGET (movehelper->banner));
5748 if (MODEST_IS_MAIN_WINDOW (win)) {
5749 GtkWidget *header_view =
5750 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
5751 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5752 movehelper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
5755 /* Perform the mail operation */
5756 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(win),
5757 xfer_messages_error_handler,
5759 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5762 modest_mail_operation_xfer_msgs (mail_op,
5764 TNY_FOLDER (helper->dst_folder),
5769 g_object_unref (G_OBJECT (mail_op));
5771 g_object_unref (helper->dst_folder);
5772 g_object_unref (helper->headers);
5773 g_slice_free (XferMsgsHelper, helper);
5777 TnyFolder *src_folder;
5778 TnyFolderStore *dst_folder;
5779 gboolean delete_original;
5780 GtkWidget *folder_view;
5784 on_move_folder_cb (gboolean canceled,
5786 GtkWindow *parent_window,
5787 TnyAccount *account,
5790 MoveFolderInfo *info = (MoveFolderInfo*)user_data;
5791 GtkTreeSelection *sel;
5792 ModestMailOperation *mail_op = NULL;
5794 if (canceled || err || !MODEST_IS_WINDOW (parent_window)) {
5795 /* Note that the connection process can fail due to
5796 memory low conditions as it can not successfully
5797 store the summary */
5798 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5799 (GtkWidget*) parent_window, err,
5801 g_debug ("Error connecting when trying to move a folder");
5803 g_object_unref (G_OBJECT (info->src_folder));
5804 g_object_unref (G_OBJECT (info->dst_folder));
5809 MoveToHelper *helper = g_new0 (MoveToHelper, 1);
5810 #ifndef MODEST_TOOLKIT_HILDON2
5811 helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
5812 _CS("ckct_nw_pasting"));
5813 if (helper->banner != NULL) {
5814 g_object_ref (helper->banner);
5815 gtk_widget_show (GTK_WIDGET(helper->banner));
5818 /* Clean folder on header view before moving it */
5819 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
5820 gtk_tree_selection_unselect_all (sel);
5822 /* Let gtk events run. We need that the folder
5823 view frees its reference to the source
5824 folder *before* issuing the mail operation
5825 so we need the signal handler of selection
5826 changed to happen before the mail
5828 while (gtk_events_pending ())
5829 gtk_main_iteration (); */
5832 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
5833 modest_ui_actions_move_folder_error_handler,
5834 g_object_ref (info->dst_folder), g_object_unref);
5835 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5838 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
5839 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
5840 TNY_FOLDER (info->dst_folder), TRUE);
5842 modest_mail_operation_xfer_folder (mail_op,
5843 TNY_FOLDER (info->src_folder),
5845 info->delete_original,
5848 g_object_unref (G_OBJECT (info->src_folder));
5850 /* if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) { */
5853 /* Unref mail operation */
5854 g_object_unref (G_OBJECT (mail_op));
5855 g_object_unref (G_OBJECT (info->dst_folder));
5860 get_account_from_folder_store (TnyFolderStore *folder_store)
5862 if (TNY_IS_ACCOUNT (folder_store))
5863 return g_object_ref (folder_store);
5865 return tny_folder_get_account (TNY_FOLDER (folder_store));
5869 * UI handler for the "Move to" action when invoked from the
5873 modest_ui_actions_on_main_window_move_to (GtkAction *action,
5874 GtkWidget *folder_view,
5875 TnyFolderStore *dst_folder,
5876 ModestMainWindow *win)
5878 ModestHeaderView *header_view = NULL;
5879 TnyFolderStore *src_folder = NULL;
5881 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5883 /* Get the source folder */
5884 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5886 /* Get header view */
5887 header_view = (ModestHeaderView *)
5888 modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5890 /* Get folder or messages to transfer */
5891 if (gtk_widget_is_focus (folder_view)) {
5892 gboolean do_xfer = TRUE;
5894 /* Allow only to transfer folders to the local root folder */
5895 if (TNY_IS_ACCOUNT (dst_folder) &&
5896 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5897 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5899 } else if (!TNY_IS_FOLDER (src_folder)) {
5900 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5905 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5906 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5908 info->src_folder = g_object_ref (src_folder);
5909 info->dst_folder = g_object_ref (dst_folder);
5910 info->delete_original = TRUE;
5911 info->folder_view = folder_view;
5913 connect_info->callback = on_move_folder_cb;
5914 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5915 connect_info->data = info;
5917 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5918 TNY_FOLDER_STORE (src_folder),
5921 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
5924 headers = modest_header_view_get_selected_headers(header_view);
5926 /* Transfer the messages */
5927 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
5928 headers, TNY_FOLDER (dst_folder));
5930 g_object_unref (headers);
5934 g_object_unref (src_folder);
5937 #ifdef MODEST_TOOLKIT_HILDON2
5939 * UI handler for the "Move to" action when invoked from the
5940 * ModestFolderWindow
5943 modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
5944 TnyFolderStore *dst_folder,
5948 TnyFolderStore *src_folder = NULL;
5949 TnyIterator *iterator;
5951 if (tny_list_get_length (selection) != 1)
5954 iterator = tny_list_create_iterator (selection);
5955 src_folder = TNY_FOLDER_STORE (tny_iterator_get_current (iterator));
5956 g_object_unref (iterator);
5959 gboolean do_xfer = TRUE;
5961 /* Allow only to transfer folders to the local root folder */
5962 if (TNY_IS_ACCOUNT (dst_folder) &&
5963 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5964 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5967 modest_platform_run_information_dialog (win,
5968 _("mail_in_ui_folder_move_target_error"),
5970 } else if (!TNY_IS_FOLDER (src_folder)) {
5971 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5976 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5977 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5979 info->src_folder = g_object_ref (src_folder);
5980 info->dst_folder = g_object_ref (dst_folder);
5981 info->delete_original = TRUE;
5982 info->folder_view = folder_view;
5984 connect_info->callback = on_move_folder_cb;
5985 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5986 connect_info->data = info;
5988 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5989 TNY_FOLDER_STORE (src_folder),
5994 g_object_unref (src_folder);
6000 modest_ui_actions_transfer_messages_helper (GtkWindow *win,
6001 TnyFolder *src_folder,
6003 TnyFolder *dst_folder)
6005 gboolean need_connection = TRUE;
6006 gboolean do_xfer = TRUE;
6007 XferMsgsHelper *helper;
6009 g_return_if_fail (TNY_IS_FOLDER (src_folder));
6010 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6011 g_return_if_fail (TNY_IS_LIST (headers));
6013 modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
6014 headers, TNY_FOLDER (dst_folder),
6015 TRUE, &need_connection,
6018 /* If we don't want to transfer just return */
6022 /* Create the helper */
6023 helper = g_slice_new (XferMsgsHelper);
6024 helper->dst_folder = g_object_ref (dst_folder);
6025 helper->headers = g_object_ref (headers);
6027 if (need_connection) {
6028 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
6029 connect_info->callback = xfer_messages_performer;
6030 connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
6031 connect_info->data = helper;
6033 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
6034 TNY_FOLDER_STORE (src_folder),
6037 TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
6038 xfer_messages_performer (FALSE, NULL, GTK_WINDOW (win),
6039 src_account, helper);
6040 g_object_unref (src_account);
6045 * UI handler for the "Move to" action when invoked from the
6046 * ModestMsgViewWindow
6049 modest_ui_actions_on_window_move_to (GtkAction *action,
6051 TnyFolderStore *dst_folder,
6054 TnyFolder *src_folder = NULL;
6056 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6059 TnyHeader *header = NULL;
6062 iter = tny_list_create_iterator (headers);
6063 header = (TnyHeader *) tny_iterator_get_current (iter);
6064 src_folder = tny_header_get_folder (header);
6066 /* Transfer the messages */
6067 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
6069 TNY_FOLDER (dst_folder));
6072 g_object_unref (header);
6073 g_object_unref (iter);
6074 g_object_unref (src_folder);
6079 modest_ui_actions_on_move_to (GtkAction *action,
6082 modest_ui_actions_on_edit_mode_move_to (win);
6086 modest_ui_actions_on_edit_mode_move_to (ModestWindow *win)
6088 GtkWidget *dialog = NULL;
6089 MoveToInfo *helper = NULL;
6090 TnyList *list_to_move;
6092 g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
6094 #ifndef MODEST_TOOLKIT_HILDON2
6095 /* Get the main window if exists */
6096 ModestMainWindow *main_window;
6097 if (MODEST_IS_MAIN_WINDOW (win))
6098 main_window = MODEST_MAIN_WINDOW (win);
6101 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
6102 FALSE)); /* don't create */
6105 list_to_move = modest_platform_get_list_to_move (MODEST_WINDOW (win));
6110 if (tny_list_get_length (list_to_move) < 1) {
6111 g_object_unref (list_to_move);
6115 /* Create and run the dialog */
6116 dialog = create_move_to_dialog (GTK_WINDOW (win), NULL, list_to_move);
6117 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
6118 GTK_WINDOW (dialog),
6122 helper = g_slice_new0 (MoveToInfo);
6123 helper->list = list_to_move;
6126 /* Listen to response signal */
6127 g_signal_connect (dialog, "response", G_CALLBACK (on_move_to_dialog_response), helper);
6129 /* Show the dialog */
6130 gtk_widget_show (dialog);
6136 * Calls #HeadersFunc for each header already selected in the main
6137 * window or the message currently being shown in the msg view window
6140 do_headers_action (ModestWindow *win,
6144 TnyList *headers_list = NULL;
6145 TnyIterator *iter = NULL;
6146 TnyHeader *header = NULL;
6147 TnyFolder *folder = NULL;
6150 headers_list = get_selected_headers (win);
6154 /* Get the folder */
6155 iter = tny_list_create_iterator (headers_list);
6156 header = TNY_HEADER (tny_iterator_get_current (iter));
6158 folder = tny_header_get_folder (header);
6159 g_object_unref (header);
6162 /* Call the function for each header */
6163 while (!tny_iterator_is_done (iter)) {
6164 header = TNY_HEADER (tny_iterator_get_current (iter));
6165 func (header, win, user_data);
6166 g_object_unref (header);
6167 tny_iterator_next (iter);
6170 /* Trick: do a poke status in order to speed up the signaling
6173 tny_folder_poke_status (folder);
6174 g_object_unref (folder);
6178 g_object_unref (iter);
6179 g_object_unref (headers_list);
6183 modest_ui_actions_view_attachment (GtkAction *action,
6184 ModestWindow *window)
6186 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6187 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
6189 /* not supported window for this action */
6190 g_return_if_reached ();
6195 modest_ui_actions_save_attachments (GtkAction *action,
6196 ModestWindow *window)
6198 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6200 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
6203 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
6205 /* not supported window for this action */
6206 g_return_if_reached ();
6211 modest_ui_actions_remove_attachments (GtkAction *action,
6212 ModestWindow *window)
6214 if (MODEST_IS_MAIN_WINDOW (window)) {
6215 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
6216 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6217 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
6219 /* not supported window for this action */
6220 g_return_if_reached ();
6225 modest_ui_actions_on_settings (GtkAction *action,
6230 dialog = modest_platform_get_global_settings_dialog ();
6231 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
6232 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
6233 gtk_widget_show_all (dialog);
6235 gtk_dialog_run (GTK_DIALOG (dialog));
6237 gtk_widget_destroy (dialog);
6241 modest_ui_actions_on_help (GtkAction *action,
6244 /* Help app is not available at all in fremantle */
6245 #ifndef MODEST_TOOLKIT_HILDON2
6246 const gchar *help_id;
6248 g_return_if_fail (win && GTK_IS_WINDOW(win));
6250 help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
6253 modest_platform_show_help (GTK_WINDOW (win), help_id);
6258 modest_ui_actions_on_csm_help (GtkAction *action,
6261 /* Help app is not available at all in fremantle */
6262 #ifndef MODEST_TOOLKIT_HILDON2
6264 const gchar* help_id = NULL;
6265 GtkWidget *folder_view;
6266 TnyFolderStore *folder_store;
6268 g_return_if_fail (win && MODEST_IS_MAIN_WINDOW (win));
6270 /* Get selected folder */
6271 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
6272 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6273 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6275 /* Switch help_id */
6276 if (folder_store && TNY_IS_FOLDER (folder_store))
6277 help_id = modest_tny_folder_get_help_id (TNY_FOLDER (folder_store));
6280 g_object_unref (folder_store);
6283 modest_platform_show_help (GTK_WINDOW (win), help_id);
6285 modest_ui_actions_on_help (action, win);
6290 retrieve_contents_cb (ModestMailOperation *mail_op,
6297 /* We only need this callback to show an error in case of
6298 memory low condition */
6299 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
6300 g_debug ("%s: message failed to retrieve. Memory low?", __FUNCTION__);
6305 retrieve_msg_contents_performer (gboolean canceled,
6307 GtkWindow *parent_window,
6308 TnyAccount *account,
6311 ModestMailOperation *mail_op;
6312 TnyList *headers = TNY_LIST (user_data);
6314 if (err || canceled) {
6315 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
6316 (GtkWidget *) parent_window, err,
6321 /* Create mail operation */
6322 mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
6323 modest_ui_actions_disk_operations_error_handler,
6325 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
6326 modest_mail_operation_get_msgs_full (mail_op, headers, retrieve_contents_cb, NULL, NULL);
6329 g_object_unref (mail_op);
6331 g_object_unref (headers);
6332 g_object_unref (account);
6336 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
6337 ModestWindow *window)
6339 TnyList *headers = NULL;
6340 TnyAccount *account = NULL;
6341 TnyIterator *iter = NULL;
6342 TnyHeader *header = NULL;
6343 TnyFolder *folder = NULL;
6346 headers = get_selected_headers (window);
6350 /* Pick the account */
6351 iter = tny_list_create_iterator (headers);
6352 header = TNY_HEADER (tny_iterator_get_current (iter));
6353 folder = tny_header_get_folder (header);
6354 account = tny_folder_get_account (folder);
6355 g_object_unref (folder);
6356 g_object_unref (header);
6357 g_object_unref (iter);
6359 /* Connect and perform the message retrieval */
6360 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6361 g_object_ref (account),
6362 retrieve_msg_contents_performer,
6363 g_object_ref (headers));
6366 g_object_unref (account);
6367 g_object_unref (headers);
6371 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
6373 g_return_if_fail (MODEST_IS_WINDOW (window));
6376 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_TOOLBAR);
6380 modest_ui_actions_check_menu_dimming_rules (ModestWindow *window)
6382 g_return_if_fail (MODEST_IS_WINDOW (window));
6385 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_MENU);
6389 modest_ui_actions_on_email_menu_activated (GtkAction *action,
6390 ModestWindow *window)
6392 g_return_if_fail (MODEST_IS_WINDOW (window));
6395 modest_ui_actions_check_menu_dimming_rules (window);
6399 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
6400 ModestWindow *window)
6402 g_return_if_fail (MODEST_IS_WINDOW (window));
6405 modest_ui_actions_check_menu_dimming_rules (window);
6409 modest_ui_actions_on_view_menu_activated (GtkAction *action,
6410 ModestWindow *window)
6412 g_return_if_fail (MODEST_IS_WINDOW (window));
6415 modest_ui_actions_check_menu_dimming_rules (window);
6419 modest_ui_actions_on_format_menu_activated (GtkAction *action,
6420 ModestWindow *window)
6422 g_return_if_fail (MODEST_IS_WINDOW (window));
6425 modest_ui_actions_check_menu_dimming_rules (window);
6429 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
6430 ModestWindow *window)
6432 g_return_if_fail (MODEST_IS_WINDOW (window));
6435 modest_ui_actions_check_menu_dimming_rules (window);
6439 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
6440 ModestWindow *window)
6442 g_return_if_fail (MODEST_IS_WINDOW (window));
6445 modest_ui_actions_check_menu_dimming_rules (window);
6449 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
6450 ModestWindow *window)
6452 g_return_if_fail (MODEST_IS_WINDOW (window));
6455 modest_ui_actions_check_menu_dimming_rules (window);
6459 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
6460 ModestWindow *window)
6462 g_return_if_fail (MODEST_IS_WINDOW (window));
6465 modest_ui_actions_check_menu_dimming_rules (window);
6469 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
6470 ModestWindow *window)
6472 g_return_if_fail (MODEST_IS_WINDOW (window));
6475 modest_ui_actions_check_menu_dimming_rules (window);
6479 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
6481 g_return_if_fail (MODEST_IS_WINDOW (window));
6483 /* we check for low-mem; in that case, show a warning, and don't allow
6486 if (modest_platform_check_memory_low (window, TRUE))
6489 modest_platform_show_search_messages (GTK_WINDOW (window));
6493 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
6495 g_return_if_fail (MODEST_IS_WINDOW (win));
6498 /* we check for low-mem; in that case, show a warning, and don't allow
6499 * for the addressbook
6501 if (modest_platform_check_memory_low (win, TRUE))
6505 modest_platform_show_addressbook (GTK_WINDOW (win));
6510 modest_ui_actions_on_toggle_find_in_page (GtkAction *action,
6511 ModestWindow *window)
6514 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
6516 if (GTK_IS_TOGGLE_ACTION (action))
6517 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
6521 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window),
6526 on_send_receive_finished (ModestMailOperation *mail_op,
6529 GtkWidget *header_view, *folder_view;
6530 TnyFolderStore *folder_store;
6531 ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
6533 /* Set send/receive operation finished */
6534 modest_main_window_notify_send_receive_completed (main_win);
6536 /* Don't refresh the current folder if there were any errors */
6537 if (modest_mail_operation_get_status (mail_op) !=
6538 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
6541 /* Refresh the current folder if we're viewing a window. We do
6542 this because the user won't be able to see the new mails in
6543 the selected folder after a Send&Receive because it only
6544 performs a poke_status, i.e, only the number of read/unread
6545 messages is updated, but the new headers are not
6547 folder_view = modest_main_window_get_child_widget (main_win,
6548 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6552 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6554 /* Do not need to refresh INBOX again because the
6555 update_account does it always automatically */
6556 if (folder_store && TNY_IS_FOLDER (folder_store) &&
6557 tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
6558 ModestMailOperation *refresh_op;
6560 header_view = modest_main_window_get_child_widget (main_win,
6561 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6563 /* We do not need to set the contents style
6564 because it hasn't changed. We also do not
6565 need to save the widget status. Just force
6567 refresh_op = modest_mail_operation_new (G_OBJECT (main_win));
6568 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), refresh_op);
6569 modest_mail_operation_refresh_folder (refresh_op, TNY_FOLDER (folder_store),
6570 folder_refreshed_cb, main_win);
6571 g_object_unref (refresh_op);
6575 g_object_unref (folder_store);
6580 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
6586 const gchar* server_name = NULL;
6587 TnyTransportAccount *transport;
6588 gchar *message = NULL;
6589 ModestProtocol *protocol;
6591 /* Don't show anything if the user cancelled something or the
6592 * send receive request is not interactive. Authentication
6593 * errors are managed by the account store so no need to show
6594 * a dialog here again */
6595 if (err->code == TNY_SYSTEM_ERROR_CANCEL ||
6596 err->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
6597 !modest_tny_send_queue_get_requested_send_receive (MODEST_TNY_SEND_QUEUE (self)))
6601 /* Get the server name. Note that we could be using a
6602 connection specific transport account */
6603 transport = (TnyTransportAccount *)
6604 tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
6606 ModestTnyAccountStore *acc_store;
6607 const gchar *acc_name;
6608 TnyTransportAccount *conn_specific;
6610 acc_store = modest_runtime_get_account_store();
6611 acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
6612 conn_specific = (TnyTransportAccount *)
6613 modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
6614 if (conn_specific) {
6615 server_name = tny_account_get_hostname (TNY_ACCOUNT (conn_specific));
6616 g_object_unref (conn_specific);
6618 server_name = tny_account_get_hostname (TNY_ACCOUNT (transport));
6620 g_object_unref (transport);
6624 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
6625 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
6626 tny_account_get_proto (TNY_ACCOUNT (transport)));
6628 g_warning ("%s: Account with no proto", __FUNCTION__);
6632 /* Show the appropriate message text for the GError: */
6633 switch (err->code) {
6634 case TNY_SERVICE_ERROR_CONNECT:
6635 message = modest_protocol_get_translation (protocol,
6636 MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
6639 case TNY_SERVICE_ERROR_SEND:
6640 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6642 case TNY_SERVICE_ERROR_UNAVAILABLE:
6643 message = modest_protocol_get_translation (protocol,
6644 MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR,
6648 g_warning ("%s: unexpected ERROR %d",
6649 __FUNCTION__, err->code);
6650 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6654 modest_platform_run_information_dialog (NULL, message, FALSE);
6659 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
6664 ModestWindow *top_window = NULL;
6665 ModestWindowMgr *mgr = NULL;
6666 GtkWidget *header_view = NULL;
6667 TnyFolder *selected_folder = NULL;
6668 TnyFolderType folder_type;
6670 mgr = modest_runtime_get_window_mgr ();
6671 top_window = modest_window_mgr_get_current_top (mgr);
6676 #ifndef MODEST_TOOLKIT_HILDON2
6677 if (MODEST_IS_MAIN_WINDOW (top_window)) {
6678 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (top_window),
6679 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6682 if (MODEST_IS_HEADER_WINDOW (top_window)) {
6683 header_view = (GtkWidget *)
6684 modest_header_window_get_header_view (MODEST_HEADER_WINDOW (top_window));
6688 /* Get selected folder */
6690 selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
6691 if (!selected_folder)
6694 /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
6695 #if GTK_CHECK_VERSION(2, 8, 0)
6696 folder_type = modest_tny_folder_guess_folder_type (selected_folder);
6697 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
6698 GtkTreeViewColumn *tree_column;
6700 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
6701 TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
6703 gtk_tree_view_column_queue_resize (tree_column);
6705 #else /* #if GTK_CHECK_VERSION(2, 8, 0) */
6706 gtk_widget_queue_draw (header_view);
6709 #ifndef MODEST_TOOLKIT_HILDON2
6710 /* Rerun dimming rules, because the message could become deletable for example */
6711 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6712 MODEST_DIMMING_RULES_TOOLBAR);
6713 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6714 MODEST_DIMMING_RULES_MENU);
6718 g_object_unref (selected_folder);
6722 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
6723 TnyAccount *account)
6725 ModestProtocolType protocol_type;
6726 ModestProtocol *protocol;
6727 gchar *error_note = NULL;
6729 protocol_type = modest_tny_account_get_protocol_type (account);
6730 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6733 error_note = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, tny_account_get_hostname (account));
6734 if (error_note == NULL) {
6735 g_warning ("%s: This should not be reached", __FUNCTION__);
6737 modest_platform_run_information_dialog (parent_window, error_note, FALSE);
6738 g_free (error_note);
6743 modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
6747 TnyFolderStore *folder = NULL;
6748 TnyAccount *account = NULL;
6749 ModestProtocolType proto;
6750 ModestProtocol *protocol;
6751 TnyHeader *header = NULL;
6753 if (MODEST_IS_MAIN_WINDOW (win)) {
6754 GtkWidget *header_view;
6755 TnyList* headers = NULL;
6757 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
6758 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6759 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6760 if (!headers || tny_list_get_length (headers) == 0) {
6762 g_object_unref (headers);
6765 iter = tny_list_create_iterator (headers);
6766 header = TNY_HEADER (tny_iterator_get_current (iter));
6767 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6768 g_object_unref (iter);
6769 g_object_unref (headers);
6770 #ifdef MODEST_TOOLKIT_HILDON2
6771 } else if (MODEST_IS_HEADER_WINDOW (win)) {
6772 GtkWidget *header_view;
6773 TnyList* headers = NULL;
6775 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
6776 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6777 if (!headers || tny_list_get_length (headers) == 0) {
6779 g_object_unref (headers);
6782 iter = tny_list_create_iterator (headers);
6783 header = TNY_HEADER (tny_iterator_get_current (iter));
6785 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6787 g_warning ("List should contain headers");
6789 g_object_unref (iter);
6790 g_object_unref (headers);
6792 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
6793 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
6795 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6798 if (!header || !folder)
6801 /* Get the account type */
6802 account = tny_folder_get_account (TNY_FOLDER (folder));
6803 proto = modest_tny_account_get_protocol_type (account);
6804 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6807 subject = tny_header_dup_subject (header);
6808 msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
6812 msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
6818 g_object_unref (account);
6820 g_object_unref (folder);
6822 g_object_unref (header);
6828 modest_ui_actions_on_delete_account (GtkWindow *parent_window,
6829 const gchar *account_name,
6830 const gchar *account_title)
6832 ModestAccountMgr *account_mgr;
6835 ModestProtocol *protocol;
6836 gboolean removed = FALSE;
6838 g_return_val_if_fail (account_name, FALSE);
6839 g_return_val_if_fail (account_title, FALSE);
6841 account_mgr = modest_runtime_get_account_mgr();
6843 /* The warning text depends on the account type: */
6844 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6845 modest_account_mgr_get_store_protocol (account_mgr,
6847 txt = modest_protocol_get_translation (protocol,
6848 MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX,
6851 txt = g_strdup_printf (_("emev_nc_delete_mailbox"), account_title);
6853 response = modest_platform_run_confirmation_dialog (parent_window, txt);
6857 if (response == GTK_RESPONSE_OK) {
6858 /* Remove account. If it succeeds then it also removes
6859 the account from the ModestAccountView: */
6860 gboolean is_default = FALSE;
6861 gchar *default_account_name = modest_account_mgr_get_default_account (account_mgr);
6862 if (default_account_name && (strcmp (default_account_name, account_name) == 0))
6864 g_free (default_account_name);
6866 removed = modest_account_mgr_remove_account (account_mgr, account_name);
6868 g_warning ("%s: modest_account_mgr_remove_account() failed.\n", __FUNCTION__);
6874 on_fetch_images_performer (gboolean canceled,
6876 GtkWindow *parent_window,
6877 TnyAccount *account,
6880 if (err || canceled) {
6881 /* Show an unable to retrieve images ??? */
6885 /* Note that the user could have closed the window while connecting */
6886 if (GTK_WIDGET_VISIBLE (parent_window))
6887 modest_msg_view_window_fetch_images ((ModestMsgViewWindow *) parent_window);
6888 g_object_unref ((GObject *) user_data);
6892 modest_ui_actions_on_fetch_images (GtkAction *action,
6893 ModestWindow *window)
6895 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
6897 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6899 on_fetch_images_performer,
6900 g_object_ref (window));
6904 modest_ui_actions_on_reload_message (const gchar *msg_id)
6906 ModestWindow *window = NULL;
6908 g_return_if_fail (msg_id && msg_id[0] != '\0');
6909 if (!modest_window_mgr_find_registered_message_uid (modest_runtime_get_window_mgr (),
6915 if (window == NULL || !MODEST_IS_MSG_VIEW_WINDOW (window))
6918 modest_msg_view_window_reload (MODEST_MSG_VIEW_WINDOW (window));
6921 /** Check whether any connections are active, and cancel them if
6923 * Returns TRUE is there was no problem,
6924 * or if an operation was cancelled so we can continue.
6925 * Returns FALSE if the user chose to cancel his request instead.
6929 modest_ui_actions_check_for_active_account (ModestWindow *self,
6930 const gchar* account_name)
6932 ModestTnySendQueue *send_queue;
6933 ModestTnyAccountStore *acc_store;
6934 ModestMailOperationQueue* queue;
6935 TnyConnectionStatus store_conn_status;
6936 TnyAccount *store_account = NULL, *transport_account = NULL;
6937 gboolean retval = TRUE, sending = FALSE;
6939 acc_store = modest_runtime_get_account_store ();
6940 queue = modest_runtime_get_mail_operation_queue ();
6943 modest_tny_account_store_get_server_account (acc_store,
6945 TNY_ACCOUNT_TYPE_STORE);
6947 /* This could happen if the account was deleted before the
6948 call to this function */
6953 modest_tny_account_store_get_server_account (acc_store,
6955 TNY_ACCOUNT_TYPE_TRANSPORT);
6957 /* This could happen if the account was deleted before the
6958 call to this function */
6959 if (!transport_account) {
6960 g_object_unref (store_account);
6964 /* If the transport account was not used yet, then the send
6965 queue could not exist (it's created on demand) */
6966 send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (transport_account), FALSE);
6967 if (TNY_IS_SEND_QUEUE (send_queue))
6968 sending = modest_tny_send_queue_sending_in_progress (send_queue);
6970 store_conn_status = tny_account_get_connection_status (store_account);
6971 if (store_conn_status == TNY_CONNECTION_STATUS_CONNECTED || sending) {
6974 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (self),
6975 _("emev_nc_disconnect_account"));
6976 if (response == GTK_RESPONSE_OK) {
6985 /* FIXME: We should only cancel those of this account */
6986 modest_mail_operation_queue_cancel_all (queue);
6988 /* Also disconnect the account */
6989 if ((tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED) &&
6990 (tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED_BROKEN)) {
6991 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account),
6995 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account),
7001 g_object_unref (store_account);
7002 g_object_unref (transport_account);