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 /* Messages are ordered from most
2183 recent to oldest. But we want to
2184 show notifications starting from
2185 the oldest message. That's why we
2187 tny_list_prepend (actually_new_list, G_OBJECT (header));
2189 g_object_unref (header);
2191 g_object_unref (iterator);
2193 if (tny_list_get_length (actually_new_list) > 0) {
2194 GList *new_headers_list = NULL;
2196 new_headers_list = modest_utils_create_notification_list_from_header_list (actually_new_list);
2198 /* Send notifications */
2199 if (new_headers_list) {
2200 modest_platform_on_new_headers_received (new_headers_list,
2201 show_visual_notifications);
2203 modest_utils_free_notification_list (new_headers_list);
2206 g_object_unref (actually_new_list);
2212 retrieve_all_messages_cb (GObject *source,
2214 guint retrieve_limit)
2220 window = GTK_WINDOW (source);
2221 msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"),
2222 num_msgs, retrieve_limit);
2224 /* Ask the user if they want to retrieve all the messages */
2226 modest_platform_run_confirmation_dialog_with_buttons (window, msg,
2227 _("mcen_bd_get_all"),
2228 _("mcen_bd_newest_only"));
2229 /* Free and return */
2231 return (response == GTK_RESPONSE_ACCEPT) ? TRUE : FALSE;
2235 TnyAccount *account;
2237 gchar *account_name;
2238 gboolean poke_status;
2239 gboolean interactive;
2240 ModestMailOperation *mail_op;
2244 do_send_receive_performer (gboolean canceled,
2246 GtkWindow *parent_window,
2247 TnyAccount *account,
2250 SendReceiveInfo *info;
2252 info = (SendReceiveInfo *) user_data;
2254 if (err || canceled) {
2255 /* In disk full conditions we could get this error here */
2256 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
2257 (GtkWidget *) parent_window, err,
2260 if (info->mail_op) {
2261 modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (),
2267 /* Set send/receive operation in progress */
2268 if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
2269 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
2272 if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
2273 g_signal_connect (G_OBJECT (info->mail_op), "operation-finished",
2274 G_CALLBACK (on_send_receive_finished),
2277 /* Send & receive. */
2278 modest_mail_operation_update_account (info->mail_op, info->account_name, info->poke_status, info->interactive,
2279 (info->win) ? retrieve_all_messages_cb : NULL,
2280 new_messages_arrived, info->win);
2285 g_object_unref (G_OBJECT (info->mail_op));
2286 if (info->account_name)
2287 g_free (info->account_name);
2289 g_object_unref (info->win);
2291 g_object_unref (info->account);
2292 g_slice_free (SendReceiveInfo, info);
2296 * This function performs the send & receive required actions. The
2297 * window is used to create the mail operation. Typically it should
2298 * always be the main window, but we pass it as argument in order to
2302 modest_ui_actions_do_send_receive (const gchar *account_name,
2303 gboolean force_connection,
2304 gboolean poke_status,
2305 gboolean interactive,
2308 gchar *acc_name = NULL;
2309 SendReceiveInfo *info;
2310 ModestTnyAccountStore *acc_store;
2311 TnyAccount *account;
2313 /* If no account name was provided then get the current account, and if
2314 there is no current account then pick the default one: */
2315 if (!account_name) {
2317 acc_name = g_strdup (modest_window_get_active_account (win));
2319 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
2321 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2325 acc_name = g_strdup (account_name);
2328 acc_store = modest_runtime_get_account_store ();
2329 account = modest_tny_account_store_get_server_account (acc_store, acc_name, TNY_ACCOUNT_TYPE_STORE);
2333 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2337 /* Do not automatically refresh accounts that are flagged as
2338 NO_AUTO_UPDATE. This could be useful for accounts that
2339 handle their own update times */
2341 ModestProtocolType proto = modest_tny_account_get_protocol_type (account);
2342 if (proto != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
2343 const gchar *tag = MODEST_PROTOCOL_REGISTRY_NO_AUTO_UPDATE_PROTOCOLS;
2344 ModestProtocolRegistry *registry = modest_runtime_get_protocol_registry ();
2346 if (modest_protocol_registry_protocol_type_has_tag (registry, proto, tag)) {
2347 g_debug ("%s no auto update allowed for account %s", __FUNCTION__, account_name);
2348 g_object_unref (account);
2355 /* Create the info for the connect and perform */
2356 info = g_slice_new (SendReceiveInfo);
2357 info->account_name = acc_name;
2358 info->win = (win) ? g_object_ref (win) : NULL;
2359 info->poke_status = poke_status;
2360 info->interactive = interactive;
2361 info->account = account;
2362 /* We need to create the operation here, because otherwise it
2363 could happen that the queue emits the queue-empty signal
2364 while we're trying to connect the account */
2365 info->mail_op = modest_mail_operation_new_with_error_handling ((info->win) ? G_OBJECT (info->win) : NULL,
2366 modest_ui_actions_disk_operations_error_handler,
2368 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), info->mail_op);
2370 /* Invoke the connect and perform */
2371 modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
2372 force_connection, info->account,
2373 do_send_receive_performer, info);
2378 modest_ui_actions_do_cancel_send (const gchar *account_name,
2381 TnyTransportAccount *transport_account;
2382 TnySendQueue *send_queue = NULL;
2383 GError *error = NULL;
2385 /* Get transport account */
2387 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2388 (modest_runtime_get_account_store(),
2390 TNY_ACCOUNT_TYPE_TRANSPORT));
2391 if (!transport_account) {
2392 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2397 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account, TRUE));
2398 if (!TNY_IS_SEND_QUEUE(send_queue)) {
2399 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
2400 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2401 "modest: could not find send queue for account\n");
2403 /* Cancel the current send */
2404 tny_account_cancel (TNY_ACCOUNT (transport_account));
2406 /* Suspend all pending messages */
2407 tny_send_queue_cancel (send_queue, TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, &error);
2411 if (transport_account != NULL)
2412 g_object_unref (G_OBJECT (transport_account));
2416 modest_ui_actions_cancel_send_all (ModestWindow *win)
2418 GSList *account_names, *iter;
2420 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2423 iter = account_names;
2425 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
2426 iter = g_slist_next (iter);
2429 modest_account_mgr_free_account_names (account_names);
2430 account_names = NULL;
2434 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
2437 /* Check if accounts exist */
2438 gboolean accounts_exist =
2439 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2441 /* If not, allow the user to create an account before trying to send/receive. */
2442 if (!accounts_exist)
2443 modest_ui_actions_on_accounts (NULL, win);
2445 /* Cancel all sending operaitons */
2446 modest_ui_actions_cancel_send_all (win);
2450 * Refreshes all accounts. This function will be used by automatic
2454 modest_ui_actions_do_send_receive_all (ModestWindow *win,
2455 gboolean force_connection,
2456 gboolean poke_status,
2457 gboolean interactive)
2459 GSList *account_names, *iter;
2461 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2464 iter = account_names;
2466 modest_ui_actions_do_send_receive ((const char*) iter->data,
2468 poke_status, interactive, win);
2469 iter = g_slist_next (iter);
2472 modest_account_mgr_free_account_names (account_names);
2473 account_names = NULL;
2477 * Handler of the click on Send&Receive button in the main toolbar
2480 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
2482 /* Check if accounts exist */
2483 gboolean accounts_exist;
2486 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2488 /* If not, allow the user to create an account before trying to send/receive. */
2489 if (!accounts_exist)
2490 modest_ui_actions_on_accounts (NULL, win);
2492 /* Refresh the current folder. The if is always TRUE it's just an extra check */
2493 if (MODEST_IS_MAIN_WINDOW (win)) {
2494 GtkWidget *folder_view;
2495 TnyFolderStore *folder_store;
2498 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2499 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2503 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2506 g_object_unref (folder_store);
2507 /* Refresh the active account. Force the connection if needed
2508 and poke the status of all folders */
2509 modest_ui_actions_do_send_receive (NULL, TRUE, TRUE, TRUE, win);
2510 #ifdef MODEST_TOOLKIT_HILDON2
2511 } else if (MODEST_IS_ACCOUNTS_WINDOW (win)) {
2512 modest_ui_actions_do_send_receive_all (win, TRUE, TRUE, TRUE);
2515 const gchar *active_account;
2516 active_account = modest_window_get_active_account (MODEST_WINDOW (win));
2518 modest_ui_actions_do_send_receive (active_account, TRUE, TRUE, TRUE, win);
2525 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
2528 GtkWidget *header_view;
2530 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2532 header_view = modest_main_window_get_child_widget (main_window,
2533 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2537 conf = modest_runtime_get_conf ();
2539 /* what is saved/restored is depending on the style; thus; we save with
2540 * old style, then update the style, and restore for this new style
2542 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
2544 if (modest_header_view_get_style
2545 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
2546 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2547 MODEST_HEADER_VIEW_STYLE_TWOLINES);
2549 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2550 MODEST_HEADER_VIEW_STYLE_DETAILS);
2552 modest_widget_memory_restore (conf, G_OBJECT(header_view),
2553 MODEST_CONF_HEADER_VIEW_KEY);
2558 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
2560 ModestMainWindow *main_window)
2562 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2563 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2565 /* in the case the folder is empty, show the empty folder message and focus
2567 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
2568 if (modest_header_view_is_empty (header_view)) {
2569 TnyFolder *folder = modest_header_view_get_folder (header_view);
2570 GtkWidget *folder_view =
2571 modest_main_window_get_child_widget (main_window,
2572 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2573 if (folder != NULL) {
2574 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
2575 g_object_unref (folder);
2577 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
2581 /* If no header has been selected then exit */
2586 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
2587 gtk_widget_grab_focus (GTK_WIDGET(header_view));
2589 /* Update toolbar dimming state */
2590 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2591 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2595 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
2598 ModestWindow *window)
2600 GtkWidget *open_widget;
2601 GtkTreeRowReference *rowref;
2603 g_return_if_fail (MODEST_IS_WINDOW(window));
2604 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2605 g_return_if_fail (TNY_IS_HEADER (header));
2607 if (modest_header_view_count_selected_headers (header_view) > 1) {
2608 /* Don't allow activation if there are more than one message selected */
2609 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
2613 /* we check for low-mem; in that case, show a warning, and don't allow
2614 * activating headers
2616 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
2619 if (MODEST_IS_MAIN_WINDOW (window)) {
2620 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
2621 open_widget = modest_window_get_action_widget (MODEST_WINDOW (window), "/MenuBar/EmailMenu/EmailOpenMenu");
2622 if (!GTK_WIDGET_IS_SENSITIVE (open_widget))
2626 rowref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)), path);
2627 open_msg_from_header (header, rowref, MODEST_WINDOW (window));
2628 gtk_tree_row_reference_free (rowref);
2632 set_active_account_from_tny_account (TnyAccount *account,
2633 ModestWindow *window)
2635 const gchar *server_acc_name = tny_account_get_id (account);
2637 /* We need the TnyAccount provided by the
2638 account store because that is the one that
2639 knows the name of the Modest account */
2640 TnyAccount *modest_server_account =
2641 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
2642 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
2644 if (!modest_server_account) {
2645 g_warning ("%s: could not get tny account\n", __FUNCTION__);
2649 /* Update active account, but only if it's not a pseudo-account */
2650 if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
2651 (!modest_tny_account_is_memory_card_account(modest_server_account))) {
2652 const gchar *modest_acc_name =
2653 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
2654 if (modest_acc_name)
2655 modest_window_set_active_account (window, modest_acc_name);
2658 g_object_unref (modest_server_account);
2663 folder_refreshed_cb (ModestMailOperation *mail_op,
2667 ModestMainWindow *win = NULL;
2668 GtkWidget *folder_view, *header_view;
2669 const GError *error;
2671 g_return_if_fail (TNY_IS_FOLDER (folder));
2673 win = MODEST_MAIN_WINDOW (user_data);
2675 /* Check if the operation failed due to memory low conditions */
2676 error = modest_mail_operation_get_error (mail_op);
2677 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
2678 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
2679 modest_platform_run_information_dialog (GTK_WINDOW (win),
2680 _KR("memr_ib_operation_disabled"),
2686 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2688 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2691 TnyFolderStore *current_folder;
2693 current_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2694 if (current_folder) {
2695 gboolean different = ((TnyFolderStore *) folder != current_folder);
2696 g_object_unref (current_folder);
2702 /* Check if folder is empty and set headers view contents style */
2703 if ((tny_folder_get_all_count (folder) == 0) ||
2704 modest_header_view_is_empty (MODEST_HEADER_VIEW (header_view)))
2705 modest_main_window_set_contents_style (win,
2706 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2710 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2711 TnyFolderStore *folder_store,
2713 ModestMainWindow *main_window)
2715 GtkWidget *header_view;
2717 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2719 header_view = modest_main_window_get_child_widget(main_window,
2720 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2725 if (TNY_IS_ACCOUNT (folder_store)) {
2727 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2729 /* Show account details */
2730 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2733 if (TNY_IS_FOLDER (folder_store) && selected) {
2734 TnyAccount *account;
2736 /* Update the active account */
2737 account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2739 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2740 g_object_unref (account);
2744 /* Set the header style by default, it could
2745 be changed later by the refresh callback to
2747 modest_main_window_set_contents_style (main_window,
2748 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2750 /* Set folder on header view. This function
2751 will call tny_folder_refresh_async so we
2752 pass a callback that will be called when
2753 finished. We use that callback to set the
2754 empty view if there are no messages */
2755 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2756 TNY_FOLDER (folder_store),
2758 MODEST_WINDOW (main_window),
2759 folder_refreshed_cb,
2762 /* Restore configuration. We need to do this
2763 *after* the set_folder because the widget
2764 memory asks the header view about its
2766 modest_widget_memory_restore (modest_runtime_get_conf (),
2767 G_OBJECT(header_view),
2768 MODEST_CONF_HEADER_VIEW_KEY);
2770 /* No need to save the header view
2771 configuration for Maemo because it only
2772 saves the sorting stuff and that it's
2773 already being done by the sort
2774 dialog. Remove it when the GNOME version
2775 has the same behaviour */
2776 #ifdef MODEST_TOOLKIT_GTK
2777 if (modest_main_window_get_contents_style (main_window) ==
2778 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2779 modest_widget_memory_save (modest_runtime_get_conf (),
2780 G_OBJECT (header_view),
2781 MODEST_CONF_HEADER_VIEW_KEY);
2783 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2787 /* Update dimming state */
2788 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2789 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2793 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2800 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2802 online = tny_device_is_online (modest_runtime_get_device());
2805 /* already online -- the item is simply not there... */
2806 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2808 GTK_MESSAGE_WARNING,
2810 _("The %s you selected cannot be found"),
2812 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2813 gtk_dialog_run (GTK_DIALOG(dialog));
2815 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2818 _("mcen_bd_dialog_cancel"),
2819 GTK_RESPONSE_REJECT,
2820 _("mcen_bd_dialog_ok"),
2821 GTK_RESPONSE_ACCEPT,
2823 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2824 "Do you want to get online?"), item);
2825 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
2826 gtk_label_new (txt), FALSE, FALSE, 0);
2827 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2830 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2831 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2832 /* TODO: Comment about why is this commented out: */
2833 /* modest_platform_connect_and_wait (); */
2836 gtk_widget_destroy (dialog);
2840 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2843 /* g_debug ("%s %s", __FUNCTION__, link); */
2848 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2851 modest_platform_activate_uri (link);
2855 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2858 modest_platform_show_uri_popup (link);
2862 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2865 /* we check for low-mem; in that case, show a warning, and don't allow
2866 * viewing attachments
2868 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
2871 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2875 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2876 const gchar *address,
2879 /* g_debug ("%s %s", __FUNCTION__, address); */
2883 on_save_to_drafts_cb (ModestMailOperation *mail_op,
2884 TnyMsg *saved_draft,
2887 ModestMsgEditWindow *edit_window;
2889 /* TODO: in hildon 2 we have to dim and undim the header views while we're saving */
2890 #ifndef MODEST_TOOLKIT_HILDON2
2891 ModestMainWindow *win;
2893 /* FIXME. Make the header view sensitive again. This is a
2894 * temporary hack. See modest_ui_actions_on_save_to_drafts()
2896 win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2897 modest_runtime_get_window_mgr(), FALSE));
2899 GtkWidget *hdrview = modest_main_window_get_child_widget(
2900 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2901 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2905 edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2907 /* Set draft is there was no error */
2908 if (!modest_mail_operation_get_error (mail_op))
2909 modest_msg_edit_window_set_draft (edit_window, saved_draft);
2911 g_object_unref(edit_window);
2915 enough_space_for_message (ModestMsgEditWindow *edit_window,
2918 guint64 available_disk, expected_size;
2923 available_disk = modest_utils_get_available_space (NULL);
2924 modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2925 expected_size = modest_tny_msg_estimate_size (data->plain_body,
2930 /* Double check: disk full condition or message too big */
2931 if (available_disk < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE ||
2932 expected_size > available_disk) {
2933 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
2934 modest_platform_information_banner (NULL, NULL, msg);
2941 * djcb: if we're in low-memory state, we only allow for
2942 * saving messages smaller than
2943 * MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE (see modest-defs.h) this
2944 * should still allow for sending anything critical...
2946 if ((expected_size > MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE) &&
2947 modest_platform_check_memory_low (MODEST_WINDOW(edit_window), TRUE))
2951 * djcb: we also make sure that the attachments are smaller than the max size
2952 * this is for the case where we'd try to forward a message with attachments
2953 * bigger than our max allowed size, or sending an message from drafts which
2954 * somehow got past our checks when attaching.
2956 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
2957 modest_platform_run_information_dialog (
2958 GTK_WINDOW(edit_window),
2959 _("mail_ib_error_attachment_size"),
2968 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2970 TnyTransportAccount *transport_account;
2971 ModestMailOperation *mail_operation;
2973 gchar *account_name;
2974 ModestAccountMgr *account_mgr;
2975 gboolean had_error = FALSE;
2976 ModestMainWindow *win = NULL;
2978 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
2980 data = modest_msg_edit_window_get_msg_data (edit_window);
2983 if (!enough_space_for_message (edit_window, data)) {
2984 modest_msg_edit_window_free_msg_data (edit_window, data);
2988 account_name = g_strdup (data->account_name);
2989 account_mgr = modest_runtime_get_account_mgr();
2991 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2993 account_name = modest_account_mgr_get_default_account (account_mgr);
2994 if (!account_name) {
2995 g_printerr ("modest: no account found\n");
2996 modest_msg_edit_window_free_msg_data (edit_window, data);
3000 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
3001 account_name = g_strdup (data->account_name);
3005 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3006 (modest_runtime_get_account_store (),
3008 TNY_ACCOUNT_TYPE_TRANSPORT));
3009 if (!transport_account) {
3010 g_printerr ("modest: no transport account found for '%s'\n", account_name);
3011 g_free (account_name);
3012 modest_msg_edit_window_free_msg_data (edit_window, data);
3016 /* Create the mail operation */
3017 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler,
3019 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3021 modest_mail_operation_save_to_drafts (mail_operation,
3033 data->priority_flags,
3036 on_save_to_drafts_cb,
3037 g_object_ref(edit_window));
3039 #ifdef MODEST_TOOLKIT_HILDON2
3040 /* In hildon2 we always show the information banner on saving to drafts.
3041 * It will be a system information banner in this case.
3043 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3044 modest_platform_information_banner (NULL, NULL, text);
3047 /* Use the main window as the parent of the banner, if the
3048 main window does not exist it won't be shown, if the parent
3049 window exists then it's properly shown. We don't use the
3050 editor window because it could be closed (save to drafts
3051 could happen after closing the window */
3052 win = (ModestMainWindow *)
3053 modest_window_mgr_get_main_window( modest_runtime_get_window_mgr(), FALSE);
3055 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3056 modest_platform_information_banner (GTK_WIDGET (win), NULL, text);
3060 modest_msg_edit_window_set_modified (edit_window, FALSE);
3063 g_free (account_name);
3064 g_object_unref (G_OBJECT (transport_account));
3065 g_object_unref (G_OBJECT (mail_operation));
3067 modest_msg_edit_window_free_msg_data (edit_window, data);
3070 * If the drafts folder is selected then make the header view
3071 * insensitive while the message is being saved to drafts
3072 * (it'll be sensitive again in on_save_to_drafts_cb()). This
3073 * is not very clean but it avoids letting the drafts folder
3074 * in an inconsistent state: the user could edit the message
3075 * being saved and undesirable things would happen.
3076 * In the average case the user won't notice anything at
3077 * all. In the worst case (the user is editing a really big
3078 * file from Drafts) the header view will be insensitive
3079 * during the saving process (10 or 20 seconds, depending on
3080 * the message). Anyway this is just a quick workaround: once
3081 * we find a better solution it should be removed
3082 * See NB#65125 (commend #18) for details.
3084 if (!had_error && win != NULL) {
3085 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
3086 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
3088 TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
3090 if (modest_tny_folder_is_local_folder(folder)) {
3091 TnyFolderType folder_type;
3092 folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
3093 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
3094 GtkWidget *hdrview = modest_main_window_get_child_widget(
3095 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3096 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
3100 if (folder != NULL) g_object_unref(folder);
3107 /* For instance, when clicking the Send toolbar button when editing a message: */
3109 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
3111 TnyTransportAccount *transport_account = NULL;
3112 gboolean had_error = FALSE;
3114 ModestAccountMgr *account_mgr;
3115 gchar *account_name;
3116 ModestMailOperation *mail_operation;
3119 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
3121 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
3124 data = modest_msg_edit_window_get_msg_data (edit_window);
3126 if (data->subject == NULL || data->subject[0] == '\0') {
3127 /* Empty subject -> no send */
3128 modest_msg_edit_window_free_msg_data (edit_window, data);
3132 recipients = g_strconcat (data->to?data->to:"",
3133 data->cc?data->cc:"",
3134 data->bcc?data->bcc:"",
3136 if (recipients == NULL || recipients[0] == '\0') {
3137 /* Empty subject -> no send */
3138 g_free (recipients);
3139 modest_msg_edit_window_free_msg_data (edit_window, data);
3142 g_free (recipients);
3145 if (!enough_space_for_message (edit_window, data)) {
3146 modest_msg_edit_window_free_msg_data (edit_window, data);
3150 account_mgr = modest_runtime_get_account_mgr();
3151 account_name = g_strdup (data->account_name);
3153 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
3156 account_name = modest_account_mgr_get_default_account (account_mgr);
3158 if (!account_name) {
3159 modest_msg_edit_window_free_msg_data (edit_window, data);
3160 /* Run account setup wizard */
3161 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window))) {
3166 /* Get the currently-active transport account for this modest account: */
3167 if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
3169 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3170 (modest_runtime_get_account_store (),
3171 account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
3174 if (!transport_account) {
3175 modest_msg_edit_window_free_msg_data (edit_window, data);
3176 /* Run account setup wizard */
3177 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
3182 /* Create the mail operation */
3183 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler, NULL, NULL);
3184 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3186 modest_mail_operation_send_new_mail (mail_operation,
3200 data->priority_flags);
3202 if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3203 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
3205 if (modest_mail_operation_get_error (mail_operation) != NULL) {
3206 const GError *error = modest_mail_operation_get_error (mail_operation);
3207 if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3208 error->code == MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED) {
3209 g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_operation))->message);
3210 modest_platform_information_banner (NULL, NULL, _CS("sfil_ni_not_enough_memory"));
3216 g_free (account_name);
3217 g_object_unref (G_OBJECT (transport_account));
3218 g_object_unref (G_OBJECT (mail_operation));
3220 modest_msg_edit_window_free_msg_data (edit_window, data);
3223 modest_msg_edit_window_set_sent (edit_window, TRUE);
3225 /* Save settings and close the window: */
3226 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
3233 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
3234 ModestMsgEditWindow *window)
3236 ModestMsgEditFormatState *format_state = NULL;
3238 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3239 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3241 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3244 format_state = modest_msg_edit_window_get_format_state (window);
3245 g_return_if_fail (format_state != NULL);
3247 format_state->bold = gtk_toggle_action_get_active (action);
3248 modest_msg_edit_window_set_format_state (window, format_state);
3249 g_free (format_state);
3254 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
3255 ModestMsgEditWindow *window)
3257 ModestMsgEditFormatState *format_state = NULL;
3259 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3260 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3262 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3265 format_state = modest_msg_edit_window_get_format_state (window);
3266 g_return_if_fail (format_state != NULL);
3268 format_state->italics = gtk_toggle_action_get_active (action);
3269 modest_msg_edit_window_set_format_state (window, format_state);
3270 g_free (format_state);
3275 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
3276 ModestMsgEditWindow *window)
3278 ModestMsgEditFormatState *format_state = NULL;
3280 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3281 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3283 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3286 format_state = modest_msg_edit_window_get_format_state (window);
3287 g_return_if_fail (format_state != NULL);
3289 format_state->bullet = gtk_toggle_action_get_active (action);
3290 modest_msg_edit_window_set_format_state (window, format_state);
3291 g_free (format_state);
3296 modest_ui_actions_on_change_justify (GtkRadioAction *action,
3297 GtkRadioAction *selected,
3298 ModestMsgEditWindow *window)
3300 ModestMsgEditFormatState *format_state = NULL;
3301 GtkJustification value;
3303 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3305 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3308 value = gtk_radio_action_get_current_value (selected);
3310 format_state = modest_msg_edit_window_get_format_state (window);
3311 g_return_if_fail (format_state != NULL);
3313 format_state->justification = value;
3314 modest_msg_edit_window_set_format_state (window, format_state);
3315 g_free (format_state);
3319 modest_ui_actions_on_select_editor_color (GtkAction *action,
3320 ModestMsgEditWindow *window)
3322 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3323 g_return_if_fail (GTK_IS_ACTION (action));
3325 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3328 modest_msg_edit_window_select_color (window);
3332 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
3333 ModestMsgEditWindow *window)
3335 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3336 g_return_if_fail (GTK_IS_ACTION (action));
3338 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3341 modest_msg_edit_window_select_background_color (window);
3345 modest_ui_actions_on_insert_image (GObject *object,
3346 ModestMsgEditWindow *window)
3348 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3351 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3354 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3357 modest_msg_edit_window_insert_image (window);
3361 modest_ui_actions_on_attach_file (GtkAction *action,
3362 ModestMsgEditWindow *window)
3364 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3365 g_return_if_fail (GTK_IS_ACTION (action));
3367 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3370 modest_msg_edit_window_offer_attach_file (window);
3374 modest_ui_actions_on_remove_attachments (GtkAction *action,
3375 ModestMsgEditWindow *window)
3377 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3379 modest_msg_edit_window_remove_attachments (window, NULL);
3383 do_create_folder_cb (ModestMailOperation *mail_op,
3384 TnyFolderStore *parent_folder,
3385 TnyFolder *new_folder,
3388 gchar *suggested_name = (gchar *) user_data;
3389 GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
3390 const GError *error;
3392 error = modest_mail_operation_get_error (mail_op);
3394 gboolean disk_full = FALSE;
3395 TnyAccount *account;
3396 /* Show an error. If there was some problem writing to
3397 disk, show it, otherwise show the generic folder
3398 create error. We do it here and not in an error
3399 handler because the call to do_create_folder will
3400 stop the main loop in a gtk_dialog_run and then,
3401 the message won't be shown until that dialog is
3403 account = modest_mail_operation_get_account (mail_op);
3406 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3407 (GtkWidget *) source_win,
3410 _("mail_in_ui_folder_create_error_memory"));
3411 g_object_unref (account);
3414 /* Show an error and try again if there is no
3415 full memory condition */
3416 modest_platform_information_banner ((GtkWidget *) source_win, NULL,
3417 _("mail_in_ui_folder_create_error"));
3418 do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
3422 /* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
3423 * FIXME: any other? */
3424 GtkWidget *folder_view;
3426 if (MODEST_IS_MAIN_WINDOW(source_win))
3428 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
3429 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3431 folder_view = GTK_WIDGET(g_object_get_data (G_OBJECT (source_win),
3432 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
3434 /* Select the newly created folder. It could happen
3435 that the widget is no longer there (i.e. the window
3436 has been destroyed, so we need to check this */
3438 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
3440 g_object_unref (new_folder);
3442 /* Free. Note that the first time it'll be NULL so noop */
3443 g_free (suggested_name);
3444 g_object_unref (source_win);
3449 TnyFolderStore *parent;
3450 } CreateFolderConnect;
3453 do_create_folder_performer (gboolean canceled,
3455 GtkWindow *parent_window,
3456 TnyAccount *account,
3459 CreateFolderConnect *helper = (CreateFolderConnect *) user_data;
3460 ModestMailOperation *mail_op;
3462 if (canceled || err) {
3463 /* In disk full conditions we could get this error here */
3464 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3465 (GtkWidget *) parent_window, err,
3466 NULL, _("mail_in_ui_folder_create_error_memory"));
3468 /* This happens if we have selected the outbox folder
3470 if (err->code == TNY_SERVICE_ERROR_UNKNOWN &&
3471 TNY_IS_MERGE_FOLDER (helper->parent)) {
3472 /* Show an error and retry */
3473 modest_platform_information_banner ((GtkWidget *) parent_window,
3475 _("mail_in_ui_folder_create_error"));
3477 do_create_folder (parent_window, helper->parent, helper->folder_name);
3483 mail_op = modest_mail_operation_new ((GObject *) parent_window);
3484 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3486 modest_mail_operation_create_folder (mail_op,
3488 (const gchar *) helper->folder_name,
3489 do_create_folder_cb,
3490 g_strdup (helper->folder_name));
3491 g_object_unref (mail_op);
3495 g_object_unref (helper->parent);
3496 if (helper->folder_name)
3497 g_free (helper->folder_name);
3498 g_slice_free (CreateFolderConnect, helper);
3503 do_create_folder (GtkWindow *parent_window,
3504 TnyFolderStore *suggested_parent,
3505 const gchar *suggested_name)
3508 gchar *folder_name = NULL;
3509 TnyFolderStore *parent_folder = NULL;
3511 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
3513 (gchar *) suggested_name,
3517 if (result == GTK_RESPONSE_ACCEPT && parent_folder) {
3518 CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderConnect);
3519 helper->folder_name = g_strdup (folder_name);
3520 helper->parent = g_object_ref (parent_folder);
3522 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
3525 do_create_folder_performer,
3530 g_free (folder_name);
3532 g_object_unref (parent_folder);
3536 modest_ui_actions_create_folder(GtkWidget *parent_window,
3537 GtkWidget *folder_view,
3538 TnyFolderStore *parent_folder)
3540 if (!parent_folder) {
3541 #ifdef MODEST_TOOLKIT_HILDON2
3542 ModestTnyAccountStore *acc_store;
3544 acc_store = modest_runtime_get_account_store ();
3546 parent_folder = (TnyFolderStore *)
3547 modest_tny_account_store_get_local_folders_account (acc_store);
3549 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3553 if (parent_folder) {
3554 do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
3555 g_object_unref (parent_folder);
3560 modest_ui_actions_on_new_folder (GtkAction *action, ModestWindow *window)
3563 g_return_if_fail (MODEST_IS_WINDOW(window));
3565 if (MODEST_IS_MAIN_WINDOW (window)) {
3566 GtkWidget *folder_view;
3568 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3569 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3573 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3574 #ifdef MODEST_TOOLKIT_HILDON2
3575 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3576 GtkWidget *folder_view;
3578 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3579 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3582 g_assert_not_reached ();
3587 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
3590 const GError *error = NULL;
3591 gchar *message = NULL;
3593 TnyAccount *account = modest_mail_operation_get_account (mail_op);
3595 /* Get error message */
3596 error = modest_mail_operation_get_error (mail_op);
3598 g_return_if_reached ();
3600 mem_full = modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
3601 (GError *) error, account);
3603 message = g_strdup_printf (_KR("cerm_device_memory_full"), "");
3604 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3605 error->code == MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS) {
3606 message = _CS("ckdg_ib_folder_already_exists");
3607 } else if (error->domain == TNY_ERROR_DOMAIN &&
3608 error->code == TNY_SERVICE_ERROR_STATE) {
3609 /* This means that the folder is already in use (a
3610 message is opened for example */
3611 message = _("emev_ni_internal_error");
3613 message = _CS("ckdg_ib_unable_to_rename");
3616 /* We don't set a parent for the dialog because the dialog
3617 will be destroyed so the banner won't appear */
3618 modest_platform_information_banner (NULL, NULL, message);
3621 g_object_unref (account);
3627 TnyFolderStore *folder;
3632 on_rename_folder_cb (ModestMailOperation *mail_op,
3633 TnyFolder *new_folder,
3636 ModestFolderView *folder_view;
3638 /* If the window was closed when renaming a folder, or if
3639 * it's not a main window this will happen */
3640 if (!MODEST_IS_FOLDER_VIEW (user_data))
3643 folder_view = MODEST_FOLDER_VIEW (user_data);
3644 /* Note that if the rename fails new_folder will be NULL */
3646 modest_folder_view_select_folder (folder_view, new_folder, FALSE);
3648 modest_folder_view_select_first_inbox_or_local (folder_view);
3650 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
3654 on_rename_folder_performer (gboolean canceled,
3656 GtkWindow *parent_window,
3657 TnyAccount *account,
3660 ModestMailOperation *mail_op = NULL;
3661 GtkTreeSelection *sel = NULL;
3662 GtkWidget *folder_view = NULL;
3663 RenameFolderInfo *data = (RenameFolderInfo*)user_data;
3665 if (canceled || err) {
3666 /* In disk full conditions we could get this error here */
3667 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3668 (GtkWidget *) parent_window, err,
3673 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3674 modest_ui_actions_rename_folder_error_handler,
3675 parent_window, NULL);
3677 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3680 if (MODEST_IS_MAIN_WINDOW(parent_window)) {
3682 folder_view = modest_main_window_get_child_widget (
3683 MODEST_MAIN_WINDOW (parent_window),
3684 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3686 #ifdef MODEST_TOOLKIT_HILDON2
3687 else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3688 ModestFolderWindow *folder_window = (ModestFolderWindow *) parent_window;
3689 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (folder_window));
3693 /* Clear the folders view */
3694 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3695 gtk_tree_selection_unselect_all (sel);
3697 /* Actually rename the folder */
3698 modest_mail_operation_rename_folder (mail_op,
3699 TNY_FOLDER (data->folder),
3700 (const gchar *) (data->new_name),
3701 on_rename_folder_cb,
3703 g_object_unref (mail_op);
3706 g_object_unref (data->folder);
3707 g_free (data->new_name);
3712 modest_ui_actions_on_rename_folder (GtkAction *action,
3713 ModestWindow *window)
3715 modest_ui_actions_on_edit_mode_rename_folder (window);
3719 modest_ui_actions_on_edit_mode_rename_folder (ModestWindow *window)
3721 TnyFolderStore *folder;
3722 GtkWidget *folder_view;
3723 gboolean do_rename = TRUE;
3725 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3727 if (MODEST_IS_MAIN_WINDOW (window)) {
3728 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3729 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3733 #ifdef MODEST_TOOLKIT_HILDON2
3734 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3735 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3741 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3746 if (TNY_IS_FOLDER (folder)) {
3747 gchar *folder_name = NULL;
3749 const gchar *current_name;
3750 TnyFolderStore *parent;
3752 current_name = tny_folder_get_name (TNY_FOLDER (folder));
3753 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
3754 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (window),
3755 parent, current_name,
3757 g_object_unref (parent);
3759 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
3762 RenameFolderInfo *rename_folder_data = g_new0 (RenameFolderInfo, 1);
3763 rename_folder_data->folder = g_object_ref (folder);
3764 rename_folder_data->new_name = folder_name;
3765 modest_platform_connect_if_remote_and_perform (GTK_WINDOW(window), TRUE,
3766 folder, on_rename_folder_performer, rename_folder_data);
3769 g_object_unref (folder);
3774 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
3777 GObject *win = modest_mail_operation_get_source (mail_op);
3779 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
3780 _("mail_in_ui_folder_delete_error"),
3782 g_object_unref (win);
3786 TnyFolderStore *folder;
3787 gboolean move_to_trash;
3791 on_delete_folder_cb (gboolean canceled,
3793 GtkWindow *parent_window,
3794 TnyAccount *account,
3797 DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
3798 GtkWidget *folder_view;
3799 ModestMailOperation *mail_op;
3800 GtkTreeSelection *sel;
3802 if (!MODEST_IS_WINDOW(parent_window) || canceled || (err!=NULL)) {
3803 /* Note that the connection process can fail due to
3804 memory low conditions as it can not successfully
3805 store the summary */
3806 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3807 (GtkWidget*) parent_window, err,
3809 g_debug ("Error connecting when trying to delete a folder");
3810 g_object_unref (G_OBJECT (info->folder));
3815 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
3816 folder_view = modest_main_window_get_child_widget (
3817 MODEST_MAIN_WINDOW (parent_window),
3818 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3819 #ifdef MODEST_TOOLKIT_HILDON2
3820 } else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3821 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (parent_window)));
3824 g_object_unref (G_OBJECT (info->folder));
3829 /* Unselect the folder before deleting it to free the headers */
3830 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3831 gtk_tree_selection_unselect_all (sel);
3833 /* Create the mail operation */
3835 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3836 modest_ui_actions_delete_folder_error_handler,
3839 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3841 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
3843 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
3845 g_object_unref (G_OBJECT (mail_op));
3846 g_object_unref (G_OBJECT (info->folder));
3851 delete_folder (ModestWindow *window, gboolean move_to_trash)
3853 TnyFolderStore *folder;
3854 GtkWidget *folder_view;
3858 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3860 if (MODEST_IS_MAIN_WINDOW (window)) {
3862 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3863 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3864 #ifdef MODEST_TOOLKIT_HILDON2
3865 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3866 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3874 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3879 /* Show an error if it's an account */
3880 if (!TNY_IS_FOLDER (folder)) {
3881 modest_platform_run_information_dialog (GTK_WINDOW (window),
3882 _("mail_in_ui_folder_delete_error"),
3884 g_object_unref (G_OBJECT (folder));
3889 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
3890 tny_folder_get_name (TNY_FOLDER (folder)));
3891 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
3892 (const gchar *) message);
3895 if (response == GTK_RESPONSE_OK) {
3896 DeleteFolderInfo *info;
3897 info = g_new0(DeleteFolderInfo, 1);
3898 info->folder = folder;
3899 info->move_to_trash = move_to_trash;
3900 g_object_ref (G_OBJECT (info->folder));
3901 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder));
3902 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (window),
3904 TNY_FOLDER_STORE (account),
3905 on_delete_folder_cb, info);
3906 g_object_unref (account);
3911 g_object_unref (G_OBJECT (folder));
3915 modest_ui_actions_on_delete_folder (GtkAction *action,
3916 ModestWindow *window)
3918 modest_ui_actions_on_edit_mode_delete_folder (window);
3922 modest_ui_actions_on_edit_mode_delete_folder (ModestWindow *window)
3924 g_return_val_if_fail (MODEST_IS_WINDOW(window), TRUE);
3926 return delete_folder (window, FALSE);
3930 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
3932 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3934 delete_folder (MODEST_WINDOW (main_window), TRUE);
3938 typedef struct _PasswordDialogFields {
3939 GtkWidget *username;
3940 GtkWidget *password;
3942 } PasswordDialogFields;
3945 password_dialog_check_field (GtkEditable *editable,
3946 PasswordDialogFields *fields)
3949 gboolean any_value_empty = FALSE;
3951 #ifdef MODEST_TOOLKIT_HILDON2
3952 value = hildon_entry_get_text (HILDON_ENTRY (fields->username));
3954 value = gtk_entry_get_text (GTK_ENTRY (fields->username));
3956 if ((value == NULL) || value[0] == '\0') {
3957 any_value_empty = TRUE;
3959 #ifdef MODEST_TOOLKIT_HILDON2
3960 value = hildon_entry_get_text (HILDON_ENTRY (fields->password));
3962 value = gtk_entry_get_text (GTK_ENTRY (fields->password));
3964 if ((value == NULL) || value[0] == '\0') {
3965 any_value_empty = TRUE;
3967 gtk_dialog_set_response_sensitive (GTK_DIALOG (fields->dialog), GTK_RESPONSE_ACCEPT, !any_value_empty);
3971 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
3972 const gchar* server_account_name,
3977 ModestMainWindow *main_window)
3979 g_return_if_fail(server_account_name);
3980 gboolean completed = FALSE;
3981 PasswordDialogFields *fields = NULL;
3983 /* Initalize output parameters: */
3990 #ifndef MODEST_TOOLKIT_GTK
3991 /* Maemo uses a different (awkward) button order,
3992 * It should probably just use gtk_alternative_dialog_button_order ().
3994 #ifdef MODEST_TOOLKIT_HILDON2
3996 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3999 _HL("wdgt_bd_done"),
4000 GTK_RESPONSE_ACCEPT,
4002 gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
4003 HILDON_MARGIN_DOUBLE);
4006 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4009 _("mcen_bd_dialog_ok"),
4010 GTK_RESPONSE_ACCEPT,
4011 _("mcen_bd_dialog_cancel"),
4012 GTK_RESPONSE_REJECT,
4014 #endif /* MODEST_TOOLKIT_HILDON2 */
4017 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4021 GTK_RESPONSE_REJECT,
4023 GTK_RESPONSE_ACCEPT,
4025 #endif /* MODEST_TOOLKIT_GTK */
4027 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog), NULL);
4029 gchar *server_name = modest_account_mgr_get_server_account_hostname (
4030 modest_runtime_get_account_mgr(), server_account_name);
4031 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
4032 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
4035 gtk_widget_destroy (dialog);
4039 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
4040 GtkWidget *label = gtk_label_new (txt);
4041 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4043 g_free (server_name);
4044 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
4049 gchar *initial_username = modest_account_mgr_get_server_account_username (
4050 modest_runtime_get_account_mgr(), server_account_name);
4052 #ifdef MODEST_TOOLKIT_HILDON2
4053 GtkWidget *entry_username = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4054 if (initial_username)
4055 hildon_entry_set_text (HILDON_ENTRY (entry_username), initial_username);
4057 GtkWidget *entry_username = gtk_entry_new ();
4058 if (initial_username)
4059 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
4061 /* Dim this if a connection has ever succeeded with this username,
4062 * as per the UI spec: */
4063 /* const gboolean username_known = */
4064 /* modest_account_mgr_get_server_account_username_has_succeeded( */
4065 /* modest_runtime_get_account_mgr(), server_account_name); */
4066 /* gtk_widget_set_sensitive (entry_username, !username_known); */
4068 /* We drop the username sensitive code and disallow changing it here
4069 * as tinymail does not support really changing the username in the callback
4071 gtk_widget_set_sensitive (entry_username, FALSE);
4073 #ifndef MODEST_TOOLKIT_GTK
4074 /* Auto-capitalization is the default, so let's turn it off: */
4075 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
4077 /* Create a size group to be used by all captions.
4078 * Note that HildonCaption does not create a default size group if we do not specify one.
4079 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
4080 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
4082 #ifdef MODEST_TOOLKIT_HILDON2
4083 GtkWidget *caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4084 _("mail_fi_username"), FALSE,
4087 GtkWidget *caption = hildon_caption_new (sizegroup,
4088 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
4090 gtk_widget_show (entry_username);
4091 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4092 FALSE, FALSE, MODEST_MARGIN_HALF);
4093 gtk_widget_show (caption);
4095 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
4097 #endif /* !MODEST_TOOLKIT_GTK */
4100 #ifdef MODEST_TOOLKIT_HILDON2
4101 GtkWidget *entry_password = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4103 GtkWidget *entry_password = gtk_entry_new ();
4105 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
4106 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
4108 #ifndef MODEST_TOOLKIT_GTK
4109 /* Auto-capitalization is the default, so let's turn it off: */
4110 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
4111 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
4113 #ifdef MODEST_TOOLKIT_HILDON2
4114 caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4115 _("mail_fi_password"), FALSE,
4118 caption = hildon_caption_new (sizegroup,
4119 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
4121 gtk_widget_show (entry_password);
4122 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4123 FALSE, FALSE, MODEST_MARGIN_HALF);
4124 gtk_widget_show (caption);
4125 g_object_unref (sizegroup);
4127 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
4129 #endif /* !MODEST_TOOLKIT_GTK */
4131 if (initial_username != NULL)
4132 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
4134 /* This is not in the Maemo UI spec:
4135 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
4136 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
4140 fields = g_slice_new0 (PasswordDialogFields);
4141 fields->username = entry_username;
4142 fields->password = entry_password;
4143 fields->dialog = dialog;
4145 g_signal_connect (entry_username, "changed", G_CALLBACK (password_dialog_check_field), fields);
4146 g_signal_connect (entry_password, "changed", G_CALLBACK (password_dialog_check_field), fields);
4147 password_dialog_check_field (NULL, fields);
4149 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
4151 while (!completed) {
4153 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
4155 #ifdef MODEST_TOOLKIT_HILDON2
4156 *username = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_username)));
4158 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
4161 /* Note that an empty field becomes the "" string */
4162 if (*username && strlen (*username) > 0) {
4163 modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
4164 server_account_name,
4168 const gboolean username_was_changed =
4169 (strcmp (*username, initial_username) != 0);
4170 if (username_was_changed) {
4171 g_warning ("%s: tinymail does not yet support changing the "
4172 "username in the get_password() callback.\n", __FUNCTION__);
4178 modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
4179 _("mcen_ib_username_pw_incorrect"));
4185 #ifdef MODEST_TOOLKIT_HILDON2
4186 *password = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_password)));
4188 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
4191 /* We do not save the password in the configuration,
4192 * because this function is only called for passwords that should
4193 * not be remembered:
4194 modest_server_account_set_password (
4195 modest_runtime_get_account_mgr(), server_account_name,
4202 #ifndef MODEST_TOOLKIT_HILDON2
4203 /* Set parent to NULL or the banner will disappear with its parent dialog */
4204 modest_platform_information_banner(NULL, NULL, _("mail_ib_login_cancelled"));
4216 /* This is not in the Maemo UI spec:
4217 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
4223 g_free (initial_username);
4224 gtk_widget_destroy (dialog);
4225 g_slice_free (PasswordDialogFields, fields);
4227 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
4231 modest_ui_actions_on_cut (GtkAction *action,
4232 ModestWindow *window)
4234 GtkWidget *focused_widget;
4235 GtkClipboard *clipboard;
4237 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4238 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4239 if (GTK_IS_EDITABLE (focused_widget)) {
4240 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
4241 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4242 gtk_clipboard_store (clipboard);
4243 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4244 GtkTextBuffer *buffer;
4246 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4247 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4248 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
4249 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4250 gtk_clipboard_store (clipboard);
4252 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4253 TnyList *header_list = modest_header_view_get_selected_headers (
4254 MODEST_HEADER_VIEW (focused_widget));
4255 gboolean continue_download = FALSE;
4256 gint num_of_unc_msgs;
4258 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4260 if (num_of_unc_msgs) {
4261 TnyAccount *account = get_account_from_header_list (header_list);
4263 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4264 g_object_unref (account);
4268 if (num_of_unc_msgs == 0 || continue_download) {
4269 /* modest_platform_information_banner (
4270 NULL, NULL, _CS("mcen_ib_getting_items"));*/
4271 modest_header_view_cut_selection (
4272 MODEST_HEADER_VIEW (focused_widget));
4275 g_object_unref (header_list);
4276 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4277 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
4282 modest_ui_actions_on_copy (GtkAction *action,
4283 ModestWindow *window)
4285 GtkClipboard *clipboard;
4286 GtkWidget *focused_widget;
4287 gboolean copied = TRUE;
4289 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4290 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4292 if (GTK_IS_LABEL (focused_widget)) {
4294 selection = modest_text_utils_label_get_selection (GTK_LABEL (focused_widget));
4295 gtk_clipboard_set_text (clipboard, selection, -1);
4297 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4298 gtk_clipboard_store (clipboard);
4299 } else if (GTK_IS_EDITABLE (focused_widget)) {
4300 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
4301 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4302 gtk_clipboard_store (clipboard);
4303 } else if (GTK_IS_HTML (focused_widget)) {
4306 sel = gtk_html_get_selection_html (GTK_HTML (focused_widget), &len);
4307 if ((sel == NULL) || (sel[0] == '\0')) {
4310 gtk_html_copy (GTK_HTML (focused_widget));
4311 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4312 gtk_clipboard_store (clipboard);
4314 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4315 GtkTextBuffer *buffer;
4316 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4317 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4318 gtk_text_buffer_copy_clipboard (buffer, clipboard);
4319 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4320 gtk_clipboard_store (clipboard);
4322 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4323 TnyList *header_list = modest_header_view_get_selected_headers (
4324 MODEST_HEADER_VIEW (focused_widget));
4325 gboolean continue_download = FALSE;
4326 gint num_of_unc_msgs;
4328 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4330 if (num_of_unc_msgs) {
4331 TnyAccount *account = get_account_from_header_list (header_list);
4333 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4334 g_object_unref (account);
4338 if (num_of_unc_msgs == 0 || continue_download) {
4339 modest_platform_information_banner (
4340 NULL, NULL, _CS("mcen_ib_getting_items"));
4341 modest_header_view_copy_selection (
4342 MODEST_HEADER_VIEW (focused_widget));
4346 g_object_unref (header_list);
4348 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4349 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
4352 /* Show information banner if there was a copy to clipboard */
4354 modest_platform_information_banner (
4355 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
4359 modest_ui_actions_on_undo (GtkAction *action,
4360 ModestWindow *window)
4362 ModestEmailClipboard *clipboard = NULL;
4364 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4365 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
4366 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4367 /* Clear clipboard source */
4368 clipboard = modest_runtime_get_email_clipboard ();
4369 modest_email_clipboard_clear (clipboard);
4372 g_return_if_reached ();
4377 modest_ui_actions_on_redo (GtkAction *action,
4378 ModestWindow *window)
4380 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4381 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
4384 g_return_if_reached ();
4390 destroy_information_note (ModestMailOperation *mail_op,
4393 /* destroy information note */
4394 gtk_widget_destroy (GTK_WIDGET(user_data));
4398 destroy_folder_information_note (ModestMailOperation *mail_op,
4399 TnyFolder *new_folder,
4402 /* destroy information note */
4403 gtk_widget_destroy (GTK_WIDGET(user_data));
4408 paste_as_attachment_free (gpointer data)
4410 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
4412 if (helper->banner) {
4413 gtk_widget_destroy (helper->banner);
4414 g_object_unref (helper->banner);
4420 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
4425 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
4426 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
4431 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
4436 modest_ui_actions_on_paste (GtkAction *action,
4437 ModestWindow *window)
4439 GtkWidget *focused_widget = NULL;
4440 GtkWidget *inf_note = NULL;
4441 ModestMailOperation *mail_op = NULL;
4443 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4444 if (GTK_IS_EDITABLE (focused_widget)) {
4445 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
4446 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4447 ModestEmailClipboard *e_clipboard = NULL;
4448 e_clipboard = modest_runtime_get_email_clipboard ();
4449 if (modest_email_clipboard_cleared (e_clipboard)) {
4450 GtkTextBuffer *buffer;
4451 GtkClipboard *clipboard;
4453 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4454 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4455 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
4456 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4457 ModestMailOperation *mail_op;
4458 TnyFolder *src_folder = NULL;
4459 TnyList *data = NULL;
4461 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
4462 helper->window = MODEST_MSG_EDIT_WINDOW (window);
4463 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4464 _CS("ckct_nw_pasting"));
4465 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
4466 mail_op = modest_mail_operation_new (G_OBJECT (window));
4467 if (helper->banner != NULL) {
4468 g_object_ref (G_OBJECT (helper->banner));
4469 gtk_widget_show (GTK_WIDGET (helper->banner));
4473 modest_mail_operation_get_msgs_full (mail_op,
4475 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
4477 paste_as_attachment_free);
4481 g_object_unref (data);
4483 g_object_unref (src_folder);
4486 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4487 ModestEmailClipboard *clipboard = NULL;
4488 TnyFolder *src_folder = NULL;
4489 TnyFolderStore *folder_store = NULL;
4490 TnyList *data = NULL;
4491 gboolean delete = FALSE;
4493 /* Check clipboard source */
4494 clipboard = modest_runtime_get_email_clipboard ();
4495 if (modest_email_clipboard_cleared (clipboard))
4498 /* Get elements to paste */
4499 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
4501 /* Create a new mail operation */
4502 mail_op = modest_mail_operation_new (G_OBJECT(window));
4504 /* Get destination folder */
4505 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
4507 /* transfer messages */
4511 /* Ask for user confirmation */
4513 modest_ui_actions_msgs_move_to_confirmation (window,
4514 TNY_FOLDER (folder_store),
4518 if (response == GTK_RESPONSE_OK) {
4519 /* Launch notification */
4520 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4521 _CS("ckct_nw_pasting"));
4522 if (inf_note != NULL) {
4523 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4524 gtk_widget_show (GTK_WIDGET(inf_note));
4527 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4528 modest_mail_operation_xfer_msgs (mail_op,
4530 TNY_FOLDER (folder_store),
4532 destroy_information_note,
4535 g_object_unref (mail_op);
4538 } else if (src_folder != NULL) {
4539 /* Launch notification */
4540 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4541 _CS("ckct_nw_pasting"));
4542 if (inf_note != NULL) {
4543 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4544 gtk_widget_show (GTK_WIDGET(inf_note));
4547 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4548 modest_mail_operation_xfer_folder (mail_op,
4552 destroy_folder_information_note,
4558 g_object_unref (data);
4559 if (src_folder != NULL)
4560 g_object_unref (src_folder);
4561 if (folder_store != NULL)
4562 g_object_unref (folder_store);
4568 modest_ui_actions_on_select_all (GtkAction *action,
4569 ModestWindow *window)
4571 GtkWidget *focused_widget;
4573 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4574 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
4575 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
4576 } else if (GTK_IS_LABEL (focused_widget)) {
4577 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
4578 } else if (GTK_IS_EDITABLE (focused_widget)) {
4579 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
4580 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4581 GtkTextBuffer *buffer;
4582 GtkTextIter start, end;
4584 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4585 gtk_text_buffer_get_start_iter (buffer, &start);
4586 gtk_text_buffer_get_end_iter (buffer, &end);
4587 gtk_text_buffer_select_range (buffer, &start, &end);
4588 } else if (GTK_IS_HTML (focused_widget)) {
4589 gtk_html_select_all (GTK_HTML (focused_widget));
4590 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4591 GtkWidget *header_view = focused_widget;
4592 GtkTreeSelection *selection = NULL;
4594 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
4595 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
4596 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4599 /* Disable window dimming management */
4600 modest_window_disable_dimming (MODEST_WINDOW(window));
4602 /* Select all messages */
4603 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
4604 gtk_tree_selection_select_all (selection);
4606 /* Set focuse on header view */
4607 gtk_widget_grab_focus (header_view);
4609 /* Enable window dimming management */
4610 modest_window_enable_dimming (MODEST_WINDOW(window));
4611 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
4612 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
4618 modest_ui_actions_on_mark_as_read (GtkAction *action,
4619 ModestWindow *window)
4621 g_return_if_fail (MODEST_IS_WINDOW(window));
4623 /* Mark each header as read */
4624 do_headers_action (window, headers_action_mark_as_read, NULL);
4628 modest_ui_actions_on_mark_as_unread (GtkAction *action,
4629 ModestWindow *window)
4631 g_return_if_fail (MODEST_IS_WINDOW(window));
4633 /* Mark each header as read */
4634 do_headers_action (window, headers_action_mark_as_unread, NULL);
4638 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
4639 GtkRadioAction *selected,
4640 ModestWindow *window)
4644 value = gtk_radio_action_get_current_value (selected);
4645 if (MODEST_IS_WINDOW (window)) {
4646 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
4651 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
4652 GtkRadioAction *selected,
4653 ModestWindow *window)
4655 TnyHeaderFlags flags;
4656 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4658 flags = gtk_radio_action_get_current_value (selected);
4659 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
4663 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
4664 GtkRadioAction *selected,
4665 ModestWindow *window)
4669 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4671 file_format = gtk_radio_action_get_current_value (selected);
4672 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
4677 modest_ui_actions_on_zoom_plus (GtkAction *action,
4678 ModestWindow *window)
4680 g_return_if_fail (MODEST_IS_WINDOW (window));
4682 modest_window_zoom_plus (MODEST_WINDOW (window));
4686 modest_ui_actions_on_zoom_minus (GtkAction *action,
4687 ModestWindow *window)
4689 g_return_if_fail (MODEST_IS_WINDOW (window));
4691 modest_window_zoom_minus (MODEST_WINDOW (window));
4695 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
4696 ModestWindow *window)
4698 ModestWindowMgr *mgr;
4699 gboolean fullscreen, active;
4700 g_return_if_fail (MODEST_IS_WINDOW (window));
4702 mgr = modest_runtime_get_window_mgr ();
4704 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
4705 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4707 if (active != fullscreen) {
4708 modest_window_mgr_set_fullscreen_mode (mgr, active);
4709 #ifndef MODEST_TOOLKIT_HILDON2
4710 gtk_window_present (GTK_WINDOW (window));
4716 modest_ui_actions_on_change_fullscreen (GtkAction *action,
4717 ModestWindow *window)
4719 ModestWindowMgr *mgr;
4720 gboolean fullscreen;
4722 g_return_if_fail (MODEST_IS_WINDOW (window));
4724 mgr = modest_runtime_get_window_mgr ();
4725 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4726 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
4728 #ifndef MODEST_TOOLKIT_HILDON2
4729 gtk_window_present (GTK_WINDOW (window));
4734 * Used by modest_ui_actions_on_details to call do_headers_action
4737 headers_action_show_details (TnyHeader *header,
4738 ModestWindow *window,
4742 gboolean async_retrieval;
4745 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4746 async_retrieval = TRUE;
4747 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (window));
4749 async_retrieval = FALSE;
4751 modest_platform_run_header_details_dialog (GTK_WINDOW (window), header, async_retrieval, msg);
4753 g_object_unref (msg);
4757 * Show the header details in a ModestDetailsDialog widget
4760 modest_ui_actions_on_details (GtkAction *action,
4763 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4767 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
4771 header = tny_msg_get_header (msg);
4773 headers_action_show_details (header, win, NULL);
4774 g_object_unref (header);
4776 g_object_unref (msg);
4778 } else if (MODEST_IS_MAIN_WINDOW (win)) {
4779 GtkWidget *folder_view, *header_view;
4781 /* Check which widget has the focus */
4782 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4783 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4784 if (gtk_widget_is_focus (folder_view)) {
4785 TnyFolderStore *folder_store
4786 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4787 if (!folder_store) {
4788 g_warning ("%s: No item was selected.\n", __FUNCTION__);
4791 /* Show only when it's a folder */
4792 /* This function should not be called for account items,
4793 * because we dim the menu item for them. */
4794 if (TNY_IS_FOLDER (folder_store)) {
4795 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4796 TNY_FOLDER (folder_store));
4799 g_object_unref (folder_store);
4802 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4803 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4804 /* Show details of each header */
4805 do_headers_action (win, headers_action_show_details, header_view);
4807 #ifdef MODEST_TOOLKIT_HILDON2
4808 } else if (MODEST_IS_HEADER_WINDOW (win)) {
4810 GtkWidget *header_view;
4812 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
4813 folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
4815 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4817 g_object_unref (folder);
4824 modest_ui_actions_on_limit_error (GtkAction *action,
4827 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
4829 modest_platform_information_banner ((GtkWidget *) win, NULL, _CS("ckdg_ib_maximum_characters_reached"));
4834 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
4835 ModestMsgEditWindow *window)
4837 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4839 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
4843 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
4844 ModestMsgEditWindow *window)
4846 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4848 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
4852 modest_ui_actions_toggle_folders_view (GtkAction *action,
4853 ModestMainWindow *main_window)
4855 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
4857 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
4858 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
4860 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
4864 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
4865 ModestWindow *window)
4867 gboolean active, fullscreen = FALSE;
4868 ModestWindowMgr *mgr;
4870 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
4872 /* Check if we want to toggle the toolbar view in fullscreen
4874 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
4875 "ViewShowToolbarFullScreen")) {
4879 /* Toggle toolbar */
4880 mgr = modest_runtime_get_window_mgr ();
4881 modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
4885 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
4886 ModestMsgEditWindow *window)
4888 modest_msg_edit_window_select_font (window);
4893 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
4894 const gchar *display_name,
4897 /* don't update the display name if it was already set;
4898 * updating the display name apparently is expensive */
4899 const gchar* old_name = gtk_window_get_title (window);
4901 if (display_name == NULL)
4904 if (old_name && display_name && strcmp (old_name, display_name) == 0)
4905 return; /* don't do anything */
4907 /* This is usually used to change the title of the main window, which
4908 * is the one that holds the folder view. Note that this change can
4909 * happen even when the widget doesn't have the focus. */
4910 gtk_window_set_title (window, display_name);
4915 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
4917 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4918 modest_msg_edit_window_select_contacts (window);
4922 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
4924 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4925 modest_msg_edit_window_check_names (window, FALSE);
4928 #ifndef MODEST_TOOLKIT_HILDON2
4930 * This function is used to track changes in the selection of the
4931 * folder view that is inside the "move to" dialog to enable/disable
4932 * the OK button because we do not want the user to select a disallowed
4933 * destination for a folder.
4934 * The user also not desired to be able to use NEW button on items where
4935 * folder creation is not possibel.
4938 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
4939 TnyFolderStore *folder_store,
4943 GtkWidget *dialog = NULL;
4944 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
4945 gboolean moving_folder = FALSE;
4946 gboolean is_local_account = TRUE;
4947 GtkWidget *folder_view = NULL;
4948 ModestTnyFolderRules rules;
4950 g_return_if_fail (MODEST_IS_FOLDER_VIEW(self));
4955 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
4959 /* check if folder_store is an remote account */
4960 if (TNY_IS_ACCOUNT (folder_store)) {
4961 TnyAccount *local_account = NULL;
4962 TnyAccount *mmc_account = NULL;
4963 ModestTnyAccountStore *account_store = NULL;
4965 account_store = modest_runtime_get_account_store ();
4966 local_account = modest_tny_account_store_get_local_folders_account (account_store);
4967 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
4969 if ((gpointer) local_account != (gpointer) folder_store &&
4970 (gpointer) mmc_account != (gpointer) folder_store) {
4971 ModestProtocolType proto;
4972 proto = modest_tny_account_get_protocol_type (TNY_ACCOUNT (folder_store));
4973 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
4974 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
4976 is_local_account = FALSE;
4977 /* New button should be dimmed on remote
4979 new_sensitive = (modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
4981 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS));
4983 g_object_unref (local_account);
4985 /* It could not exist */
4987 g_object_unref (mmc_account);
4990 /* Check the target folder rules */
4991 if (TNY_IS_FOLDER (folder_store)) {
4992 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
4993 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
4994 ok_sensitive = FALSE;
4995 new_sensitive = FALSE;
5000 /* Check if we're moving a folder */
5001 if (MODEST_IS_MAIN_WINDOW (user_data)) {
5002 /* Get the widgets */
5003 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
5004 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5005 if (gtk_widget_is_focus (folder_view))
5006 moving_folder = TRUE;
5009 if (moving_folder) {
5010 TnyFolderStore *moved_folder = NULL, *parent = NULL;
5012 /* Get the folder to move */
5013 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5015 /* Check that we're not moving to the same folder */
5016 if (TNY_IS_FOLDER (moved_folder)) {
5017 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
5018 if (parent == folder_store)
5019 ok_sensitive = FALSE;
5020 g_object_unref (parent);
5023 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
5024 /* Do not allow to move to an account unless it's the
5025 local folders account */
5026 if (!is_local_account)
5027 ok_sensitive = FALSE;
5030 if (ok_sensitive && (moved_folder == folder_store)) {
5031 /* Do not allow to move to itself */
5032 ok_sensitive = FALSE;
5034 g_object_unref (moved_folder);
5036 TnyFolder *src_folder = NULL;
5038 /* Moving a message */
5039 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
5041 TnyHeader *header = NULL;
5042 header = modest_msg_view_window_get_header
5043 (MODEST_MSG_VIEW_WINDOW (user_data));
5044 if (!TNY_IS_HEADER(header))
5045 g_warning ("%s: could not get source header", __FUNCTION__);
5047 src_folder = tny_header_get_folder (header);
5050 g_object_unref (header);
5053 TNY_FOLDER (modest_folder_view_get_selected
5054 (MODEST_FOLDER_VIEW (folder_view)));
5057 if (TNY_IS_FOLDER(src_folder)) {
5058 /* Do not allow to move the msg to the same folder */
5059 /* Do not allow to move the msg to an account */
5060 if ((gpointer) src_folder == (gpointer) folder_store ||
5061 TNY_IS_ACCOUNT (folder_store))
5062 ok_sensitive = FALSE;
5063 g_object_unref (src_folder);
5065 g_warning ("%s: could not get source folder", __FUNCTION__);
5069 /* Set sensitivity of the OK and NEW button */
5070 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, ok_sensitive);
5071 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_GTK_RESPONSE_NEW_FOLDER, new_sensitive);
5076 on_move_to_dialog_response (GtkDialog *dialog,
5080 GtkWidget *parent_win;
5081 MoveToInfo *helper = NULL;
5082 ModestFolderView *folder_view;
5083 gboolean unset_edit_mode = FALSE;
5085 helper = (MoveToInfo *) user_data;
5087 parent_win = (GtkWidget *) helper->win;
5088 folder_view = MODEST_FOLDER_VIEW (g_object_get_data (G_OBJECT (dialog),
5089 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
5092 TnyFolderStore *dst_folder;
5093 TnyFolderStore *selected;
5095 case MODEST_GTK_RESPONSE_NEW_FOLDER:
5096 selected = modest_folder_view_get_selected (folder_view);
5097 modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view), selected);
5098 g_object_unref (selected);
5100 case GTK_RESPONSE_NONE:
5101 case GTK_RESPONSE_CANCEL:
5102 case GTK_RESPONSE_DELETE_EVENT:
5104 case GTK_RESPONSE_OK:
5105 dst_folder = modest_folder_view_get_selected (folder_view);
5107 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
5108 /* Clean list to move used for filtering */
5109 modest_folder_view_set_list_to_move (folder_view, NULL);
5111 modest_ui_actions_on_main_window_move_to (NULL,
5112 GTK_WIDGET (folder_view),
5114 MODEST_MAIN_WINDOW (parent_win));
5115 #ifdef MODEST_TOOLKIT_HILDON2
5116 } else if (MODEST_IS_FOLDER_WINDOW (parent_win)) {
5117 /* Clean list to move used for filtering */
5118 modest_folder_view_set_list_to_move (folder_view, NULL);
5120 modest_ui_actions_on_folder_window_move_to (GTK_WIDGET (folder_view),
5123 GTK_WINDOW (parent_win));
5126 /* if the user selected a root folder
5127 (account) then do not perform any action */
5128 if (TNY_IS_ACCOUNT (dst_folder)) {
5129 g_signal_stop_emission_by_name (dialog, "response");
5133 /* Clean list to move used for filtering */
5134 modest_folder_view_set_list_to_move (folder_view, NULL);
5136 /* Moving from headers window in edit mode */
5137 modest_ui_actions_on_window_move_to (NULL, helper->list,
5139 MODEST_WINDOW (parent_win));
5143 g_object_unref (dst_folder);
5145 unset_edit_mode = TRUE;
5148 g_warning ("%s unexpected response id %d", __FUNCTION__, response);
5151 /* Free the helper and exit */
5153 g_object_unref (helper->list);
5154 if (unset_edit_mode) {
5155 #ifdef MODEST_TOOLKIT_HILDON2
5156 modest_hildon2_window_unset_edit_mode (MODEST_HILDON2_WINDOW (helper->win));
5159 g_slice_free (MoveToInfo, helper);
5160 gtk_widget_destroy (GTK_WIDGET (dialog));
5164 create_move_to_dialog (GtkWindow *win,
5165 GtkWidget *folder_view,
5166 TnyList *list_to_move)
5168 GtkWidget *dialog, *tree_view = NULL;
5170 dialog = modest_platform_create_move_to_dialog (win, &tree_view);
5172 #ifndef MODEST_TOOLKIT_HILDON2
5173 /* Track changes in the selection to
5174 * disable the OK button whenever "Move to" is not possible
5175 * disbale NEW button whenever New is not possible */
5176 g_signal_connect (tree_view,
5177 "folder_selection_changed",
5178 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
5182 /* It could happen that we're trying to move a message from a
5183 window (msg window for example) after the main window was
5184 closed, so we can not just get the model of the folder
5186 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
5187 const gchar *visible_id = NULL;
5189 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5190 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5191 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
5192 MODEST_FOLDER_VIEW(tree_view));
5195 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
5197 /* Show the same account than the one that is shown in the main window */
5198 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(tree_view),
5201 const gchar *active_account_name = NULL;
5202 ModestAccountMgr *mgr = NULL;
5203 ModestAccountSettings *settings = NULL;
5204 ModestServerAccountSettings *store_settings = NULL;
5206 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5207 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5208 modest_folder_view_update_model (MODEST_FOLDER_VIEW (tree_view),
5209 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
5211 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
5212 mgr = modest_runtime_get_account_mgr ();
5213 settings = modest_account_mgr_load_account_settings (mgr, active_account_name);
5216 const gchar *store_account_name;
5217 store_settings = modest_account_settings_get_store_settings (settings);
5218 store_account_name = modest_server_account_settings_get_account_name (store_settings);
5220 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (tree_view),
5221 store_account_name);
5222 g_object_unref (store_settings);
5223 g_object_unref (settings);
5227 /* we keep a pointer to the embedded folder view, so we can
5228 * retrieve it with get_folder_view_from_move_to_dialog (see
5229 * above) later (needed for focus handling)
5231 g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, tree_view);
5233 /* Hide special folders */
5234 #ifndef MODEST_TOOLKIT_HILDON2
5235 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
5238 modest_folder_view_set_list_to_move (MODEST_FOLDER_VIEW (tree_view), list_to_move);
5239 #ifndef MODEST_TOOLKIT_HILDON2
5240 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
5243 gtk_widget_show (GTK_WIDGET (tree_view));
5249 * Shows a confirmation dialog to the user when we're moving messages
5250 * from a remote server to the local storage. Returns the dialog
5251 * response. If it's other kind of movement then it always returns
5254 * This one is used by the next functions:
5255 * modest_ui_actions_on_paste - commented out
5256 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
5259 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
5260 TnyFolder *dest_folder,
5264 gint response = GTK_RESPONSE_OK;
5265 TnyAccount *account = NULL;
5266 TnyFolder *src_folder = NULL;
5267 TnyIterator *iter = NULL;
5268 TnyHeader *header = NULL;
5270 /* return with OK if the destination is a remote folder */
5271 if (modest_tny_folder_is_remote_folder (dest_folder))
5272 return GTK_RESPONSE_OK;
5274 /* Get source folder */
5275 iter = tny_list_create_iterator (headers);
5276 header = TNY_HEADER (tny_iterator_get_current (iter));
5278 src_folder = tny_header_get_folder (header);
5279 g_object_unref (header);
5281 g_object_unref (iter);
5283 /* if no src_folder, message may be an attahcment */
5284 if (src_folder == NULL)
5285 return GTK_RESPONSE_CANCEL;
5287 /* If the source is a local or MMC folder */
5288 if (!modest_tny_folder_is_remote_folder (src_folder)) {
5289 g_object_unref (src_folder);
5290 return GTK_RESPONSE_OK;
5293 /* Get the account */
5294 account = tny_folder_get_account (src_folder);
5296 /* now if offline we ask the user */
5297 if(connect_to_get_msg (win, tny_list_get_length (headers), account))
5298 response = GTK_RESPONSE_OK;
5300 response = GTK_RESPONSE_CANCEL;
5303 g_object_unref (src_folder);
5304 g_object_unref (account);
5310 move_to_helper_destroyer (gpointer user_data)
5312 MoveToHelper *helper = (MoveToHelper *) user_data;
5314 /* Close the "Pasting" information banner */
5315 if (helper->banner) {
5316 gtk_widget_destroy (GTK_WIDGET (helper->banner));
5317 g_object_unref (helper->banner);
5319 if (gtk_tree_row_reference_valid (helper->reference)) {
5320 gtk_tree_row_reference_free (helper->reference);
5321 helper->reference = NULL;
5327 move_to_cb (ModestMailOperation *mail_op,
5330 MoveToHelper *helper = (MoveToHelper *) user_data;
5331 GObject *object = modest_mail_operation_get_source (mail_op);
5333 /* Note that the operation could have failed, in that case do
5335 if (modest_mail_operation_get_status (mail_op) !=
5336 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
5339 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
5340 ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
5342 if (!modest_msg_view_window_select_next_message (self) &&
5343 !modest_msg_view_window_select_previous_message (self)) {
5344 /* No more messages to view, so close this window */
5345 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
5347 } else if (MODEST_IS_MAIN_WINDOW (object) &&
5348 gtk_tree_row_reference_valid (helper->reference)) {
5349 GtkWidget *header_view;
5351 GtkTreeSelection *sel;
5353 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5354 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5355 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
5356 path = gtk_tree_row_reference_get_path (helper->reference);
5357 /* We need to unselect the previous one
5358 because we could be copying instead of
5360 gtk_tree_selection_unselect_all (sel);
5361 gtk_tree_selection_select_path (sel, path);
5362 gtk_tree_path_free (path);
5364 g_object_unref (object);
5367 /* Destroy the helper */
5368 move_to_helper_destroyer (helper);
5372 folder_move_to_cb (ModestMailOperation *mail_op,
5373 TnyFolder *new_folder,
5376 GtkWidget *folder_view;
5379 object = modest_mail_operation_get_source (mail_op);
5380 if (MODEST_IS_MAIN_WINDOW (object)) {
5381 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5382 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5383 g_object_ref (folder_view);
5384 g_object_unref (object);
5385 move_to_cb (mail_op, user_data);
5386 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), new_folder, FALSE);
5387 g_object_unref (folder_view);
5389 move_to_cb (mail_op, user_data);
5394 msgs_move_to_cb (ModestMailOperation *mail_op,
5397 move_to_cb (mail_op, user_data);
5401 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
5404 GObject *win = NULL;
5405 const GError *error;
5406 TnyAccount *account = NULL;
5408 #ifndef MODEST_TOOLKIT_HILDON2
5409 ModestWindow *main_window = NULL;
5411 /* Disable next automatic folder selection */
5412 main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
5413 FALSE); /* don't create */
5415 /* Show notification dialog only if the main window exists */
5417 GtkWidget *folder_view = NULL;
5419 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
5420 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5421 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
5423 if (user_data && TNY_IS_FOLDER (user_data)) {
5424 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
5425 TNY_FOLDER (user_data), FALSE);
5429 win = modest_mail_operation_get_source (mail_op);
5430 error = modest_mail_operation_get_error (mail_op);
5432 if (TNY_IS_FOLDER (user_data))
5433 account = modest_tny_folder_get_account (TNY_FOLDER (user_data));
5434 else if (TNY_IS_ACCOUNT (user_data))
5435 account = g_object_ref (user_data);
5437 /* If it's not a disk full error then show a generic error */
5438 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5439 (GtkWidget *) win, (GError *) error,
5441 modest_platform_run_information_dialog ((GtkWindow *) win,
5442 _("mail_in_ui_folder_move_target_error"),
5445 g_object_unref (account);
5447 g_object_unref (win);
5451 open_msg_for_purge_cb (ModestMailOperation *mail_op,
5460 gint pending_purges = 0;
5461 gboolean some_purged = FALSE;
5462 ModestWindow *win = MODEST_WINDOW (user_data);
5463 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
5465 /* If there was any error */
5466 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
5467 modest_window_mgr_unregister_header (mgr, header);
5471 /* Once the message has been retrieved for purging, we check if
5472 * it's all ok for purging */
5474 parts = tny_simple_list_new ();
5475 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
5476 iter = tny_list_create_iterator (parts);
5478 while (!tny_iterator_is_done (iter)) {
5480 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5481 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
5482 if (tny_mime_part_is_purged (part))
5489 g_object_unref (part);
5491 tny_iterator_next (iter);
5493 g_object_unref (iter);
5496 if (pending_purges>0) {
5498 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
5500 if (response == GTK_RESPONSE_OK) {
5503 modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_me_inbox_remove_attachments"));
5504 iter = tny_list_create_iterator (parts);
5505 while (!tny_iterator_is_done (iter)) {
5508 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5509 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
5510 tny_mime_part_set_purged (part);
5513 g_object_unref (part);
5515 tny_iterator_next (iter);
5517 g_object_unref (iter);
5519 tny_msg_rewrite_cache (msg);
5521 gtk_widget_destroy (info);
5525 modest_window_mgr_unregister_header (mgr, header);
5527 g_object_unref (parts);
5531 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
5532 ModestMainWindow *win)
5534 GtkWidget *header_view;
5535 TnyList *header_list;
5537 TnyHeaderFlags flags;
5538 ModestWindow *msg_view_window = NULL;
5541 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5543 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
5544 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5546 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
5548 g_warning ("%s: no header selected", __FUNCTION__);
5552 if (tny_list_get_length (header_list) == 1) {
5553 TnyIterator *iter = tny_list_create_iterator (header_list);
5554 header = TNY_HEADER (tny_iterator_get_current (iter));
5555 g_object_unref (iter);
5559 if (!header || !TNY_IS_HEADER(header)) {
5560 g_warning ("%s: header is not valid", __FUNCTION__);
5564 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
5565 header, &msg_view_window);
5566 flags = tny_header_get_flags (header);
5567 if (!(flags & TNY_HEADER_FLAG_CACHED))
5570 if (msg_view_window != NULL)
5571 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
5573 /* do nothing; uid was registered before, so window is probably on it's way */
5574 g_debug ("header %p has already been registered", header);
5577 ModestMailOperation *mail_op = NULL;
5578 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
5579 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
5580 modest_ui_actions_disk_operations_error_handler,
5582 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
5583 modest_mail_operation_get_msg (mail_op, header, FALSE, open_msg_for_purge_cb, win);
5585 g_object_unref (mail_op);
5588 g_object_unref (header);
5590 g_object_unref (header_list);
5594 * Checks if we need a connection to do the transfer and if the user
5595 * wants to connect to complete it
5598 modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
5599 TnyFolderStore *src_folder,
5601 TnyFolder *dst_folder,
5602 gboolean delete_originals,
5603 gboolean *need_connection,
5606 TnyAccount *src_account;
5607 gint uncached_msgs = 0;
5609 /* We don't need any further check if
5611 * 1- the source folder is local OR
5612 * 2- the device is already online
5614 if (!modest_tny_folder_store_is_remote (src_folder) ||
5615 tny_device_is_online (modest_runtime_get_device())) {
5616 *need_connection = FALSE;
5621 /* We must ask for a connection when
5623 * - the message(s) is not already cached OR
5624 * - the message(s) is cached but the leave_on_server setting
5625 * is FALSE (because we need to sync the source folder to
5626 * delete the message from the server (for IMAP we could do it
5627 * offline, it'll take place the next time we get a
5630 uncached_msgs = header_list_count_uncached_msgs (headers);
5631 src_account = get_account_from_folder_store (src_folder);
5632 if (uncached_msgs > 0) {
5636 *need_connection = TRUE;
5637 num_headers = tny_list_get_length (headers);
5638 msg = ngettext ("mcen_nc_get_msg", "mcen_nc_get_msgs", num_headers);
5640 if (modest_platform_run_confirmation_dialog (parent_window, msg) ==
5641 GTK_RESPONSE_CANCEL) {
5647 /* The transfer is possible and the user wants to */
5650 if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
5651 const gchar *account_name;
5652 gboolean leave_on_server;
5654 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
5655 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
5658 if (leave_on_server == TRUE) {
5659 *need_connection = FALSE;
5661 *need_connection = TRUE;
5664 *need_connection = FALSE;
5669 g_object_unref (src_account);
5673 xfer_messages_error_handler (ModestMailOperation *mail_op,
5677 const GError *error;
5678 TnyAccount *account;
5680 win = modest_mail_operation_get_source (mail_op);
5681 error = modest_mail_operation_get_error (mail_op);
5682 account = modest_mail_operation_get_account (mail_op);
5684 if (error && modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
5685 (GError *) error, account)) {
5686 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
5687 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
5690 modest_platform_run_information_dialog ((GtkWindow *) win,
5691 _("mail_in_ui_folder_move_target_error"),
5695 g_object_unref (account);
5697 g_object_unref (win);
5701 TnyFolderStore *dst_folder;
5706 * Utility function that transfer messages from both the main window
5707 * and the msg view window when using the "Move to" dialog
5710 xfer_messages_performer (gboolean canceled,
5712 GtkWindow *parent_window,
5713 TnyAccount *account,
5716 ModestWindow *win = MODEST_WINDOW (parent_window);
5717 TnyAccount *dst_account = NULL;
5718 gboolean dst_forbids_message_add = FALSE;
5719 XferMsgsHelper *helper;
5720 MoveToHelper *movehelper;
5721 ModestMailOperation *mail_op;
5723 helper = (XferMsgsHelper *) user_data;
5725 if (canceled || err) {
5726 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5727 (GtkWidget *) parent_window, err,
5729 /* Show the proper error message */
5730 modest_ui_actions_on_account_connection_error (parent_window, account);
5735 dst_account = tny_folder_get_account (TNY_FOLDER (helper->dst_folder));
5737 /* tinymail will return NULL for local folders it seems */
5738 dst_forbids_message_add = modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
5739 modest_tny_account_get_protocol_type (dst_account),
5740 MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
5741 g_object_unref (dst_account);
5743 if (dst_forbids_message_add) {
5744 modest_platform_information_banner (GTK_WIDGET (win),
5746 ngettext("mail_in_ui_folder_move_target_error",
5747 "mail_in_ui_folder_move_targets_error",
5748 tny_list_get_length (helper->headers)));
5752 movehelper = g_new0 (MoveToHelper, 1);
5754 #ifndef MODEST_TOOLKIT_HILDON2
5755 movehelper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
5756 _CS("ckct_nw_pasting"));
5757 if (movehelper->banner != NULL) {
5758 g_object_ref (movehelper->banner);
5759 gtk_widget_show (GTK_WIDGET (movehelper->banner));
5763 if (MODEST_IS_MAIN_WINDOW (win)) {
5764 GtkWidget *header_view =
5765 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
5766 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5767 movehelper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
5770 /* Perform the mail operation */
5771 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(win),
5772 xfer_messages_error_handler,
5774 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5777 modest_mail_operation_xfer_msgs (mail_op,
5779 TNY_FOLDER (helper->dst_folder),
5784 g_object_unref (G_OBJECT (mail_op));
5786 g_object_unref (helper->dst_folder);
5787 g_object_unref (helper->headers);
5788 g_slice_free (XferMsgsHelper, helper);
5792 TnyFolder *src_folder;
5793 TnyFolderStore *dst_folder;
5794 gboolean delete_original;
5795 GtkWidget *folder_view;
5799 on_move_folder_cb (gboolean canceled,
5801 GtkWindow *parent_window,
5802 TnyAccount *account,
5805 MoveFolderInfo *info = (MoveFolderInfo*)user_data;
5806 GtkTreeSelection *sel;
5807 ModestMailOperation *mail_op = NULL;
5809 if (canceled || err || !MODEST_IS_WINDOW (parent_window)) {
5810 /* Note that the connection process can fail due to
5811 memory low conditions as it can not successfully
5812 store the summary */
5813 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5814 (GtkWidget*) parent_window, err,
5816 g_debug ("Error connecting when trying to move a folder");
5818 g_object_unref (G_OBJECT (info->src_folder));
5819 g_object_unref (G_OBJECT (info->dst_folder));
5824 MoveToHelper *helper = g_new0 (MoveToHelper, 1);
5825 #ifndef MODEST_TOOLKIT_HILDON2
5826 helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
5827 _CS("ckct_nw_pasting"));
5828 if (helper->banner != NULL) {
5829 g_object_ref (helper->banner);
5830 gtk_widget_show (GTK_WIDGET(helper->banner));
5833 /* Clean folder on header view before moving it */
5834 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
5835 gtk_tree_selection_unselect_all (sel);
5837 /* Let gtk events run. We need that the folder
5838 view frees its reference to the source
5839 folder *before* issuing the mail operation
5840 so we need the signal handler of selection
5841 changed to happen before the mail
5843 while (gtk_events_pending ())
5844 gtk_main_iteration (); */
5847 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
5848 modest_ui_actions_move_folder_error_handler,
5849 g_object_ref (info->dst_folder), g_object_unref);
5850 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5853 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
5854 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
5855 TNY_FOLDER (info->dst_folder), TRUE);
5857 modest_mail_operation_xfer_folder (mail_op,
5858 TNY_FOLDER (info->src_folder),
5860 info->delete_original,
5863 g_object_unref (G_OBJECT (info->src_folder));
5865 /* if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) { */
5868 /* Unref mail operation */
5869 g_object_unref (G_OBJECT (mail_op));
5870 g_object_unref (G_OBJECT (info->dst_folder));
5875 get_account_from_folder_store (TnyFolderStore *folder_store)
5877 if (TNY_IS_ACCOUNT (folder_store))
5878 return g_object_ref (folder_store);
5880 return tny_folder_get_account (TNY_FOLDER (folder_store));
5884 * UI handler for the "Move to" action when invoked from the
5888 modest_ui_actions_on_main_window_move_to (GtkAction *action,
5889 GtkWidget *folder_view,
5890 TnyFolderStore *dst_folder,
5891 ModestMainWindow *win)
5893 ModestHeaderView *header_view = NULL;
5894 TnyFolderStore *src_folder = NULL;
5896 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5898 /* Get the source folder */
5899 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5901 /* Get header view */
5902 header_view = (ModestHeaderView *)
5903 modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5905 /* Get folder or messages to transfer */
5906 if (gtk_widget_is_focus (folder_view)) {
5907 gboolean do_xfer = TRUE;
5909 /* Allow only to transfer folders to the local root folder */
5910 if (TNY_IS_ACCOUNT (dst_folder) &&
5911 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5912 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5914 } else if (!TNY_IS_FOLDER (src_folder)) {
5915 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5920 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5921 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5923 info->src_folder = g_object_ref (src_folder);
5924 info->dst_folder = g_object_ref (dst_folder);
5925 info->delete_original = TRUE;
5926 info->folder_view = folder_view;
5928 connect_info->callback = on_move_folder_cb;
5929 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5930 connect_info->data = info;
5932 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5933 TNY_FOLDER_STORE (src_folder),
5936 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
5939 headers = modest_header_view_get_selected_headers(header_view);
5941 /* Transfer the messages */
5942 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
5943 headers, TNY_FOLDER (dst_folder));
5945 g_object_unref (headers);
5949 g_object_unref (src_folder);
5952 #ifdef MODEST_TOOLKIT_HILDON2
5954 * UI handler for the "Move to" action when invoked from the
5955 * ModestFolderWindow
5958 modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
5959 TnyFolderStore *dst_folder,
5963 TnyFolderStore *src_folder = NULL;
5964 TnyIterator *iterator;
5966 if (tny_list_get_length (selection) != 1)
5969 iterator = tny_list_create_iterator (selection);
5970 src_folder = TNY_FOLDER_STORE (tny_iterator_get_current (iterator));
5971 g_object_unref (iterator);
5974 gboolean do_xfer = TRUE;
5976 /* Allow only to transfer folders to the local root folder */
5977 if (TNY_IS_ACCOUNT (dst_folder) &&
5978 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5979 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5982 modest_platform_run_information_dialog (win,
5983 _("mail_in_ui_folder_move_target_error"),
5985 } else if (!TNY_IS_FOLDER (src_folder)) {
5986 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5991 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5992 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5994 info->src_folder = g_object_ref (src_folder);
5995 info->dst_folder = g_object_ref (dst_folder);
5996 info->delete_original = TRUE;
5997 info->folder_view = folder_view;
5999 connect_info->callback = on_move_folder_cb;
6000 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
6001 connect_info->data = info;
6003 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
6004 TNY_FOLDER_STORE (src_folder),
6009 g_object_unref (src_folder);
6015 modest_ui_actions_transfer_messages_helper (GtkWindow *win,
6016 TnyFolder *src_folder,
6018 TnyFolder *dst_folder)
6020 gboolean need_connection = TRUE;
6021 gboolean do_xfer = TRUE;
6022 XferMsgsHelper *helper;
6024 g_return_if_fail (TNY_IS_FOLDER (src_folder));
6025 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6026 g_return_if_fail (TNY_IS_LIST (headers));
6028 modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
6029 headers, TNY_FOLDER (dst_folder),
6030 TRUE, &need_connection,
6033 /* If we don't want to transfer just return */
6037 /* Create the helper */
6038 helper = g_slice_new (XferMsgsHelper);
6039 helper->dst_folder = g_object_ref (dst_folder);
6040 helper->headers = g_object_ref (headers);
6042 if (need_connection) {
6043 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
6044 connect_info->callback = xfer_messages_performer;
6045 connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
6046 connect_info->data = helper;
6048 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
6049 TNY_FOLDER_STORE (src_folder),
6052 TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
6053 xfer_messages_performer (FALSE, NULL, GTK_WINDOW (win),
6054 src_account, helper);
6055 g_object_unref (src_account);
6060 * UI handler for the "Move to" action when invoked from the
6061 * ModestMsgViewWindow
6064 modest_ui_actions_on_window_move_to (GtkAction *action,
6066 TnyFolderStore *dst_folder,
6069 TnyFolder *src_folder = NULL;
6071 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6074 TnyHeader *header = NULL;
6077 iter = tny_list_create_iterator (headers);
6078 header = (TnyHeader *) tny_iterator_get_current (iter);
6079 src_folder = tny_header_get_folder (header);
6081 /* Transfer the messages */
6082 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
6084 TNY_FOLDER (dst_folder));
6087 g_object_unref (header);
6088 g_object_unref (iter);
6089 g_object_unref (src_folder);
6094 modest_ui_actions_on_move_to (GtkAction *action,
6097 modest_ui_actions_on_edit_mode_move_to (win);
6101 modest_ui_actions_on_edit_mode_move_to (ModestWindow *win)
6103 GtkWidget *dialog = NULL;
6104 MoveToInfo *helper = NULL;
6105 TnyList *list_to_move;
6107 g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
6109 #ifndef MODEST_TOOLKIT_HILDON2
6110 /* Get the main window if exists */
6111 ModestMainWindow *main_window;
6112 if (MODEST_IS_MAIN_WINDOW (win))
6113 main_window = MODEST_MAIN_WINDOW (win);
6116 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
6117 FALSE)); /* don't create */
6120 list_to_move = modest_platform_get_list_to_move (MODEST_WINDOW (win));
6125 if (tny_list_get_length (list_to_move) < 1) {
6126 g_object_unref (list_to_move);
6130 /* Create and run the dialog */
6131 dialog = create_move_to_dialog (GTK_WINDOW (win), NULL, list_to_move);
6132 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
6133 GTK_WINDOW (dialog),
6137 helper = g_slice_new0 (MoveToInfo);
6138 helper->list = list_to_move;
6141 /* Listen to response signal */
6142 g_signal_connect (dialog, "response", G_CALLBACK (on_move_to_dialog_response), helper);
6144 /* Show the dialog */
6145 gtk_widget_show (dialog);
6151 * Calls #HeadersFunc for each header already selected in the main
6152 * window or the message currently being shown in the msg view window
6155 do_headers_action (ModestWindow *win,
6159 TnyList *headers_list = NULL;
6160 TnyIterator *iter = NULL;
6161 TnyHeader *header = NULL;
6162 TnyFolder *folder = NULL;
6165 headers_list = get_selected_headers (win);
6169 /* Get the folder */
6170 iter = tny_list_create_iterator (headers_list);
6171 header = TNY_HEADER (tny_iterator_get_current (iter));
6173 folder = tny_header_get_folder (header);
6174 g_object_unref (header);
6177 /* Call the function for each header */
6178 while (!tny_iterator_is_done (iter)) {
6179 header = TNY_HEADER (tny_iterator_get_current (iter));
6180 func (header, win, user_data);
6181 g_object_unref (header);
6182 tny_iterator_next (iter);
6185 /* Trick: do a poke status in order to speed up the signaling
6188 tny_folder_poke_status (folder);
6189 g_object_unref (folder);
6193 g_object_unref (iter);
6194 g_object_unref (headers_list);
6198 modest_ui_actions_view_attachment (GtkAction *action,
6199 ModestWindow *window)
6201 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6202 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
6204 /* not supported window for this action */
6205 g_return_if_reached ();
6210 modest_ui_actions_save_attachments (GtkAction *action,
6211 ModestWindow *window)
6213 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6215 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
6218 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
6220 /* not supported window for this action */
6221 g_return_if_reached ();
6226 modest_ui_actions_remove_attachments (GtkAction *action,
6227 ModestWindow *window)
6229 if (MODEST_IS_MAIN_WINDOW (window)) {
6230 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
6231 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6232 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
6234 /* not supported window for this action */
6235 g_return_if_reached ();
6240 modest_ui_actions_on_settings (GtkAction *action,
6245 dialog = modest_platform_get_global_settings_dialog ();
6246 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
6247 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
6248 gtk_widget_show_all (dialog);
6250 gtk_dialog_run (GTK_DIALOG (dialog));
6252 gtk_widget_destroy (dialog);
6256 modest_ui_actions_on_help (GtkAction *action,
6259 /* Help app is not available at all in fremantle */
6260 #ifndef MODEST_TOOLKIT_HILDON2
6261 const gchar *help_id;
6263 g_return_if_fail (win && GTK_IS_WINDOW(win));
6265 help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
6268 modest_platform_show_help (GTK_WINDOW (win), help_id);
6273 modest_ui_actions_on_csm_help (GtkAction *action,
6276 /* Help app is not available at all in fremantle */
6277 #ifndef MODEST_TOOLKIT_HILDON2
6279 const gchar* help_id = NULL;
6280 GtkWidget *folder_view;
6281 TnyFolderStore *folder_store;
6283 g_return_if_fail (win && MODEST_IS_MAIN_WINDOW (win));
6285 /* Get selected folder */
6286 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
6287 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6288 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6290 /* Switch help_id */
6291 if (folder_store && TNY_IS_FOLDER (folder_store))
6292 help_id = modest_tny_folder_get_help_id (TNY_FOLDER (folder_store));
6295 g_object_unref (folder_store);
6298 modest_platform_show_help (GTK_WINDOW (win), help_id);
6300 modest_ui_actions_on_help (action, win);
6305 retrieve_contents_cb (ModestMailOperation *mail_op,
6312 /* We only need this callback to show an error in case of
6313 memory low condition */
6314 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
6315 g_debug ("%s: message failed to retrieve. Memory low?", __FUNCTION__);
6320 retrieve_msg_contents_performer (gboolean canceled,
6322 GtkWindow *parent_window,
6323 TnyAccount *account,
6326 ModestMailOperation *mail_op;
6327 TnyList *headers = TNY_LIST (user_data);
6329 if (err || canceled) {
6330 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
6331 (GtkWidget *) parent_window, err,
6336 /* Create mail operation */
6337 mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
6338 modest_ui_actions_disk_operations_error_handler,
6340 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
6341 modest_mail_operation_get_msgs_full (mail_op, headers, retrieve_contents_cb, NULL, NULL);
6344 g_object_unref (mail_op);
6346 g_object_unref (headers);
6347 g_object_unref (account);
6351 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
6352 ModestWindow *window)
6354 TnyList *headers = NULL;
6355 TnyAccount *account = NULL;
6356 TnyIterator *iter = NULL;
6357 TnyHeader *header = NULL;
6358 TnyFolder *folder = NULL;
6361 headers = get_selected_headers (window);
6365 /* Pick the account */
6366 iter = tny_list_create_iterator (headers);
6367 header = TNY_HEADER (tny_iterator_get_current (iter));
6368 folder = tny_header_get_folder (header);
6369 account = tny_folder_get_account (folder);
6370 g_object_unref (folder);
6371 g_object_unref (header);
6372 g_object_unref (iter);
6374 /* Connect and perform the message retrieval */
6375 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6376 g_object_ref (account),
6377 retrieve_msg_contents_performer,
6378 g_object_ref (headers));
6381 g_object_unref (account);
6382 g_object_unref (headers);
6386 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
6388 g_return_if_fail (MODEST_IS_WINDOW (window));
6391 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_TOOLBAR);
6395 modest_ui_actions_check_menu_dimming_rules (ModestWindow *window)
6397 g_return_if_fail (MODEST_IS_WINDOW (window));
6400 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_MENU);
6404 modest_ui_actions_on_email_menu_activated (GtkAction *action,
6405 ModestWindow *window)
6407 g_return_if_fail (MODEST_IS_WINDOW (window));
6410 modest_ui_actions_check_menu_dimming_rules (window);
6414 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
6415 ModestWindow *window)
6417 g_return_if_fail (MODEST_IS_WINDOW (window));
6420 modest_ui_actions_check_menu_dimming_rules (window);
6424 modest_ui_actions_on_view_menu_activated (GtkAction *action,
6425 ModestWindow *window)
6427 g_return_if_fail (MODEST_IS_WINDOW (window));
6430 modest_ui_actions_check_menu_dimming_rules (window);
6434 modest_ui_actions_on_format_menu_activated (GtkAction *action,
6435 ModestWindow *window)
6437 g_return_if_fail (MODEST_IS_WINDOW (window));
6440 modest_ui_actions_check_menu_dimming_rules (window);
6444 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
6445 ModestWindow *window)
6447 g_return_if_fail (MODEST_IS_WINDOW (window));
6450 modest_ui_actions_check_menu_dimming_rules (window);
6454 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
6455 ModestWindow *window)
6457 g_return_if_fail (MODEST_IS_WINDOW (window));
6460 modest_ui_actions_check_menu_dimming_rules (window);
6464 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
6465 ModestWindow *window)
6467 g_return_if_fail (MODEST_IS_WINDOW (window));
6470 modest_ui_actions_check_menu_dimming_rules (window);
6474 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
6475 ModestWindow *window)
6477 g_return_if_fail (MODEST_IS_WINDOW (window));
6480 modest_ui_actions_check_menu_dimming_rules (window);
6484 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
6485 ModestWindow *window)
6487 g_return_if_fail (MODEST_IS_WINDOW (window));
6490 modest_ui_actions_check_menu_dimming_rules (window);
6494 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
6496 g_return_if_fail (MODEST_IS_WINDOW (window));
6498 /* we check for low-mem; in that case, show a warning, and don't allow
6501 if (modest_platform_check_memory_low (window, TRUE))
6504 modest_platform_show_search_messages (GTK_WINDOW (window));
6508 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
6510 g_return_if_fail (MODEST_IS_WINDOW (win));
6513 /* we check for low-mem; in that case, show a warning, and don't allow
6514 * for the addressbook
6516 if (modest_platform_check_memory_low (win, TRUE))
6520 modest_platform_show_addressbook (GTK_WINDOW (win));
6525 modest_ui_actions_on_toggle_find_in_page (GtkAction *action,
6526 ModestWindow *window)
6529 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
6531 if (GTK_IS_TOGGLE_ACTION (action))
6532 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
6536 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window),
6541 on_send_receive_finished (ModestMailOperation *mail_op,
6544 GtkWidget *header_view, *folder_view;
6545 TnyFolderStore *folder_store;
6546 ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
6548 /* Set send/receive operation finished */
6549 modest_main_window_notify_send_receive_completed (main_win);
6551 /* Don't refresh the current folder if there were any errors */
6552 if (modest_mail_operation_get_status (mail_op) !=
6553 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
6556 /* Refresh the current folder if we're viewing a window. We do
6557 this because the user won't be able to see the new mails in
6558 the selected folder after a Send&Receive because it only
6559 performs a poke_status, i.e, only the number of read/unread
6560 messages is updated, but the new headers are not
6562 folder_view = modest_main_window_get_child_widget (main_win,
6563 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6567 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6569 /* Do not need to refresh INBOX again because the
6570 update_account does it always automatically */
6571 if (folder_store && TNY_IS_FOLDER (folder_store) &&
6572 tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
6573 ModestMailOperation *refresh_op;
6575 header_view = modest_main_window_get_child_widget (main_win,
6576 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6578 /* We do not need to set the contents style
6579 because it hasn't changed. We also do not
6580 need to save the widget status. Just force
6582 refresh_op = modest_mail_operation_new (G_OBJECT (main_win));
6583 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), refresh_op);
6584 modest_mail_operation_refresh_folder (refresh_op, TNY_FOLDER (folder_store),
6585 folder_refreshed_cb, main_win);
6586 g_object_unref (refresh_op);
6590 g_object_unref (folder_store);
6595 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
6601 const gchar* server_name = NULL;
6602 TnyTransportAccount *transport;
6603 gchar *message = NULL;
6604 ModestProtocol *protocol;
6606 /* Don't show anything if the user cancelled something or the
6607 * send receive request is not interactive. Authentication
6608 * errors are managed by the account store so no need to show
6609 * a dialog here again */
6610 if (err->code == TNY_SYSTEM_ERROR_CANCEL ||
6611 err->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
6612 !modest_tny_send_queue_get_requested_send_receive (MODEST_TNY_SEND_QUEUE (self)))
6616 /* Get the server name. Note that we could be using a
6617 connection specific transport account */
6618 transport = (TnyTransportAccount *)
6619 tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
6621 ModestTnyAccountStore *acc_store;
6622 const gchar *acc_name;
6623 TnyTransportAccount *conn_specific;
6625 acc_store = modest_runtime_get_account_store();
6626 acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
6627 conn_specific = (TnyTransportAccount *)
6628 modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
6629 if (conn_specific) {
6630 server_name = tny_account_get_hostname (TNY_ACCOUNT (conn_specific));
6631 g_object_unref (conn_specific);
6633 server_name = tny_account_get_hostname (TNY_ACCOUNT (transport));
6635 g_object_unref (transport);
6639 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
6640 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
6641 tny_account_get_proto (TNY_ACCOUNT (transport)));
6643 g_warning ("%s: Account with no proto", __FUNCTION__);
6647 /* Show the appropriate message text for the GError: */
6648 switch (err->code) {
6649 case TNY_SERVICE_ERROR_CONNECT:
6650 message = modest_protocol_get_translation (protocol,
6651 MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
6654 case TNY_SERVICE_ERROR_SEND:
6655 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6657 case TNY_SERVICE_ERROR_UNAVAILABLE:
6658 message = modest_protocol_get_translation (protocol,
6659 MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR,
6663 g_warning ("%s: unexpected ERROR %d",
6664 __FUNCTION__, err->code);
6665 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6669 modest_platform_run_information_dialog (NULL, message, FALSE);
6674 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
6679 ModestWindow *top_window = NULL;
6680 ModestWindowMgr *mgr = NULL;
6681 GtkWidget *header_view = NULL;
6682 TnyFolder *selected_folder = NULL;
6683 TnyFolderType folder_type;
6685 mgr = modest_runtime_get_window_mgr ();
6686 top_window = modest_window_mgr_get_current_top (mgr);
6691 #ifndef MODEST_TOOLKIT_HILDON2
6692 if (MODEST_IS_MAIN_WINDOW (top_window)) {
6693 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (top_window),
6694 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6697 if (MODEST_IS_HEADER_WINDOW (top_window)) {
6698 header_view = (GtkWidget *)
6699 modest_header_window_get_header_view (MODEST_HEADER_WINDOW (top_window));
6703 /* Get selected folder */
6705 selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
6706 if (!selected_folder)
6709 /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
6710 #if GTK_CHECK_VERSION(2, 8, 0)
6711 folder_type = modest_tny_folder_guess_folder_type (selected_folder);
6712 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
6713 GtkTreeViewColumn *tree_column;
6715 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
6716 TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
6718 gtk_tree_view_column_queue_resize (tree_column);
6720 #else /* #if GTK_CHECK_VERSION(2, 8, 0) */
6721 gtk_widget_queue_draw (header_view);
6724 #ifndef MODEST_TOOLKIT_HILDON2
6725 /* Rerun dimming rules, because the message could become deletable for example */
6726 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6727 MODEST_DIMMING_RULES_TOOLBAR);
6728 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6729 MODEST_DIMMING_RULES_MENU);
6733 g_object_unref (selected_folder);
6737 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
6738 TnyAccount *account)
6740 ModestProtocolType protocol_type;
6741 ModestProtocol *protocol;
6742 gchar *error_note = NULL;
6744 protocol_type = modest_tny_account_get_protocol_type (account);
6745 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6748 error_note = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, tny_account_get_hostname (account));
6749 if (error_note == NULL) {
6750 g_warning ("%s: This should not be reached", __FUNCTION__);
6752 modest_platform_run_information_dialog (parent_window, error_note, FALSE);
6753 g_free (error_note);
6758 modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
6762 TnyFolderStore *folder = NULL;
6763 TnyAccount *account = NULL;
6764 ModestProtocolType proto;
6765 ModestProtocol *protocol;
6766 TnyHeader *header = NULL;
6768 if (MODEST_IS_MAIN_WINDOW (win)) {
6769 GtkWidget *header_view;
6770 TnyList* headers = NULL;
6772 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
6773 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6774 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6775 if (!headers || tny_list_get_length (headers) == 0) {
6777 g_object_unref (headers);
6780 iter = tny_list_create_iterator (headers);
6781 header = TNY_HEADER (tny_iterator_get_current (iter));
6782 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6783 g_object_unref (iter);
6784 g_object_unref (headers);
6785 #ifdef MODEST_TOOLKIT_HILDON2
6786 } else if (MODEST_IS_HEADER_WINDOW (win)) {
6787 GtkWidget *header_view;
6788 TnyList* headers = NULL;
6790 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
6791 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6792 if (!headers || tny_list_get_length (headers) == 0) {
6794 g_object_unref (headers);
6797 iter = tny_list_create_iterator (headers);
6798 header = TNY_HEADER (tny_iterator_get_current (iter));
6800 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6802 g_warning ("List should contain headers");
6804 g_object_unref (iter);
6805 g_object_unref (headers);
6807 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
6808 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
6810 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6813 if (!header || !folder)
6816 /* Get the account type */
6817 account = tny_folder_get_account (TNY_FOLDER (folder));
6818 proto = modest_tny_account_get_protocol_type (account);
6819 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6822 subject = tny_header_dup_subject (header);
6823 msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
6827 msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
6833 g_object_unref (account);
6835 g_object_unref (folder);
6837 g_object_unref (header);
6843 modest_ui_actions_on_delete_account (GtkWindow *parent_window,
6844 const gchar *account_name,
6845 const gchar *account_title)
6847 ModestAccountMgr *account_mgr;
6850 ModestProtocol *protocol;
6851 gboolean removed = FALSE;
6853 g_return_val_if_fail (account_name, FALSE);
6854 g_return_val_if_fail (account_title, FALSE);
6856 account_mgr = modest_runtime_get_account_mgr();
6858 /* The warning text depends on the account type: */
6859 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6860 modest_account_mgr_get_store_protocol (account_mgr,
6862 txt = modest_protocol_get_translation (protocol,
6863 MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX,
6866 txt = g_strdup_printf (_("emev_nc_delete_mailbox"), account_title);
6868 response = modest_platform_run_confirmation_dialog (parent_window, txt);
6872 if (response == GTK_RESPONSE_OK) {
6873 /* Remove account. If it succeeds then it also removes
6874 the account from the ModestAccountView: */
6875 gboolean is_default = FALSE;
6876 gchar *default_account_name = modest_account_mgr_get_default_account (account_mgr);
6877 if (default_account_name && (strcmp (default_account_name, account_name) == 0))
6879 g_free (default_account_name);
6881 removed = modest_account_mgr_remove_account (account_mgr, account_name);
6883 /* Close all email notifications, we cannot
6884 distinguish if the notification belongs to
6885 this account or not, so for safety reasons
6886 we remove them all */
6887 modest_platform_remove_new_mail_notifications (FALSE);
6889 g_warning ("%s: modest_account_mgr_remove_account() failed.\n", __FUNCTION__);
6896 on_fetch_images_performer (gboolean canceled,
6898 GtkWindow *parent_window,
6899 TnyAccount *account,
6902 if (err || canceled) {
6903 /* Show an unable to retrieve images ??? */
6907 /* Note that the user could have closed the window while connecting */
6908 if (GTK_WIDGET_VISIBLE (parent_window))
6909 modest_msg_view_window_fetch_images ((ModestMsgViewWindow *) parent_window);
6910 g_object_unref ((GObject *) user_data);
6914 modest_ui_actions_on_fetch_images (GtkAction *action,
6915 ModestWindow *window)
6917 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
6919 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6921 on_fetch_images_performer,
6922 g_object_ref (window));
6926 modest_ui_actions_on_reload_message (const gchar *msg_id)
6928 ModestWindow *window = NULL;
6930 g_return_if_fail (msg_id && msg_id[0] != '\0');
6931 if (!modest_window_mgr_find_registered_message_uid (modest_runtime_get_window_mgr (),
6937 if (window == NULL || !MODEST_IS_MSG_VIEW_WINDOW (window))
6940 modest_msg_view_window_reload (MODEST_MSG_VIEW_WINDOW (window));
6943 /** Check whether any connections are active, and cancel them if
6945 * Returns TRUE is there was no problem,
6946 * or if an operation was cancelled so we can continue.
6947 * Returns FALSE if the user chose to cancel his request instead.
6951 modest_ui_actions_check_for_active_account (ModestWindow *self,
6952 const gchar* account_name)
6954 ModestTnySendQueue *send_queue;
6955 ModestTnyAccountStore *acc_store;
6956 ModestMailOperationQueue* queue;
6957 TnyConnectionStatus store_conn_status;
6958 TnyAccount *store_account = NULL, *transport_account = NULL;
6959 gboolean retval = TRUE, sending = FALSE;
6961 acc_store = modest_runtime_get_account_store ();
6962 queue = modest_runtime_get_mail_operation_queue ();
6965 modest_tny_account_store_get_server_account (acc_store,
6967 TNY_ACCOUNT_TYPE_STORE);
6969 /* This could happen if the account was deleted before the
6970 call to this function */
6975 modest_tny_account_store_get_server_account (acc_store,
6977 TNY_ACCOUNT_TYPE_TRANSPORT);
6979 /* This could happen if the account was deleted before the
6980 call to this function */
6981 if (!transport_account) {
6982 g_object_unref (store_account);
6986 /* If the transport account was not used yet, then the send
6987 queue could not exist (it's created on demand) */
6988 send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (transport_account), FALSE);
6989 if (TNY_IS_SEND_QUEUE (send_queue))
6990 sending = modest_tny_send_queue_sending_in_progress (send_queue);
6992 store_conn_status = tny_account_get_connection_status (store_account);
6993 if (store_conn_status == TNY_CONNECTION_STATUS_CONNECTED || sending) {
6996 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (self),
6997 _("emev_nc_disconnect_account"));
6998 if (response == GTK_RESPONSE_OK) {
7007 /* FIXME: We should only cancel those of this account */
7008 modest_mail_operation_queue_cancel_all (queue);
7010 /* Also disconnect the account */
7011 if ((tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED) &&
7012 (tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED_BROKEN)) {
7013 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account),
7017 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account),
7023 g_object_unref (store_account);
7024 g_object_unref (transport_account);