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_limit_error (GtkAction *action,
4822 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
4824 modest_platform_information_banner ((GtkWidget *) win, NULL, _CS("ckdg_ib_maximum_characters_reached"));
4829 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
4830 ModestMsgEditWindow *window)
4832 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4834 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
4838 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
4839 ModestMsgEditWindow *window)
4841 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4843 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
4847 modest_ui_actions_toggle_folders_view (GtkAction *action,
4848 ModestMainWindow *main_window)
4850 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
4852 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
4853 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
4855 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
4859 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
4860 ModestWindow *window)
4862 gboolean active, fullscreen = FALSE;
4863 ModestWindowMgr *mgr;
4865 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
4867 /* Check if we want to toggle the toolbar view in fullscreen
4869 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
4870 "ViewShowToolbarFullScreen")) {
4874 /* Toggle toolbar */
4875 mgr = modest_runtime_get_window_mgr ();
4876 modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
4880 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
4881 ModestMsgEditWindow *window)
4883 modest_msg_edit_window_select_font (window);
4888 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
4889 const gchar *display_name,
4892 /* don't update the display name if it was already set;
4893 * updating the display name apparently is expensive */
4894 const gchar* old_name = gtk_window_get_title (window);
4896 if (display_name == NULL)
4899 if (old_name && display_name && strcmp (old_name, display_name) == 0)
4900 return; /* don't do anything */
4902 /* This is usually used to change the title of the main window, which
4903 * is the one that holds the folder view. Note that this change can
4904 * happen even when the widget doesn't have the focus. */
4905 gtk_window_set_title (window, display_name);
4910 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
4912 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4913 modest_msg_edit_window_select_contacts (window);
4917 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
4919 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4920 modest_msg_edit_window_check_names (window, FALSE);
4923 #ifndef MODEST_TOOLKIT_HILDON2
4925 * This function is used to track changes in the selection of the
4926 * folder view that is inside the "move to" dialog to enable/disable
4927 * the OK button because we do not want the user to select a disallowed
4928 * destination for a folder.
4929 * The user also not desired to be able to use NEW button on items where
4930 * folder creation is not possibel.
4933 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
4934 TnyFolderStore *folder_store,
4938 GtkWidget *dialog = NULL;
4939 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
4940 gboolean moving_folder = FALSE;
4941 gboolean is_local_account = TRUE;
4942 GtkWidget *folder_view = NULL;
4943 ModestTnyFolderRules rules;
4945 g_return_if_fail (MODEST_IS_FOLDER_VIEW(self));
4950 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
4954 /* check if folder_store is an remote account */
4955 if (TNY_IS_ACCOUNT (folder_store)) {
4956 TnyAccount *local_account = NULL;
4957 TnyAccount *mmc_account = NULL;
4958 ModestTnyAccountStore *account_store = NULL;
4960 account_store = modest_runtime_get_account_store ();
4961 local_account = modest_tny_account_store_get_local_folders_account (account_store);
4962 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
4964 if ((gpointer) local_account != (gpointer) folder_store &&
4965 (gpointer) mmc_account != (gpointer) folder_store) {
4966 ModestProtocolType proto;
4967 proto = modest_tny_account_get_protocol_type (TNY_ACCOUNT (folder_store));
4968 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
4969 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
4971 is_local_account = FALSE;
4972 /* New button should be dimmed on remote
4974 new_sensitive = (modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
4976 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS));
4978 g_object_unref (local_account);
4980 /* It could not exist */
4982 g_object_unref (mmc_account);
4985 /* Check the target folder rules */
4986 if (TNY_IS_FOLDER (folder_store)) {
4987 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
4988 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
4989 ok_sensitive = FALSE;
4990 new_sensitive = FALSE;
4995 /* Check if we're moving a folder */
4996 if (MODEST_IS_MAIN_WINDOW (user_data)) {
4997 /* Get the widgets */
4998 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
4999 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5000 if (gtk_widget_is_focus (folder_view))
5001 moving_folder = TRUE;
5004 if (moving_folder) {
5005 TnyFolderStore *moved_folder = NULL, *parent = NULL;
5007 /* Get the folder to move */
5008 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5010 /* Check that we're not moving to the same folder */
5011 if (TNY_IS_FOLDER (moved_folder)) {
5012 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
5013 if (parent == folder_store)
5014 ok_sensitive = FALSE;
5015 g_object_unref (parent);
5018 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
5019 /* Do not allow to move to an account unless it's the
5020 local folders account */
5021 if (!is_local_account)
5022 ok_sensitive = FALSE;
5025 if (ok_sensitive && (moved_folder == folder_store)) {
5026 /* Do not allow to move to itself */
5027 ok_sensitive = FALSE;
5029 g_object_unref (moved_folder);
5031 TnyFolder *src_folder = NULL;
5033 /* Moving a message */
5034 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
5036 TnyHeader *header = NULL;
5037 header = modest_msg_view_window_get_header
5038 (MODEST_MSG_VIEW_WINDOW (user_data));
5039 if (!TNY_IS_HEADER(header))
5040 g_warning ("%s: could not get source header", __FUNCTION__);
5042 src_folder = tny_header_get_folder (header);
5045 g_object_unref (header);
5048 TNY_FOLDER (modest_folder_view_get_selected
5049 (MODEST_FOLDER_VIEW (folder_view)));
5052 if (TNY_IS_FOLDER(src_folder)) {
5053 /* Do not allow to move the msg to the same folder */
5054 /* Do not allow to move the msg to an account */
5055 if ((gpointer) src_folder == (gpointer) folder_store ||
5056 TNY_IS_ACCOUNT (folder_store))
5057 ok_sensitive = FALSE;
5058 g_object_unref (src_folder);
5060 g_warning ("%s: could not get source folder", __FUNCTION__);
5064 /* Set sensitivity of the OK and NEW button */
5065 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, ok_sensitive);
5066 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_GTK_RESPONSE_NEW_FOLDER, new_sensitive);
5071 on_move_to_dialog_response (GtkDialog *dialog,
5075 GtkWidget *parent_win;
5076 MoveToInfo *helper = NULL;
5077 ModestFolderView *folder_view;
5078 gboolean unset_edit_mode = FALSE;
5080 helper = (MoveToInfo *) user_data;
5082 parent_win = (GtkWidget *) helper->win;
5083 folder_view = MODEST_FOLDER_VIEW (g_object_get_data (G_OBJECT (dialog),
5084 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
5087 TnyFolderStore *dst_folder;
5088 TnyFolderStore *selected;
5090 case MODEST_GTK_RESPONSE_NEW_FOLDER:
5091 selected = modest_folder_view_get_selected (folder_view);
5092 modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view), selected);
5093 g_object_unref (selected);
5095 case GTK_RESPONSE_NONE:
5096 case GTK_RESPONSE_CANCEL:
5097 case GTK_RESPONSE_DELETE_EVENT:
5099 case GTK_RESPONSE_OK:
5100 dst_folder = modest_folder_view_get_selected (folder_view);
5102 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
5103 /* Clean list to move used for filtering */
5104 modest_folder_view_set_list_to_move (folder_view, NULL);
5106 modest_ui_actions_on_main_window_move_to (NULL,
5107 GTK_WIDGET (folder_view),
5109 MODEST_MAIN_WINDOW (parent_win));
5110 #ifdef MODEST_TOOLKIT_HILDON2
5111 } else if (MODEST_IS_FOLDER_WINDOW (parent_win)) {
5112 /* Clean list to move used for filtering */
5113 modest_folder_view_set_list_to_move (folder_view, NULL);
5115 modest_ui_actions_on_folder_window_move_to (GTK_WIDGET (folder_view),
5118 GTK_WINDOW (parent_win));
5121 /* if the user selected a root folder
5122 (account) then do not perform any action */
5123 if (TNY_IS_ACCOUNT (dst_folder)) {
5124 g_signal_stop_emission_by_name (dialog, "response");
5128 /* Clean list to move used for filtering */
5129 modest_folder_view_set_list_to_move (folder_view, NULL);
5131 /* Moving from headers window in edit mode */
5132 modest_ui_actions_on_window_move_to (NULL, helper->list,
5134 MODEST_WINDOW (parent_win));
5138 g_object_unref (dst_folder);
5140 unset_edit_mode = TRUE;
5143 g_warning ("%s unexpected response id %d", __FUNCTION__, response);
5146 /* Free the helper and exit */
5148 g_object_unref (helper->list);
5149 if (unset_edit_mode) {
5150 #ifdef MODEST_TOOLKIT_HILDON2
5151 modest_hildon2_window_unset_edit_mode (MODEST_HILDON2_WINDOW (helper->win));
5154 g_slice_free (MoveToInfo, helper);
5155 gtk_widget_destroy (GTK_WIDGET (dialog));
5159 create_move_to_dialog (GtkWindow *win,
5160 GtkWidget *folder_view,
5161 TnyList *list_to_move)
5163 GtkWidget *dialog, *tree_view = NULL;
5165 dialog = modest_platform_create_move_to_dialog (win, &tree_view);
5167 #ifndef MODEST_TOOLKIT_HILDON2
5168 /* Track changes in the selection to
5169 * disable the OK button whenever "Move to" is not possible
5170 * disbale NEW button whenever New is not possible */
5171 g_signal_connect (tree_view,
5172 "folder_selection_changed",
5173 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
5177 /* It could happen that we're trying to move a message from a
5178 window (msg window for example) after the main window was
5179 closed, so we can not just get the model of the folder
5181 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
5182 const gchar *visible_id = NULL;
5184 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5185 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5186 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
5187 MODEST_FOLDER_VIEW(tree_view));
5190 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
5192 /* Show the same account than the one that is shown in the main window */
5193 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(tree_view),
5196 const gchar *active_account_name = NULL;
5197 ModestAccountMgr *mgr = NULL;
5198 ModestAccountSettings *settings = NULL;
5199 ModestServerAccountSettings *store_settings = NULL;
5201 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5202 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5203 modest_folder_view_update_model (MODEST_FOLDER_VIEW (tree_view),
5204 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
5206 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
5207 mgr = modest_runtime_get_account_mgr ();
5208 settings = modest_account_mgr_load_account_settings (mgr, active_account_name);
5211 const gchar *store_account_name;
5212 store_settings = modest_account_settings_get_store_settings (settings);
5213 store_account_name = modest_server_account_settings_get_account_name (store_settings);
5215 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (tree_view),
5216 store_account_name);
5217 g_object_unref (store_settings);
5218 g_object_unref (settings);
5222 /* we keep a pointer to the embedded folder view, so we can
5223 * retrieve it with get_folder_view_from_move_to_dialog (see
5224 * above) later (needed for focus handling)
5226 g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, tree_view);
5228 /* Hide special folders */
5229 #ifndef MODEST_TOOLKIT_HILDON2
5230 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
5233 modest_folder_view_set_list_to_move (MODEST_FOLDER_VIEW (tree_view), list_to_move);
5234 #ifndef MODEST_TOOLKIT_HILDON2
5235 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
5238 gtk_widget_show (GTK_WIDGET (tree_view));
5244 * Shows a confirmation dialog to the user when we're moving messages
5245 * from a remote server to the local storage. Returns the dialog
5246 * response. If it's other kind of movement then it always returns
5249 * This one is used by the next functions:
5250 * modest_ui_actions_on_paste - commented out
5251 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
5254 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
5255 TnyFolder *dest_folder,
5259 gint response = GTK_RESPONSE_OK;
5260 TnyAccount *account = NULL;
5261 TnyFolder *src_folder = NULL;
5262 TnyIterator *iter = NULL;
5263 TnyHeader *header = NULL;
5265 /* return with OK if the destination is a remote folder */
5266 if (modest_tny_folder_is_remote_folder (dest_folder))
5267 return GTK_RESPONSE_OK;
5269 /* Get source folder */
5270 iter = tny_list_create_iterator (headers);
5271 header = TNY_HEADER (tny_iterator_get_current (iter));
5273 src_folder = tny_header_get_folder (header);
5274 g_object_unref (header);
5276 g_object_unref (iter);
5278 /* if no src_folder, message may be an attahcment */
5279 if (src_folder == NULL)
5280 return GTK_RESPONSE_CANCEL;
5282 /* If the source is a local or MMC folder */
5283 if (!modest_tny_folder_is_remote_folder (src_folder)) {
5284 g_object_unref (src_folder);
5285 return GTK_RESPONSE_OK;
5288 /* Get the account */
5289 account = tny_folder_get_account (src_folder);
5291 /* now if offline we ask the user */
5292 if(connect_to_get_msg (win, tny_list_get_length (headers), account))
5293 response = GTK_RESPONSE_OK;
5295 response = GTK_RESPONSE_CANCEL;
5298 g_object_unref (src_folder);
5299 g_object_unref (account);
5305 move_to_helper_destroyer (gpointer user_data)
5307 MoveToHelper *helper = (MoveToHelper *) user_data;
5309 /* Close the "Pasting" information banner */
5310 if (helper->banner) {
5311 gtk_widget_destroy (GTK_WIDGET (helper->banner));
5312 g_object_unref (helper->banner);
5314 if (gtk_tree_row_reference_valid (helper->reference)) {
5315 gtk_tree_row_reference_free (helper->reference);
5316 helper->reference = NULL;
5322 move_to_cb (ModestMailOperation *mail_op,
5325 MoveToHelper *helper = (MoveToHelper *) user_data;
5326 GObject *object = modest_mail_operation_get_source (mail_op);
5328 /* Note that the operation could have failed, in that case do
5330 if (modest_mail_operation_get_status (mail_op) !=
5331 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
5334 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
5335 ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
5337 if (!modest_msg_view_window_select_next_message (self) &&
5338 !modest_msg_view_window_select_previous_message (self)) {
5339 /* No more messages to view, so close this window */
5340 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
5342 } else if (MODEST_IS_MAIN_WINDOW (object) &&
5343 gtk_tree_row_reference_valid (helper->reference)) {
5344 GtkWidget *header_view;
5346 GtkTreeSelection *sel;
5348 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5349 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5350 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
5351 path = gtk_tree_row_reference_get_path (helper->reference);
5352 /* We need to unselect the previous one
5353 because we could be copying instead of
5355 gtk_tree_selection_unselect_all (sel);
5356 gtk_tree_selection_select_path (sel, path);
5357 gtk_tree_path_free (path);
5359 g_object_unref (object);
5362 /* Destroy the helper */
5363 move_to_helper_destroyer (helper);
5367 folder_move_to_cb (ModestMailOperation *mail_op,
5368 TnyFolder *new_folder,
5371 GtkWidget *folder_view;
5374 object = modest_mail_operation_get_source (mail_op);
5375 if (MODEST_IS_MAIN_WINDOW (object)) {
5376 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5377 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5378 g_object_ref (folder_view);
5379 g_object_unref (object);
5380 move_to_cb (mail_op, user_data);
5381 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), new_folder, FALSE);
5382 g_object_unref (folder_view);
5384 move_to_cb (mail_op, user_data);
5389 msgs_move_to_cb (ModestMailOperation *mail_op,
5392 move_to_cb (mail_op, user_data);
5396 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
5399 GObject *win = NULL;
5400 const GError *error;
5401 TnyAccount *account = NULL;
5403 #ifndef MODEST_TOOLKIT_HILDON2
5404 ModestWindow *main_window = NULL;
5406 /* Disable next automatic folder selection */
5407 main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
5408 FALSE); /* don't create */
5410 /* Show notification dialog only if the main window exists */
5412 GtkWidget *folder_view = NULL;
5414 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
5415 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5416 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
5418 if (user_data && TNY_IS_FOLDER (user_data)) {
5419 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
5420 TNY_FOLDER (user_data), FALSE);
5424 win = modest_mail_operation_get_source (mail_op);
5425 error = modest_mail_operation_get_error (mail_op);
5427 if (TNY_IS_FOLDER (user_data))
5428 account = modest_tny_folder_get_account (TNY_FOLDER (user_data));
5429 else if (TNY_IS_ACCOUNT (user_data))
5430 account = g_object_ref (user_data);
5432 /* If it's not a disk full error then show a generic error */
5433 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5434 (GtkWidget *) win, (GError *) error,
5436 modest_platform_run_information_dialog ((GtkWindow *) win,
5437 _("mail_in_ui_folder_move_target_error"),
5440 g_object_unref (account);
5442 g_object_unref (win);
5446 open_msg_for_purge_cb (ModestMailOperation *mail_op,
5455 gint pending_purges = 0;
5456 gboolean some_purged = FALSE;
5457 ModestWindow *win = MODEST_WINDOW (user_data);
5458 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
5460 /* If there was any error */
5461 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
5462 modest_window_mgr_unregister_header (mgr, header);
5466 /* Once the message has been retrieved for purging, we check if
5467 * it's all ok for purging */
5469 parts = tny_simple_list_new ();
5470 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
5471 iter = tny_list_create_iterator (parts);
5473 while (!tny_iterator_is_done (iter)) {
5475 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5476 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
5477 if (tny_mime_part_is_purged (part))
5484 g_object_unref (part);
5486 tny_iterator_next (iter);
5488 g_object_unref (iter);
5491 if (pending_purges>0) {
5493 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
5495 if (response == GTK_RESPONSE_OK) {
5498 modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_me_inbox_remove_attachments"));
5499 iter = tny_list_create_iterator (parts);
5500 while (!tny_iterator_is_done (iter)) {
5503 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5504 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
5505 tny_mime_part_set_purged (part);
5508 g_object_unref (part);
5510 tny_iterator_next (iter);
5512 g_object_unref (iter);
5514 tny_msg_rewrite_cache (msg);
5516 gtk_widget_destroy (info);
5520 modest_window_mgr_unregister_header (mgr, header);
5522 g_object_unref (parts);
5526 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
5527 ModestMainWindow *win)
5529 GtkWidget *header_view;
5530 TnyList *header_list;
5532 TnyHeaderFlags flags;
5533 ModestWindow *msg_view_window = NULL;
5536 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5538 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
5539 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5541 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
5543 g_warning ("%s: no header selected", __FUNCTION__);
5547 if (tny_list_get_length (header_list) == 1) {
5548 TnyIterator *iter = tny_list_create_iterator (header_list);
5549 header = TNY_HEADER (tny_iterator_get_current (iter));
5550 g_object_unref (iter);
5554 if (!header || !TNY_IS_HEADER(header)) {
5555 g_warning ("%s: header is not valid", __FUNCTION__);
5559 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
5560 header, &msg_view_window);
5561 flags = tny_header_get_flags (header);
5562 if (!(flags & TNY_HEADER_FLAG_CACHED))
5565 if (msg_view_window != NULL)
5566 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
5568 /* do nothing; uid was registered before, so window is probably on it's way */
5569 g_debug ("header %p has already been registered", header);
5572 ModestMailOperation *mail_op = NULL;
5573 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
5574 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
5575 modest_ui_actions_disk_operations_error_handler,
5577 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
5578 modest_mail_operation_get_msg (mail_op, header, FALSE, open_msg_for_purge_cb, win);
5580 g_object_unref (mail_op);
5583 g_object_unref (header);
5585 g_object_unref (header_list);
5589 * Checks if we need a connection to do the transfer and if the user
5590 * wants to connect to complete it
5593 modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
5594 TnyFolderStore *src_folder,
5596 TnyFolder *dst_folder,
5597 gboolean delete_originals,
5598 gboolean *need_connection,
5601 TnyAccount *src_account;
5602 gint uncached_msgs = 0;
5604 /* We don't need any further check if
5606 * 1- the source folder is local OR
5607 * 2- the device is already online
5609 if (!modest_tny_folder_store_is_remote (src_folder) ||
5610 tny_device_is_online (modest_runtime_get_device())) {
5611 *need_connection = FALSE;
5616 /* We must ask for a connection when
5618 * - the message(s) is not already cached OR
5619 * - the message(s) is cached but the leave_on_server setting
5620 * is FALSE (because we need to sync the source folder to
5621 * delete the message from the server (for IMAP we could do it
5622 * offline, it'll take place the next time we get a
5625 uncached_msgs = header_list_count_uncached_msgs (headers);
5626 src_account = get_account_from_folder_store (src_folder);
5627 if (uncached_msgs > 0) {
5631 *need_connection = TRUE;
5632 num_headers = tny_list_get_length (headers);
5633 msg = ngettext ("mcen_nc_get_msg", "mcen_nc_get_msgs", num_headers);
5635 if (modest_platform_run_confirmation_dialog (parent_window, msg) ==
5636 GTK_RESPONSE_CANCEL) {
5642 /* The transfer is possible and the user wants to */
5645 if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
5646 const gchar *account_name;
5647 gboolean leave_on_server;
5649 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
5650 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
5653 if (leave_on_server == TRUE) {
5654 *need_connection = FALSE;
5656 *need_connection = TRUE;
5659 *need_connection = FALSE;
5664 g_object_unref (src_account);
5668 xfer_messages_error_handler (ModestMailOperation *mail_op,
5672 const GError *error;
5673 TnyAccount *account;
5675 win = modest_mail_operation_get_source (mail_op);
5676 error = modest_mail_operation_get_error (mail_op);
5677 account = modest_mail_operation_get_account (mail_op);
5679 if (error && modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
5680 (GError *) error, account)) {
5681 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
5682 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
5685 modest_platform_run_information_dialog ((GtkWindow *) win,
5686 _("mail_in_ui_folder_move_target_error"),
5690 g_object_unref (account);
5692 g_object_unref (win);
5696 TnyFolderStore *dst_folder;
5701 * Utility function that transfer messages from both the main window
5702 * and the msg view window when using the "Move to" dialog
5705 xfer_messages_performer (gboolean canceled,
5707 GtkWindow *parent_window,
5708 TnyAccount *account,
5711 ModestWindow *win = MODEST_WINDOW (parent_window);
5712 TnyAccount *dst_account = NULL;
5713 gboolean dst_forbids_message_add = FALSE;
5714 XferMsgsHelper *helper;
5715 MoveToHelper *movehelper;
5716 ModestMailOperation *mail_op;
5718 helper = (XferMsgsHelper *) user_data;
5720 if (canceled || err) {
5721 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5722 (GtkWidget *) parent_window, err,
5724 /* Show the proper error message */
5725 modest_ui_actions_on_account_connection_error (parent_window, account);
5730 dst_account = tny_folder_get_account (TNY_FOLDER (helper->dst_folder));
5732 /* tinymail will return NULL for local folders it seems */
5733 dst_forbids_message_add = modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
5734 modest_tny_account_get_protocol_type (dst_account),
5735 MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
5736 g_object_unref (dst_account);
5738 if (dst_forbids_message_add) {
5739 modest_platform_information_banner (GTK_WIDGET (win),
5741 ngettext("mail_in_ui_folder_move_target_error",
5742 "mail_in_ui_folder_move_targets_error",
5743 tny_list_get_length (helper->headers)));
5747 movehelper = g_new0 (MoveToHelper, 1);
5749 #ifndef MODEST_TOOLKIT_HILDON2
5750 movehelper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
5751 _CS("ckct_nw_pasting"));
5752 if (movehelper->banner != NULL) {
5753 g_object_ref (movehelper->banner);
5754 gtk_widget_show (GTK_WIDGET (movehelper->banner));
5758 if (MODEST_IS_MAIN_WINDOW (win)) {
5759 GtkWidget *header_view =
5760 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
5761 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5762 movehelper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
5765 /* Perform the mail operation */
5766 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(win),
5767 xfer_messages_error_handler,
5769 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5772 modest_mail_operation_xfer_msgs (mail_op,
5774 TNY_FOLDER (helper->dst_folder),
5779 g_object_unref (G_OBJECT (mail_op));
5781 g_object_unref (helper->dst_folder);
5782 g_object_unref (helper->headers);
5783 g_slice_free (XferMsgsHelper, helper);
5787 TnyFolder *src_folder;
5788 TnyFolderStore *dst_folder;
5789 gboolean delete_original;
5790 GtkWidget *folder_view;
5794 on_move_folder_cb (gboolean canceled,
5796 GtkWindow *parent_window,
5797 TnyAccount *account,
5800 MoveFolderInfo *info = (MoveFolderInfo*)user_data;
5801 GtkTreeSelection *sel;
5802 ModestMailOperation *mail_op = NULL;
5804 if (canceled || err || !MODEST_IS_WINDOW (parent_window)) {
5805 /* Note that the connection process can fail due to
5806 memory low conditions as it can not successfully
5807 store the summary */
5808 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5809 (GtkWidget*) parent_window, err,
5811 g_debug ("Error connecting when trying to move a folder");
5813 g_object_unref (G_OBJECT (info->src_folder));
5814 g_object_unref (G_OBJECT (info->dst_folder));
5819 MoveToHelper *helper = g_new0 (MoveToHelper, 1);
5820 #ifndef MODEST_TOOLKIT_HILDON2
5821 helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
5822 _CS("ckct_nw_pasting"));
5823 if (helper->banner != NULL) {
5824 g_object_ref (helper->banner);
5825 gtk_widget_show (GTK_WIDGET(helper->banner));
5828 /* Clean folder on header view before moving it */
5829 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
5830 gtk_tree_selection_unselect_all (sel);
5832 /* Let gtk events run. We need that the folder
5833 view frees its reference to the source
5834 folder *before* issuing the mail operation
5835 so we need the signal handler of selection
5836 changed to happen before the mail
5838 while (gtk_events_pending ())
5839 gtk_main_iteration (); */
5842 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
5843 modest_ui_actions_move_folder_error_handler,
5844 g_object_ref (info->dst_folder), g_object_unref);
5845 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5848 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
5849 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
5850 TNY_FOLDER (info->dst_folder), TRUE);
5852 modest_mail_operation_xfer_folder (mail_op,
5853 TNY_FOLDER (info->src_folder),
5855 info->delete_original,
5858 g_object_unref (G_OBJECT (info->src_folder));
5860 /* if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) { */
5863 /* Unref mail operation */
5864 g_object_unref (G_OBJECT (mail_op));
5865 g_object_unref (G_OBJECT (info->dst_folder));
5870 get_account_from_folder_store (TnyFolderStore *folder_store)
5872 if (TNY_IS_ACCOUNT (folder_store))
5873 return g_object_ref (folder_store);
5875 return tny_folder_get_account (TNY_FOLDER (folder_store));
5879 * UI handler for the "Move to" action when invoked from the
5883 modest_ui_actions_on_main_window_move_to (GtkAction *action,
5884 GtkWidget *folder_view,
5885 TnyFolderStore *dst_folder,
5886 ModestMainWindow *win)
5888 ModestHeaderView *header_view = NULL;
5889 TnyFolderStore *src_folder = NULL;
5891 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5893 /* Get the source folder */
5894 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5896 /* Get header view */
5897 header_view = (ModestHeaderView *)
5898 modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5900 /* Get folder or messages to transfer */
5901 if (gtk_widget_is_focus (folder_view)) {
5902 gboolean do_xfer = TRUE;
5904 /* Allow only to transfer folders to the local root folder */
5905 if (TNY_IS_ACCOUNT (dst_folder) &&
5906 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5907 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5909 } else if (!TNY_IS_FOLDER (src_folder)) {
5910 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5915 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5916 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5918 info->src_folder = g_object_ref (src_folder);
5919 info->dst_folder = g_object_ref (dst_folder);
5920 info->delete_original = TRUE;
5921 info->folder_view = folder_view;
5923 connect_info->callback = on_move_folder_cb;
5924 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5925 connect_info->data = info;
5927 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5928 TNY_FOLDER_STORE (src_folder),
5931 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
5934 headers = modest_header_view_get_selected_headers(header_view);
5936 /* Transfer the messages */
5937 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
5938 headers, TNY_FOLDER (dst_folder));
5940 g_object_unref (headers);
5944 g_object_unref (src_folder);
5947 #ifdef MODEST_TOOLKIT_HILDON2
5949 * UI handler for the "Move to" action when invoked from the
5950 * ModestFolderWindow
5953 modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
5954 TnyFolderStore *dst_folder,
5958 TnyFolderStore *src_folder = NULL;
5959 TnyIterator *iterator;
5961 if (tny_list_get_length (selection) != 1)
5964 iterator = tny_list_create_iterator (selection);
5965 src_folder = TNY_FOLDER_STORE (tny_iterator_get_current (iterator));
5966 g_object_unref (iterator);
5969 gboolean do_xfer = TRUE;
5971 /* Allow only to transfer folders to the local root folder */
5972 if (TNY_IS_ACCOUNT (dst_folder) &&
5973 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5974 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5977 modest_platform_run_information_dialog (win,
5978 _("mail_in_ui_folder_move_target_error"),
5980 } else if (!TNY_IS_FOLDER (src_folder)) {
5981 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5986 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5987 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5989 info->src_folder = g_object_ref (src_folder);
5990 info->dst_folder = g_object_ref (dst_folder);
5991 info->delete_original = TRUE;
5992 info->folder_view = folder_view;
5994 connect_info->callback = on_move_folder_cb;
5995 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5996 connect_info->data = info;
5998 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5999 TNY_FOLDER_STORE (src_folder),
6004 g_object_unref (src_folder);
6010 modest_ui_actions_transfer_messages_helper (GtkWindow *win,
6011 TnyFolder *src_folder,
6013 TnyFolder *dst_folder)
6015 gboolean need_connection = TRUE;
6016 gboolean do_xfer = TRUE;
6017 XferMsgsHelper *helper;
6019 g_return_if_fail (TNY_IS_FOLDER (src_folder));
6020 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6021 g_return_if_fail (TNY_IS_LIST (headers));
6023 modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
6024 headers, TNY_FOLDER (dst_folder),
6025 TRUE, &need_connection,
6028 /* If we don't want to transfer just return */
6032 /* Create the helper */
6033 helper = g_slice_new (XferMsgsHelper);
6034 helper->dst_folder = g_object_ref (dst_folder);
6035 helper->headers = g_object_ref (headers);
6037 if (need_connection) {
6038 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
6039 connect_info->callback = xfer_messages_performer;
6040 connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
6041 connect_info->data = helper;
6043 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
6044 TNY_FOLDER_STORE (src_folder),
6047 TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
6048 xfer_messages_performer (FALSE, NULL, GTK_WINDOW (win),
6049 src_account, helper);
6050 g_object_unref (src_account);
6055 * UI handler for the "Move to" action when invoked from the
6056 * ModestMsgViewWindow
6059 modest_ui_actions_on_window_move_to (GtkAction *action,
6061 TnyFolderStore *dst_folder,
6064 TnyFolder *src_folder = NULL;
6066 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6069 TnyHeader *header = NULL;
6072 iter = tny_list_create_iterator (headers);
6073 header = (TnyHeader *) tny_iterator_get_current (iter);
6074 src_folder = tny_header_get_folder (header);
6076 /* Transfer the messages */
6077 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
6079 TNY_FOLDER (dst_folder));
6082 g_object_unref (header);
6083 g_object_unref (iter);
6084 g_object_unref (src_folder);
6089 modest_ui_actions_on_move_to (GtkAction *action,
6092 modest_ui_actions_on_edit_mode_move_to (win);
6096 modest_ui_actions_on_edit_mode_move_to (ModestWindow *win)
6098 GtkWidget *dialog = NULL;
6099 MoveToInfo *helper = NULL;
6100 TnyList *list_to_move;
6102 g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
6104 #ifndef MODEST_TOOLKIT_HILDON2
6105 /* Get the main window if exists */
6106 ModestMainWindow *main_window;
6107 if (MODEST_IS_MAIN_WINDOW (win))
6108 main_window = MODEST_MAIN_WINDOW (win);
6111 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
6112 FALSE)); /* don't create */
6115 list_to_move = modest_platform_get_list_to_move (MODEST_WINDOW (win));
6120 if (tny_list_get_length (list_to_move) < 1) {
6121 g_object_unref (list_to_move);
6125 /* Create and run the dialog */
6126 dialog = create_move_to_dialog (GTK_WINDOW (win), NULL, list_to_move);
6127 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
6128 GTK_WINDOW (dialog),
6132 helper = g_slice_new0 (MoveToInfo);
6133 helper->list = list_to_move;
6136 /* Listen to response signal */
6137 g_signal_connect (dialog, "response", G_CALLBACK (on_move_to_dialog_response), helper);
6139 /* Show the dialog */
6140 gtk_widget_show (dialog);
6146 * Calls #HeadersFunc for each header already selected in the main
6147 * window or the message currently being shown in the msg view window
6150 do_headers_action (ModestWindow *win,
6154 TnyList *headers_list = NULL;
6155 TnyIterator *iter = NULL;
6156 TnyHeader *header = NULL;
6157 TnyFolder *folder = NULL;
6160 headers_list = get_selected_headers (win);
6164 /* Get the folder */
6165 iter = tny_list_create_iterator (headers_list);
6166 header = TNY_HEADER (tny_iterator_get_current (iter));
6168 folder = tny_header_get_folder (header);
6169 g_object_unref (header);
6172 /* Call the function for each header */
6173 while (!tny_iterator_is_done (iter)) {
6174 header = TNY_HEADER (tny_iterator_get_current (iter));
6175 func (header, win, user_data);
6176 g_object_unref (header);
6177 tny_iterator_next (iter);
6180 /* Trick: do a poke status in order to speed up the signaling
6183 tny_folder_poke_status (folder);
6184 g_object_unref (folder);
6188 g_object_unref (iter);
6189 g_object_unref (headers_list);
6193 modest_ui_actions_view_attachment (GtkAction *action,
6194 ModestWindow *window)
6196 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6197 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
6199 /* not supported window for this action */
6200 g_return_if_reached ();
6205 modest_ui_actions_save_attachments (GtkAction *action,
6206 ModestWindow *window)
6208 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6210 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
6213 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
6215 /* not supported window for this action */
6216 g_return_if_reached ();
6221 modest_ui_actions_remove_attachments (GtkAction *action,
6222 ModestWindow *window)
6224 if (MODEST_IS_MAIN_WINDOW (window)) {
6225 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
6226 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6227 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
6229 /* not supported window for this action */
6230 g_return_if_reached ();
6235 modest_ui_actions_on_settings (GtkAction *action,
6240 dialog = modest_platform_get_global_settings_dialog ();
6241 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
6242 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
6243 gtk_widget_show_all (dialog);
6245 gtk_dialog_run (GTK_DIALOG (dialog));
6247 gtk_widget_destroy (dialog);
6251 modest_ui_actions_on_help (GtkAction *action,
6254 /* Help app is not available at all in fremantle */
6255 #ifndef MODEST_TOOLKIT_HILDON2
6256 const gchar *help_id;
6258 g_return_if_fail (win && GTK_IS_WINDOW(win));
6260 help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
6263 modest_platform_show_help (GTK_WINDOW (win), help_id);
6268 modest_ui_actions_on_csm_help (GtkAction *action,
6271 /* Help app is not available at all in fremantle */
6272 #ifndef MODEST_TOOLKIT_HILDON2
6274 const gchar* help_id = NULL;
6275 GtkWidget *folder_view;
6276 TnyFolderStore *folder_store;
6278 g_return_if_fail (win && MODEST_IS_MAIN_WINDOW (win));
6280 /* Get selected folder */
6281 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
6282 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6283 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6285 /* Switch help_id */
6286 if (folder_store && TNY_IS_FOLDER (folder_store))
6287 help_id = modest_tny_folder_get_help_id (TNY_FOLDER (folder_store));
6290 g_object_unref (folder_store);
6293 modest_platform_show_help (GTK_WINDOW (win), help_id);
6295 modest_ui_actions_on_help (action, win);
6300 retrieve_contents_cb (ModestMailOperation *mail_op,
6307 /* We only need this callback to show an error in case of
6308 memory low condition */
6309 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
6310 g_debug ("%s: message failed to retrieve. Memory low?", __FUNCTION__);
6315 retrieve_msg_contents_performer (gboolean canceled,
6317 GtkWindow *parent_window,
6318 TnyAccount *account,
6321 ModestMailOperation *mail_op;
6322 TnyList *headers = TNY_LIST (user_data);
6324 if (err || canceled) {
6325 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
6326 (GtkWidget *) parent_window, err,
6331 /* Create mail operation */
6332 mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
6333 modest_ui_actions_disk_operations_error_handler,
6335 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
6336 modest_mail_operation_get_msgs_full (mail_op, headers, retrieve_contents_cb, NULL, NULL);
6339 g_object_unref (mail_op);
6341 g_object_unref (headers);
6342 g_object_unref (account);
6346 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
6347 ModestWindow *window)
6349 TnyList *headers = NULL;
6350 TnyAccount *account = NULL;
6351 TnyIterator *iter = NULL;
6352 TnyHeader *header = NULL;
6353 TnyFolder *folder = NULL;
6356 headers = get_selected_headers (window);
6360 /* Pick the account */
6361 iter = tny_list_create_iterator (headers);
6362 header = TNY_HEADER (tny_iterator_get_current (iter));
6363 folder = tny_header_get_folder (header);
6364 account = tny_folder_get_account (folder);
6365 g_object_unref (folder);
6366 g_object_unref (header);
6367 g_object_unref (iter);
6369 /* Connect and perform the message retrieval */
6370 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6371 g_object_ref (account),
6372 retrieve_msg_contents_performer,
6373 g_object_ref (headers));
6376 g_object_unref (account);
6377 g_object_unref (headers);
6381 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
6383 g_return_if_fail (MODEST_IS_WINDOW (window));
6386 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_TOOLBAR);
6390 modest_ui_actions_check_menu_dimming_rules (ModestWindow *window)
6392 g_return_if_fail (MODEST_IS_WINDOW (window));
6395 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_MENU);
6399 modest_ui_actions_on_email_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_edit_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_view_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_format_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_tools_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_attachment_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_toolbar_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_folder_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_header_view_csm_menu_activated (GtkAction *action,
6480 ModestWindow *window)
6482 g_return_if_fail (MODEST_IS_WINDOW (window));
6485 modest_ui_actions_check_menu_dimming_rules (window);
6489 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
6491 g_return_if_fail (MODEST_IS_WINDOW (window));
6493 /* we check for low-mem; in that case, show a warning, and don't allow
6496 if (modest_platform_check_memory_low (window, TRUE))
6499 modest_platform_show_search_messages (GTK_WINDOW (window));
6503 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
6505 g_return_if_fail (MODEST_IS_WINDOW (win));
6508 /* we check for low-mem; in that case, show a warning, and don't allow
6509 * for the addressbook
6511 if (modest_platform_check_memory_low (win, TRUE))
6515 modest_platform_show_addressbook (GTK_WINDOW (win));
6520 modest_ui_actions_on_toggle_find_in_page (GtkAction *action,
6521 ModestWindow *window)
6524 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
6526 if (GTK_IS_TOGGLE_ACTION (action))
6527 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
6531 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window),
6536 on_send_receive_finished (ModestMailOperation *mail_op,
6539 GtkWidget *header_view, *folder_view;
6540 TnyFolderStore *folder_store;
6541 ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
6543 /* Set send/receive operation finished */
6544 modest_main_window_notify_send_receive_completed (main_win);
6546 /* Don't refresh the current folder if there were any errors */
6547 if (modest_mail_operation_get_status (mail_op) !=
6548 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
6551 /* Refresh the current folder if we're viewing a window. We do
6552 this because the user won't be able to see the new mails in
6553 the selected folder after a Send&Receive because it only
6554 performs a poke_status, i.e, only the number of read/unread
6555 messages is updated, but the new headers are not
6557 folder_view = modest_main_window_get_child_widget (main_win,
6558 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6562 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6564 /* Do not need to refresh INBOX again because the
6565 update_account does it always automatically */
6566 if (folder_store && TNY_IS_FOLDER (folder_store) &&
6567 tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
6568 ModestMailOperation *refresh_op;
6570 header_view = modest_main_window_get_child_widget (main_win,
6571 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6573 /* We do not need to set the contents style
6574 because it hasn't changed. We also do not
6575 need to save the widget status. Just force
6577 refresh_op = modest_mail_operation_new (G_OBJECT (main_win));
6578 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), refresh_op);
6579 modest_mail_operation_refresh_folder (refresh_op, TNY_FOLDER (folder_store),
6580 folder_refreshed_cb, main_win);
6581 g_object_unref (refresh_op);
6585 g_object_unref (folder_store);
6590 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
6596 const gchar* server_name = NULL;
6597 TnyTransportAccount *transport;
6598 gchar *message = NULL;
6599 ModestProtocol *protocol;
6601 /* Don't show anything if the user cancelled something or the
6602 * send receive request is not interactive. Authentication
6603 * errors are managed by the account store so no need to show
6604 * a dialog here again */
6605 if (err->code == TNY_SYSTEM_ERROR_CANCEL ||
6606 err->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
6607 !modest_tny_send_queue_get_requested_send_receive (MODEST_TNY_SEND_QUEUE (self)))
6611 /* Get the server name. Note that we could be using a
6612 connection specific transport account */
6613 transport = (TnyTransportAccount *)
6614 tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
6616 ModestTnyAccountStore *acc_store;
6617 const gchar *acc_name;
6618 TnyTransportAccount *conn_specific;
6620 acc_store = modest_runtime_get_account_store();
6621 acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
6622 conn_specific = (TnyTransportAccount *)
6623 modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
6624 if (conn_specific) {
6625 server_name = tny_account_get_hostname (TNY_ACCOUNT (conn_specific));
6626 g_object_unref (conn_specific);
6628 server_name = tny_account_get_hostname (TNY_ACCOUNT (transport));
6630 g_object_unref (transport);
6634 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
6635 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
6636 tny_account_get_proto (TNY_ACCOUNT (transport)));
6638 g_warning ("%s: Account with no proto", __FUNCTION__);
6642 /* Show the appropriate message text for the GError: */
6643 switch (err->code) {
6644 case TNY_SERVICE_ERROR_CONNECT:
6645 message = modest_protocol_get_translation (protocol,
6646 MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
6649 case TNY_SERVICE_ERROR_SEND:
6650 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6652 case TNY_SERVICE_ERROR_UNAVAILABLE:
6653 message = modest_protocol_get_translation (protocol,
6654 MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR,
6658 g_warning ("%s: unexpected ERROR %d",
6659 __FUNCTION__, err->code);
6660 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6664 modest_platform_run_information_dialog (NULL, message, FALSE);
6669 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
6674 ModestWindow *top_window = NULL;
6675 ModestWindowMgr *mgr = NULL;
6676 GtkWidget *header_view = NULL;
6677 TnyFolder *selected_folder = NULL;
6678 TnyFolderType folder_type;
6680 mgr = modest_runtime_get_window_mgr ();
6681 top_window = modest_window_mgr_get_current_top (mgr);
6686 #ifndef MODEST_TOOLKIT_HILDON2
6687 if (MODEST_IS_MAIN_WINDOW (top_window)) {
6688 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (top_window),
6689 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6692 if (MODEST_IS_HEADER_WINDOW (top_window)) {
6693 header_view = (GtkWidget *)
6694 modest_header_window_get_header_view (MODEST_HEADER_WINDOW (top_window));
6698 /* Get selected folder */
6700 selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
6701 if (!selected_folder)
6704 /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
6705 #if GTK_CHECK_VERSION(2, 8, 0)
6706 folder_type = modest_tny_folder_guess_folder_type (selected_folder);
6707 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
6708 GtkTreeViewColumn *tree_column;
6710 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
6711 TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
6713 gtk_tree_view_column_queue_resize (tree_column);
6715 #else /* #if GTK_CHECK_VERSION(2, 8, 0) */
6716 gtk_widget_queue_draw (header_view);
6719 #ifndef MODEST_TOOLKIT_HILDON2
6720 /* Rerun dimming rules, because the message could become deletable for example */
6721 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6722 MODEST_DIMMING_RULES_TOOLBAR);
6723 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6724 MODEST_DIMMING_RULES_MENU);
6728 g_object_unref (selected_folder);
6732 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
6733 TnyAccount *account)
6735 ModestProtocolType protocol_type;
6736 ModestProtocol *protocol;
6737 gchar *error_note = NULL;
6739 protocol_type = modest_tny_account_get_protocol_type (account);
6740 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6743 error_note = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, tny_account_get_hostname (account));
6744 if (error_note == NULL) {
6745 g_warning ("%s: This should not be reached", __FUNCTION__);
6747 modest_platform_run_information_dialog (parent_window, error_note, FALSE);
6748 g_free (error_note);
6753 modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
6757 TnyFolderStore *folder = NULL;
6758 TnyAccount *account = NULL;
6759 ModestProtocolType proto;
6760 ModestProtocol *protocol;
6761 TnyHeader *header = NULL;
6763 if (MODEST_IS_MAIN_WINDOW (win)) {
6764 GtkWidget *header_view;
6765 TnyList* headers = NULL;
6767 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
6768 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6769 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6770 if (!headers || tny_list_get_length (headers) == 0) {
6772 g_object_unref (headers);
6775 iter = tny_list_create_iterator (headers);
6776 header = TNY_HEADER (tny_iterator_get_current (iter));
6777 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6778 g_object_unref (iter);
6779 g_object_unref (headers);
6780 #ifdef MODEST_TOOLKIT_HILDON2
6781 } else if (MODEST_IS_HEADER_WINDOW (win)) {
6782 GtkWidget *header_view;
6783 TnyList* headers = NULL;
6785 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
6786 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6787 if (!headers || tny_list_get_length (headers) == 0) {
6789 g_object_unref (headers);
6792 iter = tny_list_create_iterator (headers);
6793 header = TNY_HEADER (tny_iterator_get_current (iter));
6795 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6797 g_warning ("List should contain headers");
6799 g_object_unref (iter);
6800 g_object_unref (headers);
6802 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
6803 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
6805 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6808 if (!header || !folder)
6811 /* Get the account type */
6812 account = tny_folder_get_account (TNY_FOLDER (folder));
6813 proto = modest_tny_account_get_protocol_type (account);
6814 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6817 subject = tny_header_dup_subject (header);
6818 msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
6822 msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
6828 g_object_unref (account);
6830 g_object_unref (folder);
6832 g_object_unref (header);
6838 modest_ui_actions_on_delete_account (GtkWindow *parent_window,
6839 const gchar *account_name,
6840 const gchar *account_title)
6842 ModestAccountMgr *account_mgr;
6845 ModestProtocol *protocol;
6846 gboolean removed = FALSE;
6848 g_return_val_if_fail (account_name, FALSE);
6849 g_return_val_if_fail (account_title, FALSE);
6851 account_mgr = modest_runtime_get_account_mgr();
6853 /* The warning text depends on the account type: */
6854 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6855 modest_account_mgr_get_store_protocol (account_mgr,
6857 txt = modest_protocol_get_translation (protocol,
6858 MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX,
6861 txt = g_strdup_printf (_("emev_nc_delete_mailbox"), account_title);
6863 response = modest_platform_run_confirmation_dialog (parent_window, txt);
6867 if (response == GTK_RESPONSE_OK) {
6868 /* Remove account. If it succeeds then it also removes
6869 the account from the ModestAccountView: */
6870 gboolean is_default = FALSE;
6871 gchar *default_account_name = modest_account_mgr_get_default_account (account_mgr);
6872 if (default_account_name && (strcmp (default_account_name, account_name) == 0))
6874 g_free (default_account_name);
6876 removed = modest_account_mgr_remove_account (account_mgr, account_name);
6878 /* Close all email notifications, we cannot
6879 distinguish if the notification belongs to
6880 this account or not, so for safety reasons
6881 we remove them all */
6882 modest_platform_remove_new_mail_notifications (FALSE);
6884 g_warning ("%s: modest_account_mgr_remove_account() failed.\n", __FUNCTION__);
6891 on_fetch_images_performer (gboolean canceled,
6893 GtkWindow *parent_window,
6894 TnyAccount *account,
6897 if (err || canceled) {
6898 /* Show an unable to retrieve images ??? */
6902 /* Note that the user could have closed the window while connecting */
6903 if (GTK_WIDGET_VISIBLE (parent_window))
6904 modest_msg_view_window_fetch_images ((ModestMsgViewWindow *) parent_window);
6905 g_object_unref ((GObject *) user_data);
6909 modest_ui_actions_on_fetch_images (GtkAction *action,
6910 ModestWindow *window)
6912 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
6914 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6916 on_fetch_images_performer,
6917 g_object_ref (window));
6921 modest_ui_actions_on_reload_message (const gchar *msg_id)
6923 ModestWindow *window = NULL;
6925 g_return_if_fail (msg_id && msg_id[0] != '\0');
6926 if (!modest_window_mgr_find_registered_message_uid (modest_runtime_get_window_mgr (),
6932 if (window == NULL || !MODEST_IS_MSG_VIEW_WINDOW (window))
6935 modest_msg_view_window_reload (MODEST_MSG_VIEW_WINDOW (window));
6938 /** Check whether any connections are active, and cancel them if
6940 * Returns TRUE is there was no problem,
6941 * or if an operation was cancelled so we can continue.
6942 * Returns FALSE if the user chose to cancel his request instead.
6946 modest_ui_actions_check_for_active_account (ModestWindow *self,
6947 const gchar* account_name)
6949 ModestTnySendQueue *send_queue;
6950 ModestTnyAccountStore *acc_store;
6951 ModestMailOperationQueue* queue;
6952 TnyConnectionStatus store_conn_status;
6953 TnyAccount *store_account = NULL, *transport_account = NULL;
6954 gboolean retval = TRUE, sending = FALSE;
6956 acc_store = modest_runtime_get_account_store ();
6957 queue = modest_runtime_get_mail_operation_queue ();
6960 modest_tny_account_store_get_server_account (acc_store,
6962 TNY_ACCOUNT_TYPE_STORE);
6964 /* This could happen if the account was deleted before the
6965 call to this function */
6970 modest_tny_account_store_get_server_account (acc_store,
6972 TNY_ACCOUNT_TYPE_TRANSPORT);
6974 /* This could happen if the account was deleted before the
6975 call to this function */
6976 if (!transport_account) {
6977 g_object_unref (store_account);
6981 /* If the transport account was not used yet, then the send
6982 queue could not exist (it's created on demand) */
6983 send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (transport_account), FALSE);
6984 if (TNY_IS_SEND_QUEUE (send_queue))
6985 sending = modest_tny_send_queue_sending_in_progress (send_queue);
6987 store_conn_status = tny_account_get_connection_status (store_account);
6988 if (store_conn_status == TNY_CONNECTION_STATUS_CONNECTED || sending) {
6991 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (self),
6992 _("emev_nc_disconnect_account"));
6993 if (response == GTK_RESPONSE_OK) {
7002 /* FIXME: We should only cancel those of this account */
7003 modest_mail_operation_queue_cancel_all (queue);
7005 /* Also disconnect the account */
7006 if ((tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED) &&
7007 (tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED_BROKEN)) {
7008 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account),
7012 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account),
7018 g_object_unref (store_account);
7019 g_object_unref (transport_account);