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 ModestWindow *main_window = NULL;
525 ModestWindowMgr *mgr = NULL;
526 GtkTreeModel *model = NULL;
527 GtkTreeSelection *sel = NULL;
528 GList *sel_list = NULL, *tmp = NULL;
529 GtkTreeRowReference *next_row_reference = NULL;
530 GtkTreeRowReference *prev_row_reference = NULL;
531 GtkTreePath *next_path = NULL;
532 GtkTreePath *prev_path = NULL;
533 ModestMailOperation *mail_op = NULL;
535 /* Find last selected row */
536 if (MODEST_IS_MAIN_WINDOW (win)) {
537 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
538 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
539 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
540 for (tmp=sel_list; tmp; tmp=tmp->next) {
541 if (tmp->next == NULL) {
542 prev_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
543 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
545 gtk_tree_path_prev (prev_path);
546 gtk_tree_path_next (next_path);
548 prev_row_reference = gtk_tree_row_reference_new (model, prev_path);
549 next_row_reference = gtk_tree_row_reference_new (model, next_path);
554 /* Disable window dimming management */
555 modest_window_disable_dimming (MODEST_WINDOW(win));
557 /* Remove each header. If it's a view window header_view == NULL */
558 mail_op = modest_mail_operation_new ((GObject *) win);
559 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
561 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
562 g_object_unref (mail_op);
564 /* Enable window dimming management */
566 gtk_tree_selection_unselect_all (sel);
568 modest_window_enable_dimming (MODEST_WINDOW(win));
570 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
571 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
573 /* Get main window */
574 mgr = modest_runtime_get_window_mgr ();
575 main_window = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
576 } else if (MODEST_IS_MAIN_WINDOW (win)) {
577 /* Move cursor to next row */
580 /* Select next or previous row */
581 if (gtk_tree_row_reference_valid (next_row_reference)) {
582 gtk_tree_selection_select_path (sel, next_path);
584 else if (gtk_tree_row_reference_valid (prev_row_reference)) {
585 gtk_tree_selection_select_path (sel, prev_path);
589 if (gtk_tree_row_reference_valid (next_row_reference))
590 gtk_tree_row_reference_free (next_row_reference);
591 if (next_path != NULL)
592 gtk_tree_path_free (next_path);
593 if (gtk_tree_row_reference_valid (prev_row_reference))
594 gtk_tree_row_reference_free (prev_row_reference);
595 if (prev_path != NULL)
596 gtk_tree_path_free (prev_path);
599 /* Update toolbar dimming state */
601 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
602 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
606 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
607 g_list_free (sel_list);
616 g_object_unref (header_list);
624 /* delete either message or folder, based on where we are */
626 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
628 g_return_if_fail (MODEST_IS_WINDOW(win));
630 /* Check first if the header view has the focus */
631 if (MODEST_IS_MAIN_WINDOW (win)) {
633 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
634 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
635 if (gtk_widget_is_focus (w)) {
636 modest_ui_actions_on_delete_folder (action, MODEST_WINDOW(win));
640 modest_ui_actions_on_delete_message (action, win);
644 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
646 ModestWindowMgr *mgr = NULL;
648 #ifdef MODEST_PLATFORM_MAEMO
649 modest_osso_save_state();
650 #endif /* MODEST_PLATFORM_MAEMO */
652 g_debug ("closing down, clearing %d item(s) from operation queue",
653 modest_mail_operation_queue_num_elements
654 (modest_runtime_get_mail_operation_queue()));
656 /* cancel all outstanding operations */
657 modest_mail_operation_queue_cancel_all
658 (modest_runtime_get_mail_operation_queue());
660 g_debug ("queue has been cleared");
663 /* Check if there are opened editing windows */
664 mgr = modest_runtime_get_window_mgr ();
665 modest_window_mgr_close_all_windows (mgr);
667 /* note: when modest-tny-account-store is finalized,
668 it will automatically set all network connections
671 /* gtk_main_quit (); */
675 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
679 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
681 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
682 /* gtk_widget_destroy (GTK_WIDGET (win)); */
683 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
684 /* gboolean ret_value; */
685 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
686 /* } else if (MODEST_IS_WINDOW (win)) { */
687 /* gtk_widget_destroy (GTK_WIDGET (win)); */
689 /* g_return_if_reached (); */
694 modest_ui_actions_add_to_contacts (GtkAction *action, ModestWindow *win)
696 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
698 modest_msg_view_window_add_to_contacts (MODEST_MSG_VIEW_WINDOW (win));
702 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
704 GtkClipboard *clipboard = NULL;
705 gchar *selection = NULL;
707 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
708 selection = gtk_clipboard_wait_for_text (clipboard);
710 /* Question: why is the clipboard being used here?
711 * It doesn't really make a lot of sense. */
715 modest_address_book_add_address (selection);
721 modest_ui_actions_on_new_account (GtkAction *action,
722 ModestWindow *window)
724 if (!modest_ui_actions_run_account_setup_wizard (window)) {
725 g_debug ("%s: wizard was already running", __FUNCTION__);
730 modest_ui_actions_on_accounts (GtkAction *action,
733 /* This is currently only implemented for Maemo */
734 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
735 if (!modest_ui_actions_run_account_setup_wizard (win))
736 g_debug ("%s: wizard was already running", __FUNCTION__);
740 /* Show the list of accounts */
741 GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
743 /* The accounts dialog must be modal */
744 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (account_win), (GtkWindow *) win);
745 modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
750 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
752 /* This is currently only implemented for Maemo,
753 * because it requires an API (libconic) to detect different connection
756 #ifndef MODEST_TOOLKIT_GTK /* Defined in config.h */
758 /* Create the window if necessary: */
759 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
760 modest_connection_specific_smtp_window_fill_with_connections (
761 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
762 modest_runtime_get_account_mgr());
764 /* Show the window: */
765 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
766 GTK_WINDOW (specific_window), (GtkWindow *) win);
767 gtk_widget_show (specific_window);
768 #endif /* !MODEST_TOOLKIT_GTK */
772 count_part_size (const gchar *part)
774 GnomeVFSURI *vfs_uri;
775 gchar *escaped_filename;
777 GnomeVFSFileInfo *info;
780 /* Estimation of attachment size if we cannot get it from file info */
783 vfs_uri = gnome_vfs_uri_new (part);
785 escaped_filename = g_path_get_basename (gnome_vfs_uri_get_path (vfs_uri));
786 filename = gnome_vfs_unescape_string_for_display (escaped_filename);
787 g_free (escaped_filename);
788 gnome_vfs_uri_unref (vfs_uri);
790 info = gnome_vfs_file_info_new ();
792 if (gnome_vfs_get_file_info (part,
794 GNOME_VFS_FILE_INFO_GET_MIME_TYPE)
796 if (info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) {
801 gnome_vfs_file_info_unref (info);
807 count_parts_size (GSList *parts)
812 for (node = parts; node != NULL; node = g_slist_next (node)) {
813 result += count_part_size ((const gchar *) node->data);
820 modest_ui_actions_compose_msg(ModestWindow *win,
823 const gchar *bcc_str,
824 const gchar *subject_str,
825 const gchar *body_str,
827 gboolean set_as_modified)
829 gchar *account_name = NULL;
830 const gchar *mailbox;
832 TnyAccount *account = NULL;
833 TnyFolder *folder = NULL;
834 gchar *from_str = NULL, *signature = NULL, *body = NULL;
835 gchar *recipient = NULL;
836 gboolean use_signature = FALSE;
837 ModestWindow *msg_win = NULL;
838 ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
839 ModestTnyAccountStore *store = modest_runtime_get_account_store();
840 GnomeVFSFileSize total_size, allowed_size;
841 guint64 available_disk, expected_size, parts_size;
844 /* we check for low-mem */
845 if (modest_platform_check_memory_low (win, TRUE))
848 available_disk = modest_utils_get_available_space (NULL);
849 parts_count = g_slist_length (attachments);
850 parts_size = count_parts_size (attachments);
851 expected_size = modest_tny_msg_estimate_size (body, NULL, parts_count, parts_size);
853 /* Double check: disk full condition or message too big */
854 if (available_disk < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE ||
855 expected_size > available_disk) {
856 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
857 modest_platform_system_banner (NULL, NULL, msg);
863 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
864 modest_platform_run_information_dialog (
866 _("mail_ib_error_attachment_size"),
872 #ifdef MODEST_TOOLKIT_HILDON2
874 account_name = g_strdup (modest_window_get_active_account(win));
877 account_name = modest_account_mgr_get_default_account(mgr);
880 g_printerr ("modest: no account found\n");
885 mailbox = modest_window_get_active_mailbox (win);
888 account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
890 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
893 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
895 g_printerr ("modest: failed to find Drafts folder\n");
898 from_str = modest_account_mgr_get_from_string (mgr, account_name, mailbox);
900 g_printerr ("modest: failed get from string for '%s'\n", account_name);
904 recipient = modest_text_utils_get_email_address (from_str);
905 signature = modest_account_mgr_get_signature_from_recipient (mgr, recipient, &use_signature);
907 if (body_str != NULL) {
908 body = use_signature ? g_strconcat(body_str, "\n",
909 MODEST_TEXT_UTILS_SIGNATURE_MARKER,
910 "\n", signature, NULL) : g_strdup(body_str);
912 body = use_signature ? g_strconcat("\n", MODEST_TEXT_UTILS_SIGNATURE_MARKER,
913 "\n", signature, NULL) : g_strdup("");
916 msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, NULL, NULL, body, NULL, NULL, NULL);
918 g_printerr ("modest: failed to create new msg\n");
922 /* Create and register edit window */
923 /* This is destroyed by TODO. */
925 allowed_size = MODEST_MAX_ATTACHMENT_SIZE;
926 msg_win = modest_msg_edit_window_new (msg, account_name, mailbox, FALSE);
928 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win, win)) {
929 gtk_widget_destroy (GTK_WIDGET (msg_win));
932 modest_msg_edit_window_set_modified (MODEST_MSG_EDIT_WINDOW (msg_win), set_as_modified);
933 gtk_widget_show_all (GTK_WIDGET (msg_win));
935 while (attachments) {
936 GnomeVFSFileSize att_size;
938 modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
939 attachments->data, allowed_size);
940 total_size += att_size;
942 if (att_size > allowed_size) {
943 g_debug ("%s: total size: %u",
944 __FUNCTION__, (unsigned int)total_size);
947 allowed_size -= att_size;
949 attachments = g_slist_next(attachments);
956 g_free (account_name);
958 g_object_unref (G_OBJECT(account));
960 g_object_unref (G_OBJECT(folder));
962 g_object_unref (G_OBJECT(msg));
966 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
968 /* if there are no accounts yet, just show the wizard */
969 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
970 if (!modest_ui_actions_run_account_setup_wizard (win))
973 modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL, FALSE);
978 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
982 ModestMailOperationStatus status;
984 /* If there is no message or the operation was not successful */
985 status = modest_mail_operation_get_status (mail_op);
986 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
989 /* If it's a memory low issue, then show a banner */
990 error = modest_mail_operation_get_error (mail_op);
991 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
992 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
993 GObject *source = modest_mail_operation_get_source (mail_op);
994 modest_platform_run_information_dialog (GTK_IS_WINDOW (source) ? GTK_WINDOW (source) : NULL,
995 _KR("memr_ib_operation_disabled"),
997 g_object_unref (source);
1000 if (error && ((error->code == TNY_SERVICE_ERROR_NO_SUCH_MESSAGE) ||
1001 error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE)) {
1002 gchar *subject, *msg, *format = NULL;
1003 TnyAccount *account;
1005 subject = header?tny_header_dup_subject (header):NULL;
1007 subject = g_strdup (_("mail_va_no_subject"));
1009 account = modest_mail_operation_get_account (mail_op);
1011 ModestProtocol *protocol;
1012 ModestProtocolType proto;
1013 proto = modest_tny_account_get_protocol_type (account);
1014 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (), proto);
1016 format = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
1017 g_object_unref (account);
1021 format = g_strdup (_("emev_ni_ui_imap_message_not_available_in_server"));
1023 msg = g_strdup_printf (format, subject);
1024 modest_platform_run_information_dialog (NULL, msg, FALSE);
1030 /* Remove the header from the preregistered uids */
1031 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1044 } OpenMsgBannerInfo;
1047 GtkTreeModel *model;
1049 OpenMsgBannerInfo *banner_info;
1050 GtkTreeRowReference *rowref;
1054 open_msg_banner_idle (gpointer userdata)
1056 OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) userdata;
1058 gdk_threads_enter ();
1059 banner_info->idle_handler = 0;
1060 banner_info->banner = modest_platform_animation_banner (NULL, NULL, banner_info->message);
1061 if (banner_info->banner)
1062 g_object_ref (banner_info->banner);
1064 gdk_threads_leave ();
1070 get_header_view_from_window (ModestWindow *window)
1072 GtkWidget *header_view;
1074 if (MODEST_IS_MAIN_WINDOW (window)) {
1075 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
1076 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1077 #ifdef MODEST_TOOLKIT_HILDON2
1078 } else if (MODEST_IS_HEADER_WINDOW (window)){
1079 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
1089 get_info_from_header (TnyHeader *header, gboolean *is_draft, gboolean *can_open)
1092 gchar *account = NULL;
1093 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
1098 folder = tny_header_get_folder (header);
1099 /* Gets folder type (OUTBOX headers will be opened in edit window */
1100 if (modest_tny_folder_is_local_folder (folder)) {
1101 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1102 if (folder_type == TNY_FOLDER_TYPE_INVALID)
1103 g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
1106 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
1107 TnyTransportAccount *traccount = NULL;
1108 ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
1109 traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
1111 ModestTnySendQueue *send_queue = NULL;
1112 ModestTnySendQueueStatus status;
1114 account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
1115 TNY_ACCOUNT(traccount)));
1116 send_queue = modest_runtime_get_send_queue(traccount, TRUE);
1117 if (TNY_IS_SEND_QUEUE (send_queue)) {
1118 msg_id = modest_tny_send_queue_get_msg_id (header);
1119 status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
1121 /* Only open messages in outbox with the editor if they are in Failed state */
1122 if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
1125 #ifdef MODEST_TOOLKIT_HILDON2
1127 /* In Fremantle we can not
1128 open any message from
1129 outbox which is not in
1135 g_object_unref(traccount);
1137 g_warning("Cannot get transport account for message in outbox!!");
1139 } else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
1140 *is_draft = TRUE; /* Open in editor if the message is in the Drafts folder */
1144 TnyAccount *acc = tny_folder_get_account (folder);
1147 g_strdup (modest_tny_account_get_parent_modest_account_name_for_server_account (acc));
1148 g_object_unref (acc);
1152 g_object_unref (folder);
1158 open_msg_cb (ModestMailOperation *mail_op,
1165 ModestWindowMgr *mgr = NULL;
1166 ModestWindow *parent_win = NULL;
1167 ModestWindow *win = NULL;
1168 gchar *account = NULL;
1169 gboolean open_in_editor = FALSE;
1171 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1173 /* Do nothing if there was any problem with the mail
1174 operation. The error will be shown by the error_handler of
1175 the mail operation */
1176 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1179 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
1181 /* Mark header as read */
1182 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
1184 account = get_info_from_header (header, &open_in_editor, &can_open);
1188 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
1190 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1192 if (open_in_editor) {
1193 ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
1194 gchar *from_header = NULL, *acc_name;
1195 gchar *mailbox = NULL;
1197 from_header = tny_header_dup_from (header);
1199 /* we cannot edit without a valid account... */
1200 if (!modest_account_mgr_has_accounts(mgr, TRUE)) {
1201 if (!modest_ui_actions_run_account_setup_wizard(parent_win)) {
1202 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1204 g_free (from_header);
1209 acc_name = modest_utils_get_account_name_from_recipient (from_header, &mailbox);
1210 g_free (from_header);
1216 win = modest_msg_edit_window_new (msg, account, mailbox, TRUE);
1220 gchar *uid = modest_tny_folder_get_header_unique_id (header);
1221 const gchar *mailbox = NULL;
1223 if (parent_win && MODEST_IS_WINDOW (parent_win))
1224 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_win));
1226 if (helper->rowref && helper->model) {
1227 win = modest_msg_view_window_new_with_header_model (msg, account, mailbox, (const gchar*) uid,
1228 helper->model, helper->rowref);
1230 win = modest_msg_view_window_new_for_attachment (msg, account, mailbox, (const gchar*) uid);
1235 /* Register and show new window */
1237 mgr = modest_runtime_get_window_mgr ();
1238 if (!modest_window_mgr_register_window (mgr, win, NULL)) {
1239 gtk_widget_destroy (GTK_WIDGET (win));
1242 gtk_widget_show_all (GTK_WIDGET(win));
1245 /* Update toolbar dimming state */
1246 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
1247 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
1253 g_object_unref (parent_win);
1257 modest_ui_actions_disk_operations_error_handler (ModestMailOperation *mail_op,
1260 const GError *error;
1261 GObject *win = NULL;
1262 ModestMailOperationStatus status;
1264 win = modest_mail_operation_get_source (mail_op);
1265 error = modest_mail_operation_get_error (mail_op);
1266 status = modest_mail_operation_get_status (mail_op);
1268 /* If the mail op has been cancelled then it's not an error:
1269 don't show any message */
1270 if (status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
1271 TnyAccount *account = modest_mail_operation_get_account (mail_op);
1272 if (modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
1273 (GError *) error, account)) {
1274 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
1275 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
1277 } else if (error->code == TNY_SYSTEM_ERROR_MEMORY) {
1278 modest_platform_information_banner ((GtkWidget *) win,
1279 NULL, _("emev_ui_imap_inbox_select_error"));
1280 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
1281 error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1282 modest_platform_information_banner ((GtkWidget *) win,
1283 NULL, _CS ("sfil_ni_unable_to_open_file_not_found"));
1284 } else if (user_data) {
1285 modest_platform_information_banner ((GtkWidget *) win,
1289 g_object_unref (account);
1293 g_object_unref (win);
1297 * Returns the account a list of headers belongs to. It returns a
1298 * *new* reference so don't forget to unref it
1301 get_account_from_header_list (TnyList *headers)
1303 TnyAccount *account = NULL;
1305 if (tny_list_get_length (headers) > 0) {
1306 TnyIterator *iter = tny_list_create_iterator (headers);
1307 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1308 TnyFolder *folder = tny_header_get_folder (header);
1311 g_object_unref (header);
1313 while (!tny_iterator_is_done (iter)) {
1314 header = TNY_HEADER (tny_iterator_get_current (iter));
1315 folder = tny_header_get_folder (header);
1318 g_object_unref (header);
1320 tny_iterator_next (iter);
1325 account = tny_folder_get_account (folder);
1326 g_object_unref (folder);
1330 g_object_unref (header);
1332 g_object_unref (iter);
1338 get_account_from_header (TnyHeader *header)
1340 TnyAccount *account = NULL;
1343 folder = tny_header_get_folder (header);
1346 account = tny_folder_get_account (folder);
1347 g_object_unref (folder);
1353 open_msg_helper_destroyer (gpointer user_data)
1355 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1357 if (helper->banner_info) {
1358 g_free (helper->banner_info->message);
1359 if (helper->banner_info->idle_handler > 0) {
1360 g_source_remove (helper->banner_info->idle_handler);
1361 helper->banner_info->idle_handler = 0;
1363 if (helper->banner_info->banner != NULL) {
1364 gtk_widget_destroy (helper->banner_info->banner);
1365 g_object_unref (helper->banner_info->banner);
1366 helper->banner_info->banner = NULL;
1368 g_slice_free (OpenMsgBannerInfo, helper->banner_info);
1369 helper->banner_info = NULL;
1371 g_object_unref (helper->model);
1372 g_object_unref (helper->header);
1373 gtk_tree_row_reference_free (helper->rowref);
1374 g_slice_free (OpenMsgHelper, helper);
1378 open_msg_performer(gboolean canceled,
1380 GtkWindow *parent_window,
1381 TnyAccount *account,
1384 ModestMailOperation *mail_op = NULL;
1385 gchar *error_msg = NULL;
1386 ModestProtocolType proto;
1387 TnyConnectionStatus status;
1388 OpenMsgHelper *helper = NULL;
1389 ModestProtocol *protocol;
1390 ModestProtocolRegistry *protocol_registry;
1393 helper = (OpenMsgHelper *) user_data;
1395 status = tny_account_get_connection_status (account);
1396 if (err || canceled) {
1397 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1398 /* Free the helper */
1399 open_msg_helper_destroyer (helper);
1401 /* In disk full conditions we could get this error here */
1402 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
1403 (GtkWidget *) parent_window, err,
1409 /* Get the error message depending on the protocol */
1410 proto = modest_tny_account_get_protocol_type (account);
1411 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
1412 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
1415 protocol_registry = modest_runtime_get_protocol_registry ();
1416 subject = tny_header_dup_subject (helper->header);
1418 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, proto);
1419 error_msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
1423 if (error_msg == NULL) {
1424 error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1427 #ifndef MODEST_TOOLKIT_HILDON2
1428 gboolean show_open_draft = FALSE;
1429 if (modest_protocol_registry_protocol_type_has_tag (protocol_registry,
1431 MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS)) {
1433 TnyFolderType folder_type;
1435 folder = tny_header_get_folder (helper->header);
1436 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1437 show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
1438 g_object_unref (folder);
1442 #ifdef MODEST_TOOLKIT_HILDON2
1445 gchar *account_name = get_info_from_header (helper->header, &is_draft, &can_open);
1448 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1449 g_free (account_name);
1450 open_msg_helper_destroyer (helper);
1455 ModestWindow *window;
1456 GtkWidget *header_view;
1459 header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
1460 uid = modest_tny_folder_get_header_unique_id (helper->header);
1462 const gchar *mailbox = NULL;
1463 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_window));
1464 window = modest_msg_view_window_new_from_header_view
1465 (MODEST_HEADER_VIEW (header_view), account_name, mailbox, uid, helper->rowref);
1466 if (window != NULL) {
1467 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr (),
1469 gtk_widget_destroy (GTK_WIDGET (window));
1471 gtk_widget_show_all (GTK_WIDGET(window));
1475 g_free (account_name);
1477 open_msg_helper_destroyer (helper);
1480 g_free (account_name);
1482 /* Create the mail operation */
1484 modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
1485 modest_ui_actions_disk_operations_error_handler,
1486 g_strdup (error_msg), g_free);
1487 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1491 #ifndef MODEST_TOOLKIT_HILDON2
1492 if (show_open_draft) {
1493 helper->banner_info = g_slice_new (OpenMsgBannerInfo);
1494 helper->banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
1495 helper->banner_info->banner = NULL;
1496 helper->banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle,
1497 helper->banner_info);
1503 headers = TNY_LIST (tny_simple_list_new ());
1504 tny_list_prepend (headers, G_OBJECT (helper->header));
1505 modest_mail_operation_get_msgs_full (mail_op,
1509 open_msg_helper_destroyer);
1510 g_object_unref (headers);
1517 g_object_unref (mail_op);
1518 g_object_unref (account);
1522 * This function is used by both modest_ui_actions_on_open and
1523 * modest_ui_actions_on_header_activated. This way we always do the
1524 * same when trying to open messages.
1527 open_msg_from_header (TnyHeader *header, GtkTreeRowReference *rowref, ModestWindow *win)
1529 ModestWindowMgr *mgr = NULL;
1530 TnyAccount *account;
1531 gboolean cached = FALSE;
1533 GtkWidget *header_view = NULL;
1534 OpenMsgHelper *helper;
1535 ModestWindow *window;
1537 g_return_if_fail (header != NULL && rowref != NULL);
1539 mgr = modest_runtime_get_window_mgr ();
1542 header_view = get_header_view_from_window (MODEST_WINDOW (win));
1543 if (header_view == NULL)
1546 /* Get the account */
1547 account = get_account_from_header (header);
1552 found = modest_window_mgr_find_registered_header (mgr, header, &window);
1554 /* Do not open again the message and present the
1555 window to the user */
1558 #ifndef MODEST_TOOLKIT_HILDON2
1559 gtk_window_present (GTK_WINDOW (window));
1562 /* the header has been registered already, we don't do
1563 * anything but wait for the window to come up*/
1564 g_debug ("header %p already registered, waiting for window", header);
1569 /* Open each message */
1570 cached = tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED;
1572 /* Allways download if we are online. */
1573 if (!tny_device_is_online (modest_runtime_get_device ())) {
1576 /* If ask for user permission to download the messages */
1577 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1578 _("mcen_nc_get_msg"));
1580 /* End if the user does not want to continue */
1581 if (response == GTK_RESPONSE_CANCEL) {
1587 /* We register the window for opening */
1588 modest_window_mgr_register_header (mgr, header, NULL);
1590 /* Create the helper. We need to get a reference to the model
1591 here because it could change while the message is readed
1592 (the user could switch between folders) */
1593 helper = g_slice_new (OpenMsgHelper);
1594 helper->model = g_object_ref (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)));
1595 helper->header = g_object_ref (header);
1596 helper->rowref = gtk_tree_row_reference_copy (rowref);
1597 helper->banner_info = NULL;
1599 /* Connect to the account and perform */
1601 modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
1602 open_msg_performer, helper);
1604 /* Call directly the performer, do not need to connect */
1605 open_msg_performer (FALSE, NULL, (GtkWindow *) win,
1606 g_object_ref (account), helper);
1611 g_object_unref (account);
1615 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1622 /* we check for low-mem; in that case, show a warning, and don't allow
1625 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1629 headers = get_selected_headers (win);
1633 headers_count = tny_list_get_length (headers);
1634 if (headers_count != 1) {
1635 if (headers_count > 1) {
1636 /* Don't allow activation if there are more than one message selected */
1637 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
1640 g_object_unref (headers);
1644 iter = tny_list_create_iterator (headers);
1645 header = TNY_HEADER (tny_iterator_get_current (iter));
1646 g_object_unref (iter);
1650 open_msg_from_header (header, NULL, win);
1651 g_object_unref (header);
1654 g_object_unref(headers);
1658 rf_helper_window_closed (gpointer data,
1661 ReplyForwardHelper *helper = (ReplyForwardHelper *) data;
1663 helper->parent_window = NULL;
1666 static ReplyForwardHelper*
1667 create_reply_forward_helper (ReplyForwardAction action,
1669 guint reply_forward_type,
1672 ReplyForwardHelper *rf_helper = NULL;
1673 const gchar *active_acc = modest_window_get_active_account (win);
1674 const gchar *active_mailbox = modest_window_get_active_mailbox (win);
1676 rf_helper = g_slice_new0 (ReplyForwardHelper);
1677 rf_helper->reply_forward_type = reply_forward_type;
1678 rf_helper->action = action;
1679 rf_helper->parent_window = (MODEST_IS_WINDOW (win)) ? GTK_WIDGET (win) : NULL;
1680 rf_helper->header = (header) ? g_object_ref (header) : NULL;
1681 rf_helper->account_name = (active_acc) ?
1682 g_strdup (active_acc) :
1683 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1684 rf_helper->mailbox = g_strdup (active_mailbox);
1686 /* Note that window could be destroyed just AFTER calling
1687 register_window so we must ensure that this pointer does
1688 not hold invalid references */
1689 if (rf_helper->parent_window)
1690 g_object_weak_ref (G_OBJECT (rf_helper->parent_window),
1691 rf_helper_window_closed, rf_helper);
1697 free_reply_forward_helper (gpointer data)
1699 ReplyForwardHelper *helper;
1701 helper = (ReplyForwardHelper *) data;
1702 g_free (helper->account_name);
1703 g_free (helper->mailbox);
1705 g_object_unref (helper->header);
1706 if (helper->parent_window)
1707 g_object_weak_unref (G_OBJECT (helper->parent_window),
1708 rf_helper_window_closed, helper);
1709 g_slice_free (ReplyForwardHelper, helper);
1713 reply_forward_cb (ModestMailOperation *mail_op,
1720 TnyMsg *new_msg = NULL;
1721 ReplyForwardHelper *rf_helper;
1722 ModestWindow *msg_win = NULL;
1723 ModestEditType edit_type;
1725 TnyAccount *account = NULL;
1726 ModestWindowMgr *mgr = NULL;
1727 gchar *signature = NULL;
1728 gboolean use_signature;
1731 /* If there was any error. The mail operation could be NULL,
1732 this means that we already have the message downloaded and
1733 that we didn't do a mail operation to retrieve it */
1734 rf_helper = (ReplyForwardHelper *) user_data;
1735 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1738 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1739 rf_helper->account_name, rf_helper->mailbox);
1740 recipient = modest_text_utils_get_email_address (from);
1741 signature = modest_account_mgr_get_signature_from_recipient (modest_runtime_get_account_mgr(),
1746 /* Create reply mail */
1747 switch (rf_helper->action) {
1748 /* Use the msg_header to ensure that we have all the
1749 information. The summary can lack some data */
1750 TnyHeader *msg_header;
1752 msg_header = tny_msg_get_header (msg);
1754 modest_tny_msg_create_reply_msg (msg, msg_header, from,
1755 (use_signature) ? signature : NULL,
1756 rf_helper->reply_forward_type,
1757 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1758 g_object_unref (msg_header);
1760 case ACTION_REPLY_TO_ALL:
1761 msg_header = tny_msg_get_header (msg);
1763 modest_tny_msg_create_reply_msg (msg, msg_header, from,
1764 (use_signature) ? signature : NULL,
1765 rf_helper->reply_forward_type,
1766 MODEST_TNY_MSG_REPLY_MODE_ALL);
1767 edit_type = MODEST_EDIT_TYPE_REPLY;
1768 g_object_unref (msg_header);
1770 case ACTION_FORWARD:
1772 modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL,
1773 rf_helper->reply_forward_type);
1774 edit_type = MODEST_EDIT_TYPE_FORWARD;
1777 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1779 g_return_if_reached ();
1787 g_warning ("%s: failed to create message\n", __FUNCTION__);
1791 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1792 rf_helper->account_name,
1793 TNY_ACCOUNT_TYPE_STORE);
1795 g_warning ("%s: failed to get tnyaccount for '%s'\n", __FUNCTION__, rf_helper->account_name);
1799 /* Create and register the windows */
1800 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, rf_helper->mailbox, FALSE);
1801 mgr = modest_runtime_get_window_mgr ();
1802 modest_window_mgr_register_window (mgr, msg_win, (ModestWindow *) rf_helper->parent_window);
1804 /* Note that register_window could have deleted the account */
1805 if (MODEST_IS_WINDOW (rf_helper->parent_window)) {
1806 gdouble parent_zoom;
1808 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1809 modest_window_set_zoom (msg_win, parent_zoom);
1812 /* Show edit window */
1813 gtk_widget_show_all (GTK_WIDGET (msg_win));
1816 /* We always unregister the header because the message is
1817 forwarded or replied so the original one is no longer
1819 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1822 g_object_unref (G_OBJECT (new_msg));
1824 g_object_unref (G_OBJECT (account));
1825 free_reply_forward_helper (rf_helper);
1828 /* Checks a list of headers. If any of them are not currently
1829 * downloaded (CACHED) then returns TRUE else returns FALSE.
1832 header_list_count_uncached_msgs (TnyList *header_list)
1835 gint uncached_messages = 0;
1837 iter = tny_list_create_iterator (header_list);
1838 while (!tny_iterator_is_done (iter)) {
1841 header = TNY_HEADER (tny_iterator_get_current (iter));
1843 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1844 uncached_messages ++;
1845 g_object_unref (header);
1848 tny_iterator_next (iter);
1850 g_object_unref (iter);
1852 return uncached_messages;
1855 /* Returns FALSE if the user does not want to download the
1856 * messages. Returns TRUE if the user allowed the download.
1859 connect_to_get_msg (ModestWindow *win,
1860 gint num_of_uncached_msgs,
1861 TnyAccount *account)
1863 GtkResponseType response;
1865 /* Allways download if we are online. */
1866 if (tny_device_is_online (modest_runtime_get_device ()))
1869 /* If offline, then ask for user permission to download the messages */
1870 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1871 ngettext("mcen_nc_get_msg",
1873 num_of_uncached_msgs));
1875 if (response == GTK_RESPONSE_CANCEL)
1878 return modest_platform_connect_and_wait((GtkWindow *) win, account);
1882 reply_forward_performer (gboolean canceled,
1884 GtkWindow *parent_window,
1885 TnyAccount *account,
1888 ReplyForwardHelper *rf_helper = NULL;
1889 ModestMailOperation *mail_op;
1891 rf_helper = (ReplyForwardHelper *) user_data;
1893 if (canceled || err) {
1894 free_reply_forward_helper (rf_helper);
1898 /* Retrieve the message */
1899 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), rf_helper->header, NULL);
1900 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (parent_window),
1901 modest_ui_actions_disk_operations_error_handler,
1903 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1904 modest_mail_operation_get_msg (mail_op, rf_helper->header, TRUE, reply_forward_cb, rf_helper);
1907 g_object_unref(mail_op);
1911 * Common code for the reply and forward actions
1914 reply_forward (ReplyForwardAction action, ModestWindow *win)
1916 ReplyForwardHelper *rf_helper = NULL;
1917 guint reply_forward_type;
1919 g_return_if_fail (MODEST_IS_WINDOW(win));
1921 /* we check for low-mem; in that case, show a warning, and don't allow
1922 * reply/forward (because it could potentially require a lot of memory */
1923 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1927 /* we need an account when editing */
1928 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1929 if (!modest_ui_actions_run_account_setup_wizard (win))
1933 reply_forward_type =
1934 modest_conf_get_int (modest_runtime_get_conf (),
1935 (action == ACTION_FORWARD) ?
1936 MODEST_CONF_FORWARD_TYPE :
1937 MODEST_CONF_REPLY_TYPE,
1940 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1942 TnyHeader *header = NULL;
1943 /* Get header and message. Do not free them here, the
1944 reply_forward_cb must do it */
1945 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1946 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
1948 if (msg && header) {
1950 rf_helper = create_reply_forward_helper (action, win,
1951 reply_forward_type, header);
1952 reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
1954 g_warning("%s: no message or header found in viewer\n", __FUNCTION__);
1958 g_object_unref (msg);
1960 g_object_unref (header);
1962 TnyHeader *header = NULL;
1964 gboolean do_retrieve = TRUE;
1965 TnyList *header_list = NULL;
1967 header_list = get_selected_headers (win);
1970 /* Check that only one message is selected for replying */
1971 if (tny_list_get_length (header_list) != 1) {
1972 modest_platform_information_banner ((win) ? GTK_WIDGET (win) : NULL,
1973 NULL, _("mcen_ib_select_one_message"));
1974 g_object_unref (header_list);
1978 /* Only reply/forward to one message */
1979 iter = tny_list_create_iterator (header_list);
1980 header = TNY_HEADER (tny_iterator_get_current (iter));
1981 g_object_unref (iter);
1983 /* Retrieve messages */
1984 do_retrieve = (action == ACTION_FORWARD) ||
1985 (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1988 TnyAccount *account = NULL;
1989 TnyFolder *folder = NULL;
1990 gdouble download = TRUE;
1991 guint uncached_msgs = 0;
1993 folder = tny_header_get_folder (header);
1995 goto do_retrieve_frees;
1996 account = tny_folder_get_account (folder);
1998 goto do_retrieve_frees;
2000 uncached_msgs = header_list_count_uncached_msgs (header_list);
2002 if (uncached_msgs > 0) {
2003 /* Allways download if we are online. */
2004 if (!tny_device_is_online (modest_runtime_get_device ())) {
2007 /* If ask for user permission to download the messages */
2008 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2009 ngettext("mcen_nc_get_msg",
2013 /* End if the user does not want to continue */
2014 if (response == GTK_RESPONSE_CANCEL)
2021 rf_helper = create_reply_forward_helper (action, win,
2022 reply_forward_type, header);
2023 if (uncached_msgs > 0) {
2024 modest_platform_connect_and_perform (GTK_WINDOW (win),
2026 reply_forward_performer,
2029 reply_forward_performer (FALSE, NULL, GTK_WINDOW (win),
2030 account, rf_helper);
2035 g_object_unref (account);
2037 g_object_unref (folder);
2039 reply_forward_cb (NULL, header, FALSE, NULL, NULL, rf_helper);
2042 g_object_unref (header_list);
2043 g_object_unref (header);
2048 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
2050 g_return_if_fail (MODEST_IS_WINDOW(win));
2052 reply_forward (ACTION_REPLY, win);
2056 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
2058 g_return_if_fail (MODEST_IS_WINDOW(win));
2060 reply_forward (ACTION_FORWARD, win);
2064 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
2066 g_return_if_fail (MODEST_IS_WINDOW(win));
2068 reply_forward (ACTION_REPLY_TO_ALL, win);
2072 modest_ui_actions_on_next (GtkAction *action,
2073 ModestWindow *window)
2075 if (MODEST_IS_MAIN_WINDOW (window)) {
2076 GtkWidget *header_view;
2078 header_view = modest_main_window_get_child_widget (
2079 MODEST_MAIN_WINDOW(window),
2080 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2084 modest_header_view_select_next (
2085 MODEST_HEADER_VIEW(header_view));
2086 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2087 modest_msg_view_window_select_next_message (
2088 MODEST_MSG_VIEW_WINDOW (window));
2090 g_return_if_reached ();
2095 modest_ui_actions_on_prev (GtkAction *action,
2096 ModestWindow *window)
2098 g_return_if_fail (MODEST_IS_WINDOW(window));
2100 if (MODEST_IS_MAIN_WINDOW (window)) {
2101 GtkWidget *header_view;
2102 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2103 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2107 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
2108 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2109 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
2111 g_return_if_reached ();
2116 modest_ui_actions_on_sort (GtkAction *action,
2117 ModestWindow *window)
2119 GtkWidget *header_view = NULL;
2121 g_return_if_fail (MODEST_IS_WINDOW(window));
2123 if (MODEST_IS_MAIN_WINDOW (window)) {
2124 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2125 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2126 #ifdef MODEST_TOOLKIT_HILDON2
2127 } else if (MODEST_IS_HEADER_WINDOW (window)) {
2128 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
2133 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
2138 /* Show sorting dialog */
2139 modest_utils_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
2143 new_messages_arrived (ModestMailOperation *self,
2144 TnyList *new_headers,
2148 gboolean show_visual_notifications;
2150 source = modest_mail_operation_get_source (self);
2151 show_visual_notifications = (source) ? FALSE : TRUE;
2153 g_object_unref (source);
2155 /* Notify new messages have been downloaded. If the
2156 send&receive was invoked by the user then do not show any
2157 visual notification, only play a sound and activate the LED
2158 (for the Maemo version) */
2159 if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0) {
2161 /* We only notify about really new messages (not seen) we get */
2162 TnyList *actually_new_list;
2163 TnyIterator *iterator;
2164 actually_new_list = TNY_LIST (tny_simple_list_new ());
2165 for (iterator = tny_list_create_iterator (new_headers);
2166 !tny_iterator_is_done (iterator);
2167 tny_iterator_next (iterator)) {
2169 TnyHeaderFlags flags;
2170 header = TNY_HEADER (tny_iterator_get_current (iterator));
2171 flags = tny_header_get_flags (header);
2173 if (!(flags & TNY_HEADER_FLAG_SEEN)) {
2174 tny_list_append (actually_new_list, G_OBJECT (header));
2176 g_object_unref (header);
2178 g_object_unref (iterator);
2180 if (tny_list_get_length (actually_new_list) > 0) {
2181 GList *new_headers_list = NULL;
2183 new_headers_list = modest_utils_create_notification_list_from_header_list (actually_new_list);
2185 /* Send notifications */
2186 if (new_headers_list) {
2187 modest_platform_on_new_headers_received (new_headers_list,
2188 show_visual_notifications);
2190 modest_utils_free_notification_list (new_headers_list);
2193 g_object_unref (actually_new_list);
2199 retrieve_all_messages_cb (GObject *source,
2201 guint retrieve_limit)
2207 window = GTK_WINDOW (source);
2208 msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"),
2209 num_msgs, retrieve_limit);
2211 /* Ask the user if they want to retrieve all the messages */
2213 modest_platform_run_confirmation_dialog_with_buttons (window, msg,
2214 _("mcen_bd_get_all"),
2215 _("mcen_bd_newest_only"));
2216 /* Free and return */
2218 return (response == GTK_RESPONSE_ACCEPT) ? TRUE : FALSE;
2222 TnyAccount *account;
2224 gchar *account_name;
2225 gboolean poke_status;
2226 gboolean interactive;
2227 ModestMailOperation *mail_op;
2231 do_send_receive_performer (gboolean canceled,
2233 GtkWindow *parent_window,
2234 TnyAccount *account,
2237 SendReceiveInfo *info;
2239 info = (SendReceiveInfo *) user_data;
2241 if (err || canceled) {
2242 /* In disk full conditions we could get this error here */
2243 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
2244 (GtkWidget *) parent_window, err,
2247 if (info->mail_op) {
2248 modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (),
2254 /* Set send/receive operation in progress */
2255 if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
2256 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
2259 if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
2260 g_signal_connect (G_OBJECT (info->mail_op), "operation-finished",
2261 G_CALLBACK (on_send_receive_finished),
2264 /* Send & receive. */
2265 modest_mail_operation_update_account (info->mail_op, info->account_name, info->poke_status, info->interactive,
2266 (info->win) ? retrieve_all_messages_cb : NULL,
2267 new_messages_arrived, info->win);
2272 g_object_unref (G_OBJECT (info->mail_op));
2273 if (info->account_name)
2274 g_free (info->account_name);
2276 g_object_unref (info->win);
2278 g_object_unref (info->account);
2279 g_slice_free (SendReceiveInfo, info);
2283 * This function performs the send & receive required actions. The
2284 * window is used to create the mail operation. Typically it should
2285 * always be the main window, but we pass it as argument in order to
2289 modest_ui_actions_do_send_receive (const gchar *account_name,
2290 gboolean force_connection,
2291 gboolean poke_status,
2292 gboolean interactive,
2295 gchar *acc_name = NULL;
2296 SendReceiveInfo *info;
2297 ModestTnyAccountStore *acc_store;
2298 TnyAccount *account;
2300 /* If no account name was provided then get the current account, and if
2301 there is no current account then pick the default one: */
2302 if (!account_name) {
2304 acc_name = g_strdup (modest_window_get_active_account (win));
2306 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
2308 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2312 acc_name = g_strdup (account_name);
2315 acc_store = modest_runtime_get_account_store ();
2316 account = modest_tny_account_store_get_server_account (acc_store, acc_name, TNY_ACCOUNT_TYPE_STORE);
2320 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2324 /* Do not automatically refresh accounts that are flagged as
2325 NO_AUTO_UPDATE. This could be useful for accounts that
2326 handle their own update times */
2328 ModestProtocolType proto = modest_tny_account_get_protocol_type (account);
2329 if (proto != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
2330 const gchar *tag = MODEST_PROTOCOL_REGISTRY_NO_AUTO_UPDATE_PROTOCOLS;
2331 ModestProtocolRegistry *registry = modest_runtime_get_protocol_registry ();
2333 if (modest_protocol_registry_protocol_type_has_tag (registry, proto, tag)) {
2334 g_debug ("%s no auto update allowed for account %s", __FUNCTION__, account_name);
2335 g_object_unref (account);
2342 /* Create the info for the connect and perform */
2343 info = g_slice_new (SendReceiveInfo);
2344 info->account_name = acc_name;
2345 info->win = (win) ? g_object_ref (win) : NULL;
2346 info->poke_status = poke_status;
2347 info->interactive = interactive;
2348 info->account = account;
2349 /* We need to create the operation here, because otherwise it
2350 could happen that the queue emits the queue-empty signal
2351 while we're trying to connect the account */
2352 info->mail_op = modest_mail_operation_new_with_error_handling ((info->win) ? G_OBJECT (info->win) : NULL,
2353 modest_ui_actions_disk_operations_error_handler,
2355 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), info->mail_op);
2357 /* Invoke the connect and perform */
2358 modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
2359 force_connection, info->account,
2360 do_send_receive_performer, info);
2365 modest_ui_actions_do_cancel_send (const gchar *account_name,
2368 TnyTransportAccount *transport_account;
2369 TnySendQueue *send_queue = NULL;
2370 GError *error = NULL;
2372 /* Get transport account */
2374 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2375 (modest_runtime_get_account_store(),
2377 TNY_ACCOUNT_TYPE_TRANSPORT));
2378 if (!transport_account) {
2379 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2384 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account, TRUE));
2385 if (!TNY_IS_SEND_QUEUE(send_queue)) {
2386 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
2387 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2388 "modest: could not find send queue for account\n");
2390 /* Cancel the current send */
2391 tny_account_cancel (TNY_ACCOUNT (transport_account));
2393 /* Suspend all pending messages */
2394 tny_send_queue_cancel (send_queue, TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, &error);
2398 if (transport_account != NULL)
2399 g_object_unref (G_OBJECT (transport_account));
2403 modest_ui_actions_cancel_send_all (ModestWindow *win)
2405 GSList *account_names, *iter;
2407 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2410 iter = account_names;
2412 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
2413 iter = g_slist_next (iter);
2416 modest_account_mgr_free_account_names (account_names);
2417 account_names = NULL;
2421 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
2424 /* Check if accounts exist */
2425 gboolean accounts_exist =
2426 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2428 /* If not, allow the user to create an account before trying to send/receive. */
2429 if (!accounts_exist)
2430 modest_ui_actions_on_accounts (NULL, win);
2432 /* Cancel all sending operaitons */
2433 modest_ui_actions_cancel_send_all (win);
2437 * Refreshes all accounts. This function will be used by automatic
2441 modest_ui_actions_do_send_receive_all (ModestWindow *win,
2442 gboolean force_connection,
2443 gboolean poke_status,
2444 gboolean interactive)
2446 GSList *account_names, *iter;
2448 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2451 iter = account_names;
2453 modest_ui_actions_do_send_receive ((const char*) iter->data,
2455 poke_status, interactive, win);
2456 iter = g_slist_next (iter);
2459 modest_account_mgr_free_account_names (account_names);
2460 account_names = NULL;
2464 * Handler of the click on Send&Receive button in the main toolbar
2467 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
2469 /* Check if accounts exist */
2470 gboolean accounts_exist;
2473 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2475 /* If not, allow the user to create an account before trying to send/receive. */
2476 if (!accounts_exist)
2477 modest_ui_actions_on_accounts (NULL, win);
2479 /* Refresh the current folder. The if is always TRUE it's just an extra check */
2480 if (MODEST_IS_MAIN_WINDOW (win)) {
2481 GtkWidget *folder_view;
2482 TnyFolderStore *folder_store;
2485 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2486 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2490 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2493 g_object_unref (folder_store);
2494 /* Refresh the active account. Force the connection if needed
2495 and poke the status of all folders */
2496 modest_ui_actions_do_send_receive (NULL, TRUE, TRUE, TRUE, win);
2497 #ifdef MODEST_TOOLKIT_HILDON2
2498 } else if (MODEST_IS_ACCOUNTS_WINDOW (win)) {
2499 modest_ui_actions_do_send_receive_all (win, TRUE, TRUE, TRUE);
2502 const gchar *active_account;
2503 active_account = modest_window_get_active_account (MODEST_WINDOW (win));
2505 modest_ui_actions_do_send_receive (active_account, TRUE, TRUE, TRUE, win);
2512 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
2515 GtkWidget *header_view;
2517 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2519 header_view = modest_main_window_get_child_widget (main_window,
2520 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2524 conf = modest_runtime_get_conf ();
2526 /* what is saved/restored is depending on the style; thus; we save with
2527 * old style, then update the style, and restore for this new style
2529 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
2531 if (modest_header_view_get_style
2532 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
2533 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2534 MODEST_HEADER_VIEW_STYLE_TWOLINES);
2536 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2537 MODEST_HEADER_VIEW_STYLE_DETAILS);
2539 modest_widget_memory_restore (conf, G_OBJECT(header_view),
2540 MODEST_CONF_HEADER_VIEW_KEY);
2545 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
2547 ModestMainWindow *main_window)
2549 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2550 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2552 /* in the case the folder is empty, show the empty folder message and focus
2554 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
2555 if (modest_header_view_is_empty (header_view)) {
2556 TnyFolder *folder = modest_header_view_get_folder (header_view);
2557 GtkWidget *folder_view =
2558 modest_main_window_get_child_widget (main_window,
2559 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2560 if (folder != NULL) {
2561 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
2562 g_object_unref (folder);
2564 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
2568 /* If no header has been selected then exit */
2573 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
2574 gtk_widget_grab_focus (GTK_WIDGET(header_view));
2576 /* Update toolbar dimming state */
2577 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2578 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2582 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
2585 ModestWindow *window)
2587 GtkWidget *open_widget;
2588 GtkTreeRowReference *rowref;
2590 g_return_if_fail (MODEST_IS_WINDOW(window));
2591 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2592 g_return_if_fail (TNY_IS_HEADER (header));
2594 if (modest_header_view_count_selected_headers (header_view) > 1) {
2595 /* Don't allow activation if there are more than one message selected */
2596 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
2600 /* we check for low-mem; in that case, show a warning, and don't allow
2601 * activating headers
2603 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
2606 if (MODEST_IS_MAIN_WINDOW (window)) {
2607 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
2608 open_widget = modest_window_get_action_widget (MODEST_WINDOW (window), "/MenuBar/EmailMenu/EmailOpenMenu");
2609 if (!GTK_WIDGET_IS_SENSITIVE (open_widget))
2613 rowref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)), path);
2614 open_msg_from_header (header, rowref, MODEST_WINDOW (window));
2615 gtk_tree_row_reference_free (rowref);
2619 set_active_account_from_tny_account (TnyAccount *account,
2620 ModestWindow *window)
2622 const gchar *server_acc_name = tny_account_get_id (account);
2624 /* We need the TnyAccount provided by the
2625 account store because that is the one that
2626 knows the name of the Modest account */
2627 TnyAccount *modest_server_account =
2628 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
2629 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
2631 if (!modest_server_account) {
2632 g_warning ("%s: could not get tny account\n", __FUNCTION__);
2636 /* Update active account, but only if it's not a pseudo-account */
2637 if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
2638 (!modest_tny_account_is_memory_card_account(modest_server_account))) {
2639 const gchar *modest_acc_name =
2640 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
2641 if (modest_acc_name)
2642 modest_window_set_active_account (window, modest_acc_name);
2645 g_object_unref (modest_server_account);
2650 folder_refreshed_cb (ModestMailOperation *mail_op,
2654 ModestMainWindow *win = NULL;
2655 GtkWidget *folder_view, *header_view;
2656 const GError *error;
2658 g_return_if_fail (TNY_IS_FOLDER (folder));
2660 win = MODEST_MAIN_WINDOW (user_data);
2662 /* Check if the operation failed due to memory low conditions */
2663 error = modest_mail_operation_get_error (mail_op);
2664 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
2665 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
2666 modest_platform_run_information_dialog (GTK_WINDOW (win),
2667 _KR("memr_ib_operation_disabled"),
2673 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2675 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2678 TnyFolderStore *current_folder;
2680 current_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2681 if (current_folder) {
2682 gboolean different = ((TnyFolderStore *) folder != current_folder);
2683 g_object_unref (current_folder);
2689 /* Check if folder is empty and set headers view contents style */
2690 if ((tny_folder_get_all_count (folder) == 0) ||
2691 modest_header_view_is_empty (MODEST_HEADER_VIEW (header_view)))
2692 modest_main_window_set_contents_style (win,
2693 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2697 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2698 TnyFolderStore *folder_store,
2700 ModestMainWindow *main_window)
2702 GtkWidget *header_view;
2704 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2706 header_view = modest_main_window_get_child_widget(main_window,
2707 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2712 if (TNY_IS_ACCOUNT (folder_store)) {
2714 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2716 /* Show account details */
2717 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2720 if (TNY_IS_FOLDER (folder_store) && selected) {
2721 TnyAccount *account;
2723 /* Update the active account */
2724 account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2726 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2727 g_object_unref (account);
2731 /* Set the header style by default, it could
2732 be changed later by the refresh callback to
2734 modest_main_window_set_contents_style (main_window,
2735 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2737 /* Set folder on header view. This function
2738 will call tny_folder_refresh_async so we
2739 pass a callback that will be called when
2740 finished. We use that callback to set the
2741 empty view if there are no messages */
2742 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2743 TNY_FOLDER (folder_store),
2745 MODEST_WINDOW (main_window),
2746 folder_refreshed_cb,
2749 /* Restore configuration. We need to do this
2750 *after* the set_folder because the widget
2751 memory asks the header view about its
2753 modest_widget_memory_restore (modest_runtime_get_conf (),
2754 G_OBJECT(header_view),
2755 MODEST_CONF_HEADER_VIEW_KEY);
2757 /* No need to save the header view
2758 configuration for Maemo because it only
2759 saves the sorting stuff and that it's
2760 already being done by the sort
2761 dialog. Remove it when the GNOME version
2762 has the same behaviour */
2763 #ifdef MODEST_TOOLKIT_GTK
2764 if (modest_main_window_get_contents_style (main_window) ==
2765 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2766 modest_widget_memory_save (modest_runtime_get_conf (),
2767 G_OBJECT (header_view),
2768 MODEST_CONF_HEADER_VIEW_KEY);
2770 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2774 /* Update dimming state */
2775 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2776 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2780 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2787 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2789 online = tny_device_is_online (modest_runtime_get_device());
2792 /* already online -- the item is simply not there... */
2793 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2795 GTK_MESSAGE_WARNING,
2797 _("The %s you selected cannot be found"),
2799 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2800 gtk_dialog_run (GTK_DIALOG(dialog));
2802 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2805 _("mcen_bd_dialog_cancel"),
2806 GTK_RESPONSE_REJECT,
2807 _("mcen_bd_dialog_ok"),
2808 GTK_RESPONSE_ACCEPT,
2810 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2811 "Do you want to get online?"), item);
2812 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
2813 gtk_label_new (txt), FALSE, FALSE, 0);
2814 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2817 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2818 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2819 /* TODO: Comment about why is this commented out: */
2820 /* modest_platform_connect_and_wait (); */
2823 gtk_widget_destroy (dialog);
2827 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2830 /* g_debug ("%s %s", __FUNCTION__, link); */
2835 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2838 modest_platform_activate_uri (link);
2842 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2845 modest_platform_show_uri_popup (link);
2849 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2852 /* we check for low-mem; in that case, show a warning, and don't allow
2853 * viewing attachments
2855 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
2858 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2862 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2863 const gchar *address,
2866 /* g_debug ("%s %s", __FUNCTION__, address); */
2870 on_save_to_drafts_cb (ModestMailOperation *mail_op,
2871 TnyMsg *saved_draft,
2874 ModestMsgEditWindow *edit_window;
2876 /* TODO: in hildon 2 we have to dim and undim the header views while we're saving */
2877 #ifndef MODEST_TOOLKIT_HILDON2
2878 ModestMainWindow *win;
2880 /* FIXME. Make the header view sensitive again. This is a
2881 * temporary hack. See modest_ui_actions_on_save_to_drafts()
2883 win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2884 modest_runtime_get_window_mgr(), FALSE));
2886 GtkWidget *hdrview = modest_main_window_get_child_widget(
2887 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2888 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2892 edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2894 /* Set draft is there was no error */
2895 if (!modest_mail_operation_get_error (mail_op))
2896 modest_msg_edit_window_set_draft (edit_window, saved_draft);
2898 g_object_unref(edit_window);
2902 enough_space_for_message (ModestMsgEditWindow *edit_window,
2905 guint64 available_disk, expected_size;
2910 available_disk = modest_utils_get_available_space (NULL);
2911 modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2912 expected_size = modest_tny_msg_estimate_size (data->plain_body,
2917 /* Double check: disk full condition or message too big */
2918 if (available_disk < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE ||
2919 expected_size > available_disk) {
2920 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
2921 modest_platform_information_banner (NULL, NULL, msg);
2928 * djcb: if we're in low-memory state, we only allow for
2929 * saving messages smaller than
2930 * MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE (see modest-defs.h) this
2931 * should still allow for sending anything critical...
2933 if ((expected_size > MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE) &&
2934 modest_platform_check_memory_low (MODEST_WINDOW(edit_window), TRUE))
2938 * djcb: we also make sure that the attachments are smaller than the max size
2939 * this is for the case where we'd try to forward a message with attachments
2940 * bigger than our max allowed size, or sending an message from drafts which
2941 * somehow got past our checks when attaching.
2943 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
2944 modest_platform_run_information_dialog (
2945 GTK_WINDOW(edit_window),
2946 _("mail_ib_error_attachment_size"),
2955 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2957 TnyTransportAccount *transport_account;
2958 ModestMailOperation *mail_operation;
2960 gchar *account_name;
2961 ModestAccountMgr *account_mgr;
2962 gboolean had_error = FALSE;
2963 ModestMainWindow *win = NULL;
2965 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
2967 data = modest_msg_edit_window_get_msg_data (edit_window);
2970 if (!enough_space_for_message (edit_window, data)) {
2971 modest_msg_edit_window_free_msg_data (edit_window, data);
2975 account_name = g_strdup (data->account_name);
2976 account_mgr = modest_runtime_get_account_mgr();
2978 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2980 account_name = modest_account_mgr_get_default_account (account_mgr);
2981 if (!account_name) {
2982 g_printerr ("modest: no account found\n");
2983 modest_msg_edit_window_free_msg_data (edit_window, data);
2987 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2988 account_name = g_strdup (data->account_name);
2992 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2993 (modest_runtime_get_account_store (),
2995 TNY_ACCOUNT_TYPE_TRANSPORT));
2996 if (!transport_account) {
2997 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2998 g_free (account_name);
2999 modest_msg_edit_window_free_msg_data (edit_window, data);
3003 /* Create the mail operation */
3004 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler,
3006 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3008 modest_mail_operation_save_to_drafts (mail_operation,
3020 data->priority_flags,
3023 on_save_to_drafts_cb,
3024 g_object_ref(edit_window));
3026 #ifdef MODEST_TOOLKIT_HILDON2
3027 /* In hildon2 we always show the information banner on saving to drafts.
3028 * It will be a system information banner in this case.
3030 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3031 modest_platform_information_banner (NULL, NULL, text);
3034 /* Use the main window as the parent of the banner, if the
3035 main window does not exist it won't be shown, if the parent
3036 window exists then it's properly shown. We don't use the
3037 editor window because it could be closed (save to drafts
3038 could happen after closing the window */
3039 win = (ModestMainWindow *)
3040 modest_window_mgr_get_main_window( modest_runtime_get_window_mgr(), FALSE);
3042 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3043 modest_platform_information_banner (GTK_WIDGET (win), NULL, text);
3047 modest_msg_edit_window_set_modified (edit_window, FALSE);
3050 g_free (account_name);
3051 g_object_unref (G_OBJECT (transport_account));
3052 g_object_unref (G_OBJECT (mail_operation));
3054 modest_msg_edit_window_free_msg_data (edit_window, data);
3057 * If the drafts folder is selected then make the header view
3058 * insensitive while the message is being saved to drafts
3059 * (it'll be sensitive again in on_save_to_drafts_cb()). This
3060 * is not very clean but it avoids letting the drafts folder
3061 * in an inconsistent state: the user could edit the message
3062 * being saved and undesirable things would happen.
3063 * In the average case the user won't notice anything at
3064 * all. In the worst case (the user is editing a really big
3065 * file from Drafts) the header view will be insensitive
3066 * during the saving process (10 or 20 seconds, depending on
3067 * the message). Anyway this is just a quick workaround: once
3068 * we find a better solution it should be removed
3069 * See NB#65125 (commend #18) for details.
3071 if (!had_error && win != NULL) {
3072 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
3073 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
3075 TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
3077 if (modest_tny_folder_is_local_folder(folder)) {
3078 TnyFolderType folder_type;
3079 folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
3080 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
3081 GtkWidget *hdrview = modest_main_window_get_child_widget(
3082 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3083 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
3087 if (folder != NULL) g_object_unref(folder);
3094 /* For instance, when clicking the Send toolbar button when editing a message: */
3096 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
3098 TnyTransportAccount *transport_account = NULL;
3099 gboolean had_error = FALSE;
3101 ModestAccountMgr *account_mgr;
3102 gchar *account_name;
3103 ModestMailOperation *mail_operation;
3106 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
3108 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
3111 data = modest_msg_edit_window_get_msg_data (edit_window);
3113 if (data->subject == NULL || data->subject[0] == '\0') {
3114 /* Empty subject -> no send */
3115 modest_msg_edit_window_free_msg_data (edit_window, data);
3119 recipients = g_strconcat (data->to?data->to:"",
3120 data->cc?data->cc:"",
3121 data->bcc?data->bcc:"",
3123 if (recipients == NULL || recipients[0] == '\0') {
3124 /* Empty subject -> no send */
3125 g_free (recipients);
3126 modest_msg_edit_window_free_msg_data (edit_window, data);
3129 g_free (recipients);
3132 if (!enough_space_for_message (edit_window, data)) {
3133 modest_msg_edit_window_free_msg_data (edit_window, data);
3137 account_mgr = modest_runtime_get_account_mgr();
3138 account_name = g_strdup (data->account_name);
3140 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
3143 account_name = modest_account_mgr_get_default_account (account_mgr);
3145 if (!account_name) {
3146 modest_msg_edit_window_free_msg_data (edit_window, data);
3147 /* Run account setup wizard */
3148 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window))) {
3153 /* Get the currently-active transport account for this modest account: */
3154 if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
3156 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3157 (modest_runtime_get_account_store (),
3158 account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
3161 if (!transport_account) {
3162 modest_msg_edit_window_free_msg_data (edit_window, data);
3163 /* Run account setup wizard */
3164 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
3169 /* Create the mail operation */
3170 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler, NULL, NULL);
3171 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3173 modest_mail_operation_send_new_mail (mail_operation,
3187 data->priority_flags);
3189 if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3190 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
3192 if (modest_mail_operation_get_error (mail_operation) != NULL) {
3193 const GError *error = modest_mail_operation_get_error (mail_operation);
3194 if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3195 error->code == MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED) {
3196 g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_operation))->message);
3197 modest_platform_information_banner (NULL, NULL, _CS("sfil_ni_not_enough_memory"));
3203 g_free (account_name);
3204 g_object_unref (G_OBJECT (transport_account));
3205 g_object_unref (G_OBJECT (mail_operation));
3207 modest_msg_edit_window_free_msg_data (edit_window, data);
3210 modest_msg_edit_window_set_sent (edit_window, TRUE);
3212 /* Save settings and close the window: */
3213 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
3220 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
3221 ModestMsgEditWindow *window)
3223 ModestMsgEditFormatState *format_state = NULL;
3225 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3226 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3228 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3231 format_state = modest_msg_edit_window_get_format_state (window);
3232 g_return_if_fail (format_state != NULL);
3234 format_state->bold = gtk_toggle_action_get_active (action);
3235 modest_msg_edit_window_set_format_state (window, format_state);
3236 g_free (format_state);
3241 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
3242 ModestMsgEditWindow *window)
3244 ModestMsgEditFormatState *format_state = NULL;
3246 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3247 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3249 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3252 format_state = modest_msg_edit_window_get_format_state (window);
3253 g_return_if_fail (format_state != NULL);
3255 format_state->italics = gtk_toggle_action_get_active (action);
3256 modest_msg_edit_window_set_format_state (window, format_state);
3257 g_free (format_state);
3262 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
3263 ModestMsgEditWindow *window)
3265 ModestMsgEditFormatState *format_state = NULL;
3267 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3268 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3270 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3273 format_state = modest_msg_edit_window_get_format_state (window);
3274 g_return_if_fail (format_state != NULL);
3276 format_state->bullet = gtk_toggle_action_get_active (action);
3277 modest_msg_edit_window_set_format_state (window, format_state);
3278 g_free (format_state);
3283 modest_ui_actions_on_change_justify (GtkRadioAction *action,
3284 GtkRadioAction *selected,
3285 ModestMsgEditWindow *window)
3287 ModestMsgEditFormatState *format_state = NULL;
3288 GtkJustification value;
3290 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3292 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3295 value = gtk_radio_action_get_current_value (selected);
3297 format_state = modest_msg_edit_window_get_format_state (window);
3298 g_return_if_fail (format_state != NULL);
3300 format_state->justification = value;
3301 modest_msg_edit_window_set_format_state (window, format_state);
3302 g_free (format_state);
3306 modest_ui_actions_on_select_editor_color (GtkAction *action,
3307 ModestMsgEditWindow *window)
3309 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3310 g_return_if_fail (GTK_IS_ACTION (action));
3312 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3315 modest_msg_edit_window_select_color (window);
3319 modest_ui_actions_on_select_editor_background_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_background_color (window);
3332 modest_ui_actions_on_insert_image (GObject *object,
3333 ModestMsgEditWindow *window)
3335 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3338 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3341 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3344 modest_msg_edit_window_insert_image (window);
3348 modest_ui_actions_on_attach_file (GtkAction *action,
3349 ModestMsgEditWindow *window)
3351 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3352 g_return_if_fail (GTK_IS_ACTION (action));
3354 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3357 modest_msg_edit_window_offer_attach_file (window);
3361 modest_ui_actions_on_remove_attachments (GtkAction *action,
3362 ModestMsgEditWindow *window)
3364 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3366 modest_msg_edit_window_remove_attachments (window, NULL);
3370 do_create_folder_cb (ModestMailOperation *mail_op,
3371 TnyFolderStore *parent_folder,
3372 TnyFolder *new_folder,
3375 gchar *suggested_name = (gchar *) user_data;
3376 GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
3377 const GError *error;
3379 error = modest_mail_operation_get_error (mail_op);
3381 gboolean disk_full = FALSE;
3382 TnyAccount *account;
3383 /* Show an error. If there was some problem writing to
3384 disk, show it, otherwise show the generic folder
3385 create error. We do it here and not in an error
3386 handler because the call to do_create_folder will
3387 stop the main loop in a gtk_dialog_run and then,
3388 the message won't be shown until that dialog is
3390 account = modest_mail_operation_get_account (mail_op);
3393 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3394 (GtkWidget *) source_win,
3397 _("mail_in_ui_folder_create_error_memory"));
3398 g_object_unref (account);
3401 /* Show an error and try again if there is no
3402 full memory condition */
3403 modest_platform_information_banner ((GtkWidget *) source_win, NULL,
3404 _("mail_in_ui_folder_create_error"));
3405 do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
3409 /* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
3410 * FIXME: any other? */
3411 GtkWidget *folder_view;
3413 if (MODEST_IS_MAIN_WINDOW(source_win))
3415 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
3416 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3418 folder_view = GTK_WIDGET(g_object_get_data (G_OBJECT (source_win),
3419 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
3421 /* Select the newly created folder. It could happen
3422 that the widget is no longer there (i.e. the window
3423 has been destroyed, so we need to check this */
3425 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
3427 g_object_unref (new_folder);
3429 /* Free. Note that the first time it'll be NULL so noop */
3430 g_free (suggested_name);
3431 g_object_unref (source_win);
3436 TnyFolderStore *parent;
3437 } CreateFolderConnect;
3440 do_create_folder_performer (gboolean canceled,
3442 GtkWindow *parent_window,
3443 TnyAccount *account,
3446 CreateFolderConnect *helper = (CreateFolderConnect *) user_data;
3447 ModestMailOperation *mail_op;
3449 if (canceled || err) {
3450 /* In disk full conditions we could get this error here */
3451 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3452 (GtkWidget *) parent_window, err,
3453 NULL, _("mail_in_ui_folder_create_error_memory"));
3455 /* This happens if we have selected the outbox folder
3457 if (err->code == TNY_SERVICE_ERROR_UNKNOWN &&
3458 TNY_IS_MERGE_FOLDER (helper->parent)) {
3459 /* Show an error and retry */
3460 modest_platform_information_banner ((GtkWidget *) parent_window,
3462 _("mail_in_ui_folder_create_error"));
3464 do_create_folder (parent_window, helper->parent, helper->folder_name);
3470 mail_op = modest_mail_operation_new ((GObject *) parent_window);
3471 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3473 modest_mail_operation_create_folder (mail_op,
3475 (const gchar *) helper->folder_name,
3476 do_create_folder_cb,
3477 g_strdup (helper->folder_name));
3478 g_object_unref (mail_op);
3482 g_object_unref (helper->parent);
3483 if (helper->folder_name)
3484 g_free (helper->folder_name);
3485 g_slice_free (CreateFolderConnect, helper);
3490 do_create_folder (GtkWindow *parent_window,
3491 TnyFolderStore *suggested_parent,
3492 const gchar *suggested_name)
3495 gchar *folder_name = NULL;
3496 TnyFolderStore *parent_folder = NULL;
3498 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
3500 (gchar *) suggested_name,
3504 if (result == GTK_RESPONSE_ACCEPT && parent_folder) {
3505 CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderConnect);
3506 helper->folder_name = g_strdup (folder_name);
3507 helper->parent = g_object_ref (parent_folder);
3509 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
3512 do_create_folder_performer,
3517 g_free (folder_name);
3519 g_object_unref (parent_folder);
3523 modest_ui_actions_create_folder(GtkWidget *parent_window,
3524 GtkWidget *folder_view,
3525 TnyFolderStore *parent_folder)
3527 if (!parent_folder) {
3528 #ifdef MODEST_TOOLKIT_HILDON2
3529 ModestTnyAccountStore *acc_store;
3531 acc_store = modest_runtime_get_account_store ();
3533 parent_folder = (TnyFolderStore *)
3534 modest_tny_account_store_get_local_folders_account (acc_store);
3536 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3540 if (parent_folder) {
3541 do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
3542 g_object_unref (parent_folder);
3547 modest_ui_actions_on_new_folder (GtkAction *action, ModestWindow *window)
3550 g_return_if_fail (MODEST_IS_WINDOW(window));
3552 if (MODEST_IS_MAIN_WINDOW (window)) {
3553 GtkWidget *folder_view;
3555 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3556 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3560 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3561 #ifdef MODEST_TOOLKIT_HILDON2
3562 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3563 GtkWidget *folder_view;
3565 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3566 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3569 g_assert_not_reached ();
3574 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
3577 const GError *error = NULL;
3578 gchar *message = NULL;
3580 TnyAccount *account = modest_mail_operation_get_account (mail_op);
3582 /* Get error message */
3583 error = modest_mail_operation_get_error (mail_op);
3585 g_return_if_reached ();
3587 mem_full = modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
3588 (GError *) error, account);
3590 message = g_strdup_printf (_KR("cerm_device_memory_full"), "");
3591 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3592 error->code == MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS) {
3593 message = _CS("ckdg_ib_folder_already_exists");
3594 } else if (error->domain == TNY_ERROR_DOMAIN &&
3595 error->code == TNY_SERVICE_ERROR_STATE) {
3596 /* This means that the folder is already in use (a
3597 message is opened for example */
3598 message = _("emev_ni_internal_error");
3600 message = _CS("ckdg_ib_unable_to_rename");
3603 /* We don't set a parent for the dialog because the dialog
3604 will be destroyed so the banner won't appear */
3605 modest_platform_information_banner (NULL, NULL, message);
3608 g_object_unref (account);
3614 TnyFolderStore *folder;
3619 on_rename_folder_cb (ModestMailOperation *mail_op,
3620 TnyFolder *new_folder,
3623 ModestFolderView *folder_view;
3625 /* If the window was closed when renaming a folder, or if
3626 * it's not a main window this will happen */
3627 if (!MODEST_IS_FOLDER_VIEW (user_data))
3630 folder_view = MODEST_FOLDER_VIEW (user_data);
3631 /* Note that if the rename fails new_folder will be NULL */
3633 modest_folder_view_select_folder (folder_view, new_folder, FALSE);
3635 modest_folder_view_select_first_inbox_or_local (folder_view);
3637 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
3641 on_rename_folder_performer (gboolean canceled,
3643 GtkWindow *parent_window,
3644 TnyAccount *account,
3647 ModestMailOperation *mail_op = NULL;
3648 GtkTreeSelection *sel = NULL;
3649 GtkWidget *folder_view = NULL;
3650 RenameFolderInfo *data = (RenameFolderInfo*)user_data;
3652 if (canceled || err) {
3653 /* In disk full conditions we could get this error here */
3654 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3655 (GtkWidget *) parent_window, err,
3660 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3661 modest_ui_actions_rename_folder_error_handler,
3662 parent_window, NULL);
3664 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3667 if (MODEST_IS_MAIN_WINDOW(parent_window)) {
3669 folder_view = modest_main_window_get_child_widget (
3670 MODEST_MAIN_WINDOW (parent_window),
3671 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3673 #ifdef MODEST_TOOLKIT_HILDON2
3674 else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3675 ModestFolderWindow *folder_window = (ModestFolderWindow *) parent_window;
3676 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (folder_window));
3680 /* Clear the folders view */
3681 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3682 gtk_tree_selection_unselect_all (sel);
3684 /* Actually rename the folder */
3685 modest_mail_operation_rename_folder (mail_op,
3686 TNY_FOLDER (data->folder),
3687 (const gchar *) (data->new_name),
3688 on_rename_folder_cb,
3690 g_object_unref (mail_op);
3693 g_object_unref (data->folder);
3694 g_free (data->new_name);
3699 modest_ui_actions_on_rename_folder (GtkAction *action,
3700 ModestWindow *window)
3702 modest_ui_actions_on_edit_mode_rename_folder (window);
3706 modest_ui_actions_on_edit_mode_rename_folder (ModestWindow *window)
3708 TnyFolderStore *folder;
3709 GtkWidget *folder_view;
3710 gboolean do_rename = TRUE;
3712 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3714 if (MODEST_IS_MAIN_WINDOW (window)) {
3715 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3716 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3720 #ifdef MODEST_TOOLKIT_HILDON2
3721 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3722 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3728 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3733 if (TNY_IS_FOLDER (folder)) {
3734 gchar *folder_name = NULL;
3736 const gchar *current_name;
3737 TnyFolderStore *parent;
3739 current_name = tny_folder_get_name (TNY_FOLDER (folder));
3740 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
3741 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (window),
3742 parent, current_name,
3744 g_object_unref (parent);
3746 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
3749 RenameFolderInfo *rename_folder_data = g_new0 (RenameFolderInfo, 1);
3750 rename_folder_data->folder = g_object_ref (folder);
3751 rename_folder_data->new_name = folder_name;
3752 modest_platform_connect_if_remote_and_perform (GTK_WINDOW(window), TRUE,
3753 folder, on_rename_folder_performer, rename_folder_data);
3756 g_object_unref (folder);
3761 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
3764 GObject *win = modest_mail_operation_get_source (mail_op);
3766 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
3767 _("mail_in_ui_folder_delete_error"),
3769 g_object_unref (win);
3773 TnyFolderStore *folder;
3774 gboolean move_to_trash;
3778 on_delete_folder_cb (gboolean canceled,
3780 GtkWindow *parent_window,
3781 TnyAccount *account,
3784 DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
3785 GtkWidget *folder_view;
3786 ModestMailOperation *mail_op;
3787 GtkTreeSelection *sel;
3789 if (!MODEST_IS_WINDOW(parent_window) || canceled || (err!=NULL)) {
3790 /* Note that the connection process can fail due to
3791 memory low conditions as it can not successfully
3792 store the summary */
3793 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3794 (GtkWidget*) parent_window, err,
3796 g_debug ("Error connecting when trying to delete a folder");
3797 g_object_unref (G_OBJECT (info->folder));
3802 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
3803 folder_view = modest_main_window_get_child_widget (
3804 MODEST_MAIN_WINDOW (parent_window),
3805 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3806 #ifdef MODEST_TOOLKIT_HILDON2
3807 } else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3808 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (parent_window)));
3811 g_object_unref (G_OBJECT (info->folder));
3816 /* Unselect the folder before deleting it to free the headers */
3817 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3818 gtk_tree_selection_unselect_all (sel);
3820 /* Create the mail operation */
3822 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3823 modest_ui_actions_delete_folder_error_handler,
3826 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3828 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
3830 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
3832 g_object_unref (G_OBJECT (mail_op));
3833 g_object_unref (G_OBJECT (info->folder));
3838 delete_folder (ModestWindow *window, gboolean move_to_trash)
3840 TnyFolderStore *folder;
3841 GtkWidget *folder_view;
3845 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3847 if (MODEST_IS_MAIN_WINDOW (window)) {
3849 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3850 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3851 #ifdef MODEST_TOOLKIT_HILDON2
3852 } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3853 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3861 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3866 /* Show an error if it's an account */
3867 if (!TNY_IS_FOLDER (folder)) {
3868 modest_platform_run_information_dialog (GTK_WINDOW (window),
3869 _("mail_in_ui_folder_delete_error"),
3871 g_object_unref (G_OBJECT (folder));
3876 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
3877 tny_folder_get_name (TNY_FOLDER (folder)));
3878 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
3879 (const gchar *) message);
3882 if (response == GTK_RESPONSE_OK) {
3883 DeleteFolderInfo *info;
3884 info = g_new0(DeleteFolderInfo, 1);
3885 info->folder = folder;
3886 info->move_to_trash = move_to_trash;
3887 g_object_ref (G_OBJECT (info->folder));
3888 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder));
3889 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (window),
3891 TNY_FOLDER_STORE (account),
3892 on_delete_folder_cb, info);
3893 g_object_unref (account);
3898 g_object_unref (G_OBJECT (folder));
3902 modest_ui_actions_on_delete_folder (GtkAction *action,
3903 ModestWindow *window)
3905 modest_ui_actions_on_edit_mode_delete_folder (window);
3909 modest_ui_actions_on_edit_mode_delete_folder (ModestWindow *window)
3911 g_return_val_if_fail (MODEST_IS_WINDOW(window), TRUE);
3913 return delete_folder (window, FALSE);
3917 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
3919 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3921 delete_folder (MODEST_WINDOW (main_window), TRUE);
3925 typedef struct _PasswordDialogFields {
3926 GtkWidget *username;
3927 GtkWidget *password;
3929 } PasswordDialogFields;
3932 password_dialog_check_field (GtkEditable *editable,
3933 PasswordDialogFields *fields)
3936 gboolean any_value_empty = FALSE;
3938 #ifdef MODEST_TOOLKIT_HILDON2
3939 value = hildon_entry_get_text (HILDON_ENTRY (fields->username));
3941 value = gtk_entry_get_text (GTK_ENTRY (fields->username));
3943 if ((value == NULL) || value[0] == '\0') {
3944 any_value_empty = TRUE;
3946 #ifdef MODEST_TOOLKIT_HILDON2
3947 value = hildon_entry_get_text (HILDON_ENTRY (fields->password));
3949 value = gtk_entry_get_text (GTK_ENTRY (fields->password));
3951 if ((value == NULL) || value[0] == '\0') {
3952 any_value_empty = TRUE;
3954 gtk_dialog_set_response_sensitive (GTK_DIALOG (fields->dialog), GTK_RESPONSE_ACCEPT, !any_value_empty);
3958 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
3959 const gchar* server_account_name,
3964 ModestMainWindow *main_window)
3966 g_return_if_fail(server_account_name);
3967 gboolean completed = FALSE;
3968 PasswordDialogFields *fields = NULL;
3970 /* Initalize output parameters: */
3977 #ifndef MODEST_TOOLKIT_GTK
3978 /* Maemo uses a different (awkward) button order,
3979 * It should probably just use gtk_alternative_dialog_button_order ().
3981 #ifdef MODEST_TOOLKIT_HILDON2
3983 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3986 _HL("wdgt_bd_done"),
3987 GTK_RESPONSE_ACCEPT,
3989 gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
3990 HILDON_MARGIN_DOUBLE);
3993 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3996 _("mcen_bd_dialog_ok"),
3997 GTK_RESPONSE_ACCEPT,
3998 _("mcen_bd_dialog_cancel"),
3999 GTK_RESPONSE_REJECT,
4001 #endif /* MODEST_TOOLKIT_HILDON2 */
4004 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4008 GTK_RESPONSE_REJECT,
4010 GTK_RESPONSE_ACCEPT,
4012 #endif /* MODEST_TOOLKIT_GTK */
4014 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog), NULL);
4016 gchar *server_name = modest_account_mgr_get_server_account_hostname (
4017 modest_runtime_get_account_mgr(), server_account_name);
4018 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
4019 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
4022 gtk_widget_destroy (dialog);
4026 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
4027 GtkWidget *label = gtk_label_new (txt);
4028 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4030 g_free (server_name);
4031 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
4036 gchar *initial_username = modest_account_mgr_get_server_account_username (
4037 modest_runtime_get_account_mgr(), server_account_name);
4039 #ifdef MODEST_TOOLKIT_HILDON2
4040 GtkWidget *entry_username = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4041 if (initial_username)
4042 hildon_entry_set_text (HILDON_ENTRY (entry_username), initial_username);
4044 GtkWidget *entry_username = gtk_entry_new ();
4045 if (initial_username)
4046 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
4048 /* Dim this if a connection has ever succeeded with this username,
4049 * as per the UI spec: */
4050 /* const gboolean username_known = */
4051 /* modest_account_mgr_get_server_account_username_has_succeeded( */
4052 /* modest_runtime_get_account_mgr(), server_account_name); */
4053 /* gtk_widget_set_sensitive (entry_username, !username_known); */
4055 /* We drop the username sensitive code and disallow changing it here
4056 * as tinymail does not support really changing the username in the callback
4058 gtk_widget_set_sensitive (entry_username, FALSE);
4060 #ifndef MODEST_TOOLKIT_GTK
4061 /* Auto-capitalization is the default, so let's turn it off: */
4062 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
4064 /* Create a size group to be used by all captions.
4065 * Note that HildonCaption does not create a default size group if we do not specify one.
4066 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
4067 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
4069 #ifdef MODEST_TOOLKIT_HILDON2
4070 GtkWidget *caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4071 _("mail_fi_username"), FALSE,
4074 GtkWidget *caption = hildon_caption_new (sizegroup,
4075 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
4077 gtk_widget_show (entry_username);
4078 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4079 FALSE, FALSE, MODEST_MARGIN_HALF);
4080 gtk_widget_show (caption);
4082 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
4084 #endif /* !MODEST_TOOLKIT_GTK */
4087 #ifdef MODEST_TOOLKIT_HILDON2
4088 GtkWidget *entry_password = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
4090 GtkWidget *entry_password = gtk_entry_new ();
4092 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
4093 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
4095 #ifndef MODEST_TOOLKIT_GTK
4096 /* Auto-capitalization is the default, so let's turn it off: */
4097 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
4098 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
4100 #ifdef MODEST_TOOLKIT_HILDON2
4101 caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4102 _("mail_fi_password"), FALSE,
4105 caption = hildon_caption_new (sizegroup,
4106 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
4108 gtk_widget_show (entry_password);
4109 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4110 FALSE, FALSE, MODEST_MARGIN_HALF);
4111 gtk_widget_show (caption);
4112 g_object_unref (sizegroup);
4114 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
4116 #endif /* !MODEST_TOOLKIT_GTK */
4118 if (initial_username != NULL)
4119 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
4121 /* This is not in the Maemo UI spec:
4122 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
4123 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
4127 fields = g_slice_new0 (PasswordDialogFields);
4128 fields->username = entry_username;
4129 fields->password = entry_password;
4130 fields->dialog = dialog;
4132 g_signal_connect (entry_username, "changed", G_CALLBACK (password_dialog_check_field), fields);
4133 g_signal_connect (entry_password, "changed", G_CALLBACK (password_dialog_check_field), fields);
4134 password_dialog_check_field (NULL, fields);
4136 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
4138 while (!completed) {
4140 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
4142 #ifdef MODEST_TOOLKIT_HILDON2
4143 *username = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_username)));
4145 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
4148 /* Note that an empty field becomes the "" string */
4149 if (*username && strlen (*username) > 0) {
4150 modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
4151 server_account_name,
4155 const gboolean username_was_changed =
4156 (strcmp (*username, initial_username) != 0);
4157 if (username_was_changed) {
4158 g_warning ("%s: tinymail does not yet support changing the "
4159 "username in the get_password() callback.\n", __FUNCTION__);
4165 modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
4166 _("mcen_ib_username_pw_incorrect"));
4172 #ifdef MODEST_TOOLKIT_HILDON2
4173 *password = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_password)));
4175 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
4178 /* We do not save the password in the configuration,
4179 * because this function is only called for passwords that should
4180 * not be remembered:
4181 modest_server_account_set_password (
4182 modest_runtime_get_account_mgr(), server_account_name,
4189 #ifndef MODEST_TOOLKIT_HILDON2
4190 /* Set parent to NULL or the banner will disappear with its parent dialog */
4191 modest_platform_information_banner(NULL, NULL, _("mail_ib_login_cancelled"));
4203 /* This is not in the Maemo UI spec:
4204 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
4210 g_free (initial_username);
4211 gtk_widget_destroy (dialog);
4212 g_slice_free (PasswordDialogFields, fields);
4214 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
4218 modest_ui_actions_on_cut (GtkAction *action,
4219 ModestWindow *window)
4221 GtkWidget *focused_widget;
4222 GtkClipboard *clipboard;
4224 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4225 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4226 if (GTK_IS_EDITABLE (focused_widget)) {
4227 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
4228 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4229 gtk_clipboard_store (clipboard);
4230 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4231 GtkTextBuffer *buffer;
4233 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4234 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4235 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
4236 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4237 gtk_clipboard_store (clipboard);
4239 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4240 TnyList *header_list = modest_header_view_get_selected_headers (
4241 MODEST_HEADER_VIEW (focused_widget));
4242 gboolean continue_download = FALSE;
4243 gint num_of_unc_msgs;
4245 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4247 if (num_of_unc_msgs) {
4248 TnyAccount *account = get_account_from_header_list (header_list);
4250 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4251 g_object_unref (account);
4255 if (num_of_unc_msgs == 0 || continue_download) {
4256 /* modest_platform_information_banner (
4257 NULL, NULL, _CS("mcen_ib_getting_items"));*/
4258 modest_header_view_cut_selection (
4259 MODEST_HEADER_VIEW (focused_widget));
4262 g_object_unref (header_list);
4263 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4264 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
4269 modest_ui_actions_on_copy (GtkAction *action,
4270 ModestWindow *window)
4272 GtkClipboard *clipboard;
4273 GtkWidget *focused_widget;
4274 gboolean copied = TRUE;
4276 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4277 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4279 if (GTK_IS_LABEL (focused_widget)) {
4281 selection = modest_text_utils_label_get_selection (GTK_LABEL (focused_widget));
4282 gtk_clipboard_set_text (clipboard, selection, -1);
4284 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4285 gtk_clipboard_store (clipboard);
4286 } else if (GTK_IS_EDITABLE (focused_widget)) {
4287 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
4288 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4289 gtk_clipboard_store (clipboard);
4290 } else if (GTK_IS_HTML (focused_widget)) {
4293 sel = gtk_html_get_selection_html (GTK_HTML (focused_widget), &len);
4294 if ((sel == NULL) || (sel[0] == '\0')) {
4297 gtk_html_copy (GTK_HTML (focused_widget));
4298 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4299 gtk_clipboard_store (clipboard);
4301 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4302 GtkTextBuffer *buffer;
4303 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4304 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4305 gtk_text_buffer_copy_clipboard (buffer, clipboard);
4306 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4307 gtk_clipboard_store (clipboard);
4309 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4310 TnyList *header_list = modest_header_view_get_selected_headers (
4311 MODEST_HEADER_VIEW (focused_widget));
4312 gboolean continue_download = FALSE;
4313 gint num_of_unc_msgs;
4315 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4317 if (num_of_unc_msgs) {
4318 TnyAccount *account = get_account_from_header_list (header_list);
4320 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4321 g_object_unref (account);
4325 if (num_of_unc_msgs == 0 || continue_download) {
4326 modest_platform_information_banner (
4327 NULL, NULL, _CS("mcen_ib_getting_items"));
4328 modest_header_view_copy_selection (
4329 MODEST_HEADER_VIEW (focused_widget));
4333 g_object_unref (header_list);
4335 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4336 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
4339 /* Show information banner if there was a copy to clipboard */
4341 modest_platform_information_banner (
4342 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
4346 modest_ui_actions_on_undo (GtkAction *action,
4347 ModestWindow *window)
4349 ModestEmailClipboard *clipboard = NULL;
4351 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4352 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
4353 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4354 /* Clear clipboard source */
4355 clipboard = modest_runtime_get_email_clipboard ();
4356 modest_email_clipboard_clear (clipboard);
4359 g_return_if_reached ();
4364 modest_ui_actions_on_redo (GtkAction *action,
4365 ModestWindow *window)
4367 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4368 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
4371 g_return_if_reached ();
4377 destroy_information_note (ModestMailOperation *mail_op,
4380 /* destroy information note */
4381 gtk_widget_destroy (GTK_WIDGET(user_data));
4385 destroy_folder_information_note (ModestMailOperation *mail_op,
4386 TnyFolder *new_folder,
4389 /* destroy information note */
4390 gtk_widget_destroy (GTK_WIDGET(user_data));
4395 paste_as_attachment_free (gpointer data)
4397 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
4399 if (helper->banner) {
4400 gtk_widget_destroy (helper->banner);
4401 g_object_unref (helper->banner);
4407 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
4412 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
4413 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
4418 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
4423 modest_ui_actions_on_paste (GtkAction *action,
4424 ModestWindow *window)
4426 GtkWidget *focused_widget = NULL;
4427 GtkWidget *inf_note = NULL;
4428 ModestMailOperation *mail_op = NULL;
4430 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4431 if (GTK_IS_EDITABLE (focused_widget)) {
4432 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
4433 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4434 ModestEmailClipboard *e_clipboard = NULL;
4435 e_clipboard = modest_runtime_get_email_clipboard ();
4436 if (modest_email_clipboard_cleared (e_clipboard)) {
4437 GtkTextBuffer *buffer;
4438 GtkClipboard *clipboard;
4440 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4441 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4442 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
4443 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4444 ModestMailOperation *mail_op;
4445 TnyFolder *src_folder = NULL;
4446 TnyList *data = NULL;
4448 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
4449 helper->window = MODEST_MSG_EDIT_WINDOW (window);
4450 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4451 _CS("ckct_nw_pasting"));
4452 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
4453 mail_op = modest_mail_operation_new (G_OBJECT (window));
4454 if (helper->banner != NULL) {
4455 g_object_ref (G_OBJECT (helper->banner));
4456 gtk_widget_show (GTK_WIDGET (helper->banner));
4460 modest_mail_operation_get_msgs_full (mail_op,
4462 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
4464 paste_as_attachment_free);
4468 g_object_unref (data);
4470 g_object_unref (src_folder);
4473 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4474 ModestEmailClipboard *clipboard = NULL;
4475 TnyFolder *src_folder = NULL;
4476 TnyFolderStore *folder_store = NULL;
4477 TnyList *data = NULL;
4478 gboolean delete = FALSE;
4480 /* Check clipboard source */
4481 clipboard = modest_runtime_get_email_clipboard ();
4482 if (modest_email_clipboard_cleared (clipboard))
4485 /* Get elements to paste */
4486 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
4488 /* Create a new mail operation */
4489 mail_op = modest_mail_operation_new (G_OBJECT(window));
4491 /* Get destination folder */
4492 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
4494 /* transfer messages */
4498 /* Ask for user confirmation */
4500 modest_ui_actions_msgs_move_to_confirmation (window,
4501 TNY_FOLDER (folder_store),
4505 if (response == GTK_RESPONSE_OK) {
4506 /* Launch notification */
4507 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4508 _CS("ckct_nw_pasting"));
4509 if (inf_note != NULL) {
4510 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4511 gtk_widget_show (GTK_WIDGET(inf_note));
4514 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4515 modest_mail_operation_xfer_msgs (mail_op,
4517 TNY_FOLDER (folder_store),
4519 destroy_information_note,
4522 g_object_unref (mail_op);
4525 } else if (src_folder != NULL) {
4526 /* Launch notification */
4527 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4528 _CS("ckct_nw_pasting"));
4529 if (inf_note != NULL) {
4530 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4531 gtk_widget_show (GTK_WIDGET(inf_note));
4534 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4535 modest_mail_operation_xfer_folder (mail_op,
4539 destroy_folder_information_note,
4545 g_object_unref (data);
4546 if (src_folder != NULL)
4547 g_object_unref (src_folder);
4548 if (folder_store != NULL)
4549 g_object_unref (folder_store);
4555 modest_ui_actions_on_select_all (GtkAction *action,
4556 ModestWindow *window)
4558 GtkWidget *focused_widget;
4560 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4561 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
4562 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
4563 } else if (GTK_IS_LABEL (focused_widget)) {
4564 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
4565 } else if (GTK_IS_EDITABLE (focused_widget)) {
4566 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
4567 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4568 GtkTextBuffer *buffer;
4569 GtkTextIter start, end;
4571 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4572 gtk_text_buffer_get_start_iter (buffer, &start);
4573 gtk_text_buffer_get_end_iter (buffer, &end);
4574 gtk_text_buffer_select_range (buffer, &start, &end);
4575 } else if (GTK_IS_HTML (focused_widget)) {
4576 gtk_html_select_all (GTK_HTML (focused_widget));
4577 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4578 GtkWidget *header_view = focused_widget;
4579 GtkTreeSelection *selection = NULL;
4581 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
4582 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
4583 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4586 /* Disable window dimming management */
4587 modest_window_disable_dimming (MODEST_WINDOW(window));
4589 /* Select all messages */
4590 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
4591 gtk_tree_selection_select_all (selection);
4593 /* Set focuse on header view */
4594 gtk_widget_grab_focus (header_view);
4596 /* Enable window dimming management */
4597 modest_window_enable_dimming (MODEST_WINDOW(window));
4598 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
4599 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
4605 modest_ui_actions_on_mark_as_read (GtkAction *action,
4606 ModestWindow *window)
4608 g_return_if_fail (MODEST_IS_WINDOW(window));
4610 /* Mark each header as read */
4611 do_headers_action (window, headers_action_mark_as_read, NULL);
4615 modest_ui_actions_on_mark_as_unread (GtkAction *action,
4616 ModestWindow *window)
4618 g_return_if_fail (MODEST_IS_WINDOW(window));
4620 /* Mark each header as read */
4621 do_headers_action (window, headers_action_mark_as_unread, NULL);
4625 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
4626 GtkRadioAction *selected,
4627 ModestWindow *window)
4631 value = gtk_radio_action_get_current_value (selected);
4632 if (MODEST_IS_WINDOW (window)) {
4633 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
4638 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
4639 GtkRadioAction *selected,
4640 ModestWindow *window)
4642 TnyHeaderFlags flags;
4643 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4645 flags = gtk_radio_action_get_current_value (selected);
4646 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
4650 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
4651 GtkRadioAction *selected,
4652 ModestWindow *window)
4656 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4658 file_format = gtk_radio_action_get_current_value (selected);
4659 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
4664 modest_ui_actions_on_zoom_plus (GtkAction *action,
4665 ModestWindow *window)
4667 g_return_if_fail (MODEST_IS_WINDOW (window));
4669 modest_window_zoom_plus (MODEST_WINDOW (window));
4673 modest_ui_actions_on_zoom_minus (GtkAction *action,
4674 ModestWindow *window)
4676 g_return_if_fail (MODEST_IS_WINDOW (window));
4678 modest_window_zoom_minus (MODEST_WINDOW (window));
4682 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
4683 ModestWindow *window)
4685 ModestWindowMgr *mgr;
4686 gboolean fullscreen, active;
4687 g_return_if_fail (MODEST_IS_WINDOW (window));
4689 mgr = modest_runtime_get_window_mgr ();
4691 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
4692 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4694 if (active != fullscreen) {
4695 modest_window_mgr_set_fullscreen_mode (mgr, active);
4696 #ifndef MODEST_TOOLKIT_HILDON2
4697 gtk_window_present (GTK_WINDOW (window));
4703 modest_ui_actions_on_change_fullscreen (GtkAction *action,
4704 ModestWindow *window)
4706 ModestWindowMgr *mgr;
4707 gboolean fullscreen;
4709 g_return_if_fail (MODEST_IS_WINDOW (window));
4711 mgr = modest_runtime_get_window_mgr ();
4712 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4713 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
4715 #ifndef MODEST_TOOLKIT_HILDON2
4716 gtk_window_present (GTK_WINDOW (window));
4721 * Used by modest_ui_actions_on_details to call do_headers_action
4724 headers_action_show_details (TnyHeader *header,
4725 ModestWindow *window,
4729 gboolean async_retrieval;
4732 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4733 async_retrieval = TRUE;
4734 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (window));
4736 async_retrieval = FALSE;
4738 modest_platform_run_header_details_dialog (GTK_WINDOW (window), header, async_retrieval, msg);
4740 g_object_unref (msg);
4744 * Show the header details in a ModestDetailsDialog widget
4747 modest_ui_actions_on_details (GtkAction *action,
4750 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4754 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
4758 header = tny_msg_get_header (msg);
4760 headers_action_show_details (header, win, NULL);
4761 g_object_unref (header);
4763 g_object_unref (msg);
4765 } else if (MODEST_IS_MAIN_WINDOW (win)) {
4766 GtkWidget *folder_view, *header_view;
4768 /* Check which widget has the focus */
4769 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4770 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4771 if (gtk_widget_is_focus (folder_view)) {
4772 TnyFolderStore *folder_store
4773 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4774 if (!folder_store) {
4775 g_warning ("%s: No item was selected.\n", __FUNCTION__);
4778 /* Show only when it's a folder */
4779 /* This function should not be called for account items,
4780 * because we dim the menu item for them. */
4781 if (TNY_IS_FOLDER (folder_store)) {
4782 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4783 TNY_FOLDER (folder_store));
4786 g_object_unref (folder_store);
4789 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4790 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4791 /* Show details of each header */
4792 do_headers_action (win, headers_action_show_details, header_view);
4794 #ifdef MODEST_TOOLKIT_HILDON2
4795 } else if (MODEST_IS_HEADER_WINDOW (win)) {
4797 GtkWidget *header_view;
4799 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
4800 folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
4802 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4804 g_object_unref (folder);
4811 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
4812 ModestMsgEditWindow *window)
4814 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4816 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
4820 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
4821 ModestMsgEditWindow *window)
4823 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4825 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
4829 modest_ui_actions_toggle_folders_view (GtkAction *action,
4830 ModestMainWindow *main_window)
4832 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
4834 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
4835 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
4837 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
4841 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
4842 ModestWindow *window)
4844 gboolean active, fullscreen = FALSE;
4845 ModestWindowMgr *mgr;
4847 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
4849 /* Check if we want to toggle the toolbar view in fullscreen
4851 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
4852 "ViewShowToolbarFullScreen")) {
4856 /* Toggle toolbar */
4857 mgr = modest_runtime_get_window_mgr ();
4858 modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
4862 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
4863 ModestMsgEditWindow *window)
4865 modest_msg_edit_window_select_font (window);
4870 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
4871 const gchar *display_name,
4874 /* don't update the display name if it was already set;
4875 * updating the display name apparently is expensive */
4876 const gchar* old_name = gtk_window_get_title (window);
4878 if (display_name == NULL)
4881 if (old_name && display_name && strcmp (old_name, display_name) == 0)
4882 return; /* don't do anything */
4884 /* This is usually used to change the title of the main window, which
4885 * is the one that holds the folder view. Note that this change can
4886 * happen even when the widget doesn't have the focus. */
4887 gtk_window_set_title (window, display_name);
4892 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
4894 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4895 modest_msg_edit_window_select_contacts (window);
4899 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
4901 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4902 modest_msg_edit_window_check_names (window, FALSE);
4905 #ifndef MODEST_TOOLKIT_HILDON2
4907 * This function is used to track changes in the selection of the
4908 * folder view that is inside the "move to" dialog to enable/disable
4909 * the OK button because we do not want the user to select a disallowed
4910 * destination for a folder.
4911 * The user also not desired to be able to use NEW button on items where
4912 * folder creation is not possibel.
4915 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
4916 TnyFolderStore *folder_store,
4920 GtkWidget *dialog = NULL;
4921 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
4922 gboolean moving_folder = FALSE;
4923 gboolean is_local_account = TRUE;
4924 GtkWidget *folder_view = NULL;
4925 ModestTnyFolderRules rules;
4927 g_return_if_fail (MODEST_IS_FOLDER_VIEW(self));
4932 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
4936 /* check if folder_store is an remote account */
4937 if (TNY_IS_ACCOUNT (folder_store)) {
4938 TnyAccount *local_account = NULL;
4939 TnyAccount *mmc_account = NULL;
4940 ModestTnyAccountStore *account_store = NULL;
4942 account_store = modest_runtime_get_account_store ();
4943 local_account = modest_tny_account_store_get_local_folders_account (account_store);
4944 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
4946 if ((gpointer) local_account != (gpointer) folder_store &&
4947 (gpointer) mmc_account != (gpointer) folder_store) {
4948 ModestProtocolType proto;
4949 proto = modest_tny_account_get_protocol_type (TNY_ACCOUNT (folder_store));
4950 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
4951 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
4953 is_local_account = FALSE;
4954 /* New button should be dimmed on remote
4956 new_sensitive = (modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
4958 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS));
4960 g_object_unref (local_account);
4962 /* It could not exist */
4964 g_object_unref (mmc_account);
4967 /* Check the target folder rules */
4968 if (TNY_IS_FOLDER (folder_store)) {
4969 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
4970 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
4971 ok_sensitive = FALSE;
4972 new_sensitive = FALSE;
4977 /* Check if we're moving a folder */
4978 if (MODEST_IS_MAIN_WINDOW (user_data)) {
4979 /* Get the widgets */
4980 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
4981 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4982 if (gtk_widget_is_focus (folder_view))
4983 moving_folder = TRUE;
4986 if (moving_folder) {
4987 TnyFolderStore *moved_folder = NULL, *parent = NULL;
4989 /* Get the folder to move */
4990 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4992 /* Check that we're not moving to the same folder */
4993 if (TNY_IS_FOLDER (moved_folder)) {
4994 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
4995 if (parent == folder_store)
4996 ok_sensitive = FALSE;
4997 g_object_unref (parent);
5000 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
5001 /* Do not allow to move to an account unless it's the
5002 local folders account */
5003 if (!is_local_account)
5004 ok_sensitive = FALSE;
5007 if (ok_sensitive && (moved_folder == folder_store)) {
5008 /* Do not allow to move to itself */
5009 ok_sensitive = FALSE;
5011 g_object_unref (moved_folder);
5013 TnyFolder *src_folder = NULL;
5015 /* Moving a message */
5016 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
5018 TnyHeader *header = NULL;
5019 header = modest_msg_view_window_get_header
5020 (MODEST_MSG_VIEW_WINDOW (user_data));
5021 if (!TNY_IS_HEADER(header))
5022 g_warning ("%s: could not get source header", __FUNCTION__);
5024 src_folder = tny_header_get_folder (header);
5027 g_object_unref (header);
5030 TNY_FOLDER (modest_folder_view_get_selected
5031 (MODEST_FOLDER_VIEW (folder_view)));
5034 if (TNY_IS_FOLDER(src_folder)) {
5035 /* Do not allow to move the msg to the same folder */
5036 /* Do not allow to move the msg to an account */
5037 if ((gpointer) src_folder == (gpointer) folder_store ||
5038 TNY_IS_ACCOUNT (folder_store))
5039 ok_sensitive = FALSE;
5040 g_object_unref (src_folder);
5042 g_warning ("%s: could not get source folder", __FUNCTION__);
5046 /* Set sensitivity of the OK and NEW button */
5047 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, ok_sensitive);
5048 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_GTK_RESPONSE_NEW_FOLDER, new_sensitive);
5053 on_move_to_dialog_response (GtkDialog *dialog,
5057 GtkWidget *parent_win;
5058 MoveToInfo *helper = NULL;
5059 ModestFolderView *folder_view;
5060 gboolean unset_edit_mode = FALSE;
5062 helper = (MoveToInfo *) user_data;
5064 parent_win = (GtkWidget *) helper->win;
5065 folder_view = MODEST_FOLDER_VIEW (g_object_get_data (G_OBJECT (dialog),
5066 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
5069 TnyFolderStore *dst_folder;
5070 TnyFolderStore *selected;
5072 case MODEST_GTK_RESPONSE_NEW_FOLDER:
5073 selected = modest_folder_view_get_selected (folder_view);
5074 modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view), selected);
5075 g_object_unref (selected);
5077 case GTK_RESPONSE_NONE:
5078 case GTK_RESPONSE_CANCEL:
5079 case GTK_RESPONSE_DELETE_EVENT:
5081 case GTK_RESPONSE_OK:
5082 dst_folder = modest_folder_view_get_selected (folder_view);
5084 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
5085 /* Clean list to move used for filtering */
5086 modest_folder_view_set_list_to_move (folder_view, NULL);
5088 modest_ui_actions_on_main_window_move_to (NULL,
5089 GTK_WIDGET (folder_view),
5091 MODEST_MAIN_WINDOW (parent_win));
5092 #ifdef MODEST_TOOLKIT_HILDON2
5093 } else if (MODEST_IS_FOLDER_WINDOW (parent_win)) {
5094 /* Clean list to move used for filtering */
5095 modest_folder_view_set_list_to_move (folder_view, NULL);
5097 modest_ui_actions_on_folder_window_move_to (GTK_WIDGET (folder_view),
5100 GTK_WINDOW (parent_win));
5103 /* if the user selected a root folder
5104 (account) then do not perform any action */
5105 if (TNY_IS_ACCOUNT (dst_folder)) {
5106 g_signal_stop_emission_by_name (dialog, "response");
5110 /* Clean list to move used for filtering */
5111 modest_folder_view_set_list_to_move (folder_view, NULL);
5113 /* Moving from headers window in edit mode */
5114 modest_ui_actions_on_window_move_to (NULL, helper->list,
5116 MODEST_WINDOW (parent_win));
5120 g_object_unref (dst_folder);
5122 unset_edit_mode = TRUE;
5125 g_warning ("%s unexpected response id %d", __FUNCTION__, response);
5128 /* Free the helper and exit */
5130 g_object_unref (helper->list);
5131 if (unset_edit_mode) {
5132 #ifdef MODEST_TOOLKIT_HILDON2
5133 modest_hildon2_window_unset_edit_mode (MODEST_HILDON2_WINDOW (helper->win));
5136 g_slice_free (MoveToInfo, helper);
5137 gtk_widget_destroy (GTK_WIDGET (dialog));
5141 create_move_to_dialog (GtkWindow *win,
5142 GtkWidget *folder_view,
5143 TnyList *list_to_move)
5145 GtkWidget *dialog, *tree_view = NULL;
5147 dialog = modest_platform_create_move_to_dialog (win, &tree_view);
5149 #ifndef MODEST_TOOLKIT_HILDON2
5150 /* Track changes in the selection to
5151 * disable the OK button whenever "Move to" is not possible
5152 * disbale NEW button whenever New is not possible */
5153 g_signal_connect (tree_view,
5154 "folder_selection_changed",
5155 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
5159 /* It could happen that we're trying to move a message from a
5160 window (msg window for example) after the main window was
5161 closed, so we can not just get the model of the folder
5163 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
5164 const gchar *visible_id = NULL;
5166 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5167 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5168 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
5169 MODEST_FOLDER_VIEW(tree_view));
5172 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
5174 /* Show the same account than the one that is shown in the main window */
5175 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(tree_view),
5178 const gchar *active_account_name = NULL;
5179 ModestAccountMgr *mgr = NULL;
5180 ModestAccountSettings *settings = NULL;
5181 ModestServerAccountSettings *store_settings = NULL;
5183 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5184 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5185 modest_folder_view_update_model (MODEST_FOLDER_VIEW (tree_view),
5186 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
5188 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
5189 mgr = modest_runtime_get_account_mgr ();
5190 settings = modest_account_mgr_load_account_settings (mgr, active_account_name);
5193 const gchar *store_account_name;
5194 store_settings = modest_account_settings_get_store_settings (settings);
5195 store_account_name = modest_server_account_settings_get_account_name (store_settings);
5197 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (tree_view),
5198 store_account_name);
5199 g_object_unref (store_settings);
5200 g_object_unref (settings);
5204 /* we keep a pointer to the embedded folder view, so we can
5205 * retrieve it with get_folder_view_from_move_to_dialog (see
5206 * above) later (needed for focus handling)
5208 g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, tree_view);
5210 /* Hide special folders */
5211 #ifndef MODEST_TOOLKIT_HILDON2
5212 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
5215 modest_folder_view_set_list_to_move (MODEST_FOLDER_VIEW (tree_view), list_to_move);
5216 #ifndef MODEST_TOOLKIT_HILDON2
5217 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
5220 gtk_widget_show (GTK_WIDGET (tree_view));
5226 * Shows a confirmation dialog to the user when we're moving messages
5227 * from a remote server to the local storage. Returns the dialog
5228 * response. If it's other kind of movement then it always returns
5231 * This one is used by the next functions:
5232 * modest_ui_actions_on_paste - commented out
5233 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
5236 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
5237 TnyFolder *dest_folder,
5241 gint response = GTK_RESPONSE_OK;
5242 TnyAccount *account = NULL;
5243 TnyFolder *src_folder = NULL;
5244 TnyIterator *iter = NULL;
5245 TnyHeader *header = NULL;
5247 /* return with OK if the destination is a remote folder */
5248 if (modest_tny_folder_is_remote_folder (dest_folder))
5249 return GTK_RESPONSE_OK;
5251 /* Get source folder */
5252 iter = tny_list_create_iterator (headers);
5253 header = TNY_HEADER (tny_iterator_get_current (iter));
5255 src_folder = tny_header_get_folder (header);
5256 g_object_unref (header);
5258 g_object_unref (iter);
5260 /* if no src_folder, message may be an attahcment */
5261 if (src_folder == NULL)
5262 return GTK_RESPONSE_CANCEL;
5264 /* If the source is a local or MMC folder */
5265 if (!modest_tny_folder_is_remote_folder (src_folder)) {
5266 g_object_unref (src_folder);
5267 return GTK_RESPONSE_OK;
5270 /* Get the account */
5271 account = tny_folder_get_account (src_folder);
5273 /* now if offline we ask the user */
5274 if(connect_to_get_msg (win, tny_list_get_length (headers), account))
5275 response = GTK_RESPONSE_OK;
5277 response = GTK_RESPONSE_CANCEL;
5280 g_object_unref (src_folder);
5281 g_object_unref (account);
5287 move_to_helper_destroyer (gpointer user_data)
5289 MoveToHelper *helper = (MoveToHelper *) user_data;
5291 /* Close the "Pasting" information banner */
5292 if (helper->banner) {
5293 gtk_widget_destroy (GTK_WIDGET (helper->banner));
5294 g_object_unref (helper->banner);
5296 if (gtk_tree_row_reference_valid (helper->reference)) {
5297 gtk_tree_row_reference_free (helper->reference);
5298 helper->reference = NULL;
5304 move_to_cb (ModestMailOperation *mail_op,
5307 MoveToHelper *helper = (MoveToHelper *) user_data;
5308 GObject *object = modest_mail_operation_get_source (mail_op);
5310 /* Note that the operation could have failed, in that case do
5312 if (modest_mail_operation_get_status (mail_op) !=
5313 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
5316 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
5317 ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
5319 if (!modest_msg_view_window_select_next_message (self) &&
5320 !modest_msg_view_window_select_previous_message (self)) {
5321 /* No more messages to view, so close this window */
5322 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
5324 } else if (MODEST_IS_MAIN_WINDOW (object) &&
5325 gtk_tree_row_reference_valid (helper->reference)) {
5326 GtkWidget *header_view;
5328 GtkTreeSelection *sel;
5330 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5331 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5332 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
5333 path = gtk_tree_row_reference_get_path (helper->reference);
5334 /* We need to unselect the previous one
5335 because we could be copying instead of
5337 gtk_tree_selection_unselect_all (sel);
5338 gtk_tree_selection_select_path (sel, path);
5339 gtk_tree_path_free (path);
5341 g_object_unref (object);
5344 /* Destroy the helper */
5345 move_to_helper_destroyer (helper);
5349 folder_move_to_cb (ModestMailOperation *mail_op,
5350 TnyFolder *new_folder,
5353 GtkWidget *folder_view;
5356 object = modest_mail_operation_get_source (mail_op);
5357 if (MODEST_IS_MAIN_WINDOW (object)) {
5358 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5359 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5360 g_object_ref (folder_view);
5361 g_object_unref (object);
5362 move_to_cb (mail_op, user_data);
5363 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), new_folder, FALSE);
5364 g_object_unref (folder_view);
5366 move_to_cb (mail_op, user_data);
5371 msgs_move_to_cb (ModestMailOperation *mail_op,
5374 move_to_cb (mail_op, user_data);
5378 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
5381 GObject *win = NULL;
5382 const GError *error;
5383 TnyAccount *account = NULL;
5385 #ifndef MODEST_TOOLKIT_HILDON2
5386 ModestWindow *main_window = NULL;
5388 /* Disable next automatic folder selection */
5389 main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
5390 FALSE); /* don't create */
5392 /* Show notification dialog only if the main window exists */
5394 GtkWidget *folder_view = NULL;
5396 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
5397 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5398 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
5400 if (user_data && TNY_IS_FOLDER (user_data)) {
5401 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
5402 TNY_FOLDER (user_data), FALSE);
5406 win = modest_mail_operation_get_source (mail_op);
5407 error = modest_mail_operation_get_error (mail_op);
5409 if (TNY_IS_FOLDER (user_data))
5410 account = modest_tny_folder_get_account (TNY_FOLDER (user_data));
5411 else if (TNY_IS_ACCOUNT (user_data))
5412 account = g_object_ref (user_data);
5414 /* If it's not a disk full error then show a generic error */
5415 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5416 (GtkWidget *) win, (GError *) error,
5418 modest_platform_run_information_dialog ((GtkWindow *) win,
5419 _("mail_in_ui_folder_move_target_error"),
5422 g_object_unref (account);
5424 g_object_unref (win);
5428 open_msg_for_purge_cb (ModestMailOperation *mail_op,
5437 gint pending_purges = 0;
5438 gboolean some_purged = FALSE;
5439 ModestWindow *win = MODEST_WINDOW (user_data);
5440 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
5442 /* If there was any error */
5443 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
5444 modest_window_mgr_unregister_header (mgr, header);
5448 /* Once the message has been retrieved for purging, we check if
5449 * it's all ok for purging */
5451 parts = tny_simple_list_new ();
5452 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
5453 iter = tny_list_create_iterator (parts);
5455 while (!tny_iterator_is_done (iter)) {
5457 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5458 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
5459 if (tny_mime_part_is_purged (part))
5466 g_object_unref (part);
5468 tny_iterator_next (iter);
5470 g_object_unref (iter);
5473 if (pending_purges>0) {
5475 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
5477 if (response == GTK_RESPONSE_OK) {
5480 modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_me_inbox_remove_attachments"));
5481 iter = tny_list_create_iterator (parts);
5482 while (!tny_iterator_is_done (iter)) {
5485 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5486 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
5487 tny_mime_part_set_purged (part);
5490 g_object_unref (part);
5492 tny_iterator_next (iter);
5494 g_object_unref (iter);
5496 tny_msg_rewrite_cache (msg);
5498 gtk_widget_destroy (info);
5502 modest_window_mgr_unregister_header (mgr, header);
5504 g_object_unref (parts);
5508 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
5509 ModestMainWindow *win)
5511 GtkWidget *header_view;
5512 TnyList *header_list;
5514 TnyHeaderFlags flags;
5515 ModestWindow *msg_view_window = NULL;
5518 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5520 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
5521 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5523 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
5525 g_warning ("%s: no header selected", __FUNCTION__);
5529 if (tny_list_get_length (header_list) == 1) {
5530 TnyIterator *iter = tny_list_create_iterator (header_list);
5531 header = TNY_HEADER (tny_iterator_get_current (iter));
5532 g_object_unref (iter);
5536 if (!header || !TNY_IS_HEADER(header)) {
5537 g_warning ("%s: header is not valid", __FUNCTION__);
5541 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
5542 header, &msg_view_window);
5543 flags = tny_header_get_flags (header);
5544 if (!(flags & TNY_HEADER_FLAG_CACHED))
5547 if (msg_view_window != NULL)
5548 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
5550 /* do nothing; uid was registered before, so window is probably on it's way */
5551 g_debug ("header %p has already been registered", header);
5554 ModestMailOperation *mail_op = NULL;
5555 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
5556 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
5557 modest_ui_actions_disk_operations_error_handler,
5559 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
5560 modest_mail_operation_get_msg (mail_op, header, FALSE, open_msg_for_purge_cb, win);
5562 g_object_unref (mail_op);
5565 g_object_unref (header);
5567 g_object_unref (header_list);
5571 * Checks if we need a connection to do the transfer and if the user
5572 * wants to connect to complete it
5575 modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
5576 TnyFolderStore *src_folder,
5578 TnyFolder *dst_folder,
5579 gboolean delete_originals,
5580 gboolean *need_connection,
5583 TnyAccount *src_account;
5584 gint uncached_msgs = 0;
5586 /* We don't need any further check if
5588 * 1- the source folder is local OR
5589 * 2- the device is already online
5591 if (!modest_tny_folder_store_is_remote (src_folder) ||
5592 tny_device_is_online (modest_runtime_get_device())) {
5593 *need_connection = FALSE;
5598 /* We must ask for a connection when
5600 * - the message(s) is not already cached OR
5601 * - the message(s) is cached but the leave_on_server setting
5602 * is FALSE (because we need to sync the source folder to
5603 * delete the message from the server (for IMAP we could do it
5604 * offline, it'll take place the next time we get a
5607 uncached_msgs = header_list_count_uncached_msgs (headers);
5608 src_account = get_account_from_folder_store (src_folder);
5609 if (uncached_msgs > 0) {
5613 *need_connection = TRUE;
5614 num_headers = tny_list_get_length (headers);
5615 msg = ngettext ("mcen_nc_get_msg", "mcen_nc_get_msgs", num_headers);
5617 if (modest_platform_run_confirmation_dialog (parent_window, msg) ==
5618 GTK_RESPONSE_CANCEL) {
5624 /* The transfer is possible and the user wants to */
5627 if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
5628 const gchar *account_name;
5629 gboolean leave_on_server;
5631 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
5632 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
5635 if (leave_on_server == TRUE) {
5636 *need_connection = FALSE;
5638 *need_connection = TRUE;
5641 *need_connection = FALSE;
5646 g_object_unref (src_account);
5650 xfer_messages_error_handler (ModestMailOperation *mail_op,
5654 const GError *error;
5655 TnyAccount *account;
5657 win = modest_mail_operation_get_source (mail_op);
5658 error = modest_mail_operation_get_error (mail_op);
5659 account = modest_mail_operation_get_account (mail_op);
5661 if (error && modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
5662 (GError *) error, account)) {
5663 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
5664 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
5667 modest_platform_run_information_dialog ((GtkWindow *) win,
5668 _("mail_in_ui_folder_move_target_error"),
5672 g_object_unref (account);
5674 g_object_unref (win);
5678 TnyFolderStore *dst_folder;
5683 * Utility function that transfer messages from both the main window
5684 * and the msg view window when using the "Move to" dialog
5687 xfer_messages_performer (gboolean canceled,
5689 GtkWindow *parent_window,
5690 TnyAccount *account,
5693 ModestWindow *win = MODEST_WINDOW (parent_window);
5694 TnyAccount *dst_account = NULL;
5695 gboolean dst_forbids_message_add = FALSE;
5696 XferMsgsHelper *helper;
5697 MoveToHelper *movehelper;
5698 ModestMailOperation *mail_op;
5700 helper = (XferMsgsHelper *) user_data;
5702 if (canceled || err) {
5703 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5704 (GtkWidget *) parent_window, err,
5706 /* Show the proper error message */
5707 modest_ui_actions_on_account_connection_error (parent_window, account);
5712 dst_account = tny_folder_get_account (TNY_FOLDER (helper->dst_folder));
5714 /* tinymail will return NULL for local folders it seems */
5715 dst_forbids_message_add = modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
5716 modest_tny_account_get_protocol_type (dst_account),
5717 MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
5718 g_object_unref (dst_account);
5720 if (dst_forbids_message_add) {
5721 modest_platform_information_banner (GTK_WIDGET (win),
5723 ngettext("mail_in_ui_folder_move_target_error",
5724 "mail_in_ui_folder_move_targets_error",
5725 tny_list_get_length (helper->headers)));
5729 movehelper = g_new0 (MoveToHelper, 1);
5731 #ifndef MODEST_TOOLKIT_HILDON2
5732 movehelper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
5733 _CS("ckct_nw_pasting"));
5734 if (movehelper->banner != NULL) {
5735 g_object_ref (movehelper->banner);
5736 gtk_widget_show (GTK_WIDGET (movehelper->banner));
5740 if (MODEST_IS_MAIN_WINDOW (win)) {
5741 GtkWidget *header_view =
5742 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
5743 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5744 movehelper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
5747 /* Perform the mail operation */
5748 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(win),
5749 xfer_messages_error_handler,
5751 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5754 modest_mail_operation_xfer_msgs (mail_op,
5756 TNY_FOLDER (helper->dst_folder),
5761 g_object_unref (G_OBJECT (mail_op));
5763 g_object_unref (helper->dst_folder);
5764 g_object_unref (helper->headers);
5765 g_slice_free (XferMsgsHelper, helper);
5769 TnyFolder *src_folder;
5770 TnyFolderStore *dst_folder;
5771 gboolean delete_original;
5772 GtkWidget *folder_view;
5776 on_move_folder_cb (gboolean canceled,
5778 GtkWindow *parent_window,
5779 TnyAccount *account,
5782 MoveFolderInfo *info = (MoveFolderInfo*)user_data;
5783 GtkTreeSelection *sel;
5784 ModestMailOperation *mail_op = NULL;
5786 if (canceled || err || !MODEST_IS_WINDOW (parent_window)) {
5787 /* Note that the connection process can fail due to
5788 memory low conditions as it can not successfully
5789 store the summary */
5790 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5791 (GtkWidget*) parent_window, err,
5793 g_debug ("Error connecting when trying to move a folder");
5795 g_object_unref (G_OBJECT (info->src_folder));
5796 g_object_unref (G_OBJECT (info->dst_folder));
5801 MoveToHelper *helper = g_new0 (MoveToHelper, 1);
5802 #ifndef MODEST_TOOLKIT_HILDON2
5803 helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
5804 _CS("ckct_nw_pasting"));
5805 if (helper->banner != NULL) {
5806 g_object_ref (helper->banner);
5807 gtk_widget_show (GTK_WIDGET(helper->banner));
5810 /* Clean folder on header view before moving it */
5811 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
5812 gtk_tree_selection_unselect_all (sel);
5814 /* Let gtk events run. We need that the folder
5815 view frees its reference to the source
5816 folder *before* issuing the mail operation
5817 so we need the signal handler of selection
5818 changed to happen before the mail
5820 while (gtk_events_pending ())
5821 gtk_main_iteration (); */
5824 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
5825 modest_ui_actions_move_folder_error_handler,
5826 g_object_ref (info->dst_folder), g_object_unref);
5827 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5830 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
5831 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
5832 TNY_FOLDER (info->dst_folder), TRUE);
5834 modest_mail_operation_xfer_folder (mail_op,
5835 TNY_FOLDER (info->src_folder),
5837 info->delete_original,
5840 g_object_unref (G_OBJECT (info->src_folder));
5842 /* if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) { */
5845 /* Unref mail operation */
5846 g_object_unref (G_OBJECT (mail_op));
5847 g_object_unref (G_OBJECT (info->dst_folder));
5852 get_account_from_folder_store (TnyFolderStore *folder_store)
5854 if (TNY_IS_ACCOUNT (folder_store))
5855 return g_object_ref (folder_store);
5857 return tny_folder_get_account (TNY_FOLDER (folder_store));
5861 * UI handler for the "Move to" action when invoked from the
5865 modest_ui_actions_on_main_window_move_to (GtkAction *action,
5866 GtkWidget *folder_view,
5867 TnyFolderStore *dst_folder,
5868 ModestMainWindow *win)
5870 ModestHeaderView *header_view = NULL;
5871 TnyFolderStore *src_folder = NULL;
5873 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5875 /* Get the source folder */
5876 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5878 /* Get header view */
5879 header_view = (ModestHeaderView *)
5880 modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5882 /* Get folder or messages to transfer */
5883 if (gtk_widget_is_focus (folder_view)) {
5884 gboolean do_xfer = TRUE;
5886 /* Allow only to transfer folders to the local root folder */
5887 if (TNY_IS_ACCOUNT (dst_folder) &&
5888 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5889 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5891 } else if (!TNY_IS_FOLDER (src_folder)) {
5892 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5897 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5898 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5900 info->src_folder = g_object_ref (src_folder);
5901 info->dst_folder = g_object_ref (dst_folder);
5902 info->delete_original = TRUE;
5903 info->folder_view = folder_view;
5905 connect_info->callback = on_move_folder_cb;
5906 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5907 connect_info->data = info;
5909 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5910 TNY_FOLDER_STORE (src_folder),
5913 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
5916 headers = modest_header_view_get_selected_headers(header_view);
5918 /* Transfer the messages */
5919 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
5920 headers, TNY_FOLDER (dst_folder));
5922 g_object_unref (headers);
5926 g_object_unref (src_folder);
5929 #ifdef MODEST_TOOLKIT_HILDON2
5931 * UI handler for the "Move to" action when invoked from the
5932 * ModestFolderWindow
5935 modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
5936 TnyFolderStore *dst_folder,
5940 TnyFolderStore *src_folder = NULL;
5941 TnyIterator *iterator;
5943 if (tny_list_get_length (selection) != 1)
5946 iterator = tny_list_create_iterator (selection);
5947 src_folder = TNY_FOLDER_STORE (tny_iterator_get_current (iterator));
5948 g_object_unref (iterator);
5951 gboolean do_xfer = TRUE;
5953 /* Allow only to transfer folders to the local root folder */
5954 if (TNY_IS_ACCOUNT (dst_folder) &&
5955 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5956 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5959 modest_platform_run_information_dialog (win,
5960 _("mail_in_ui_folder_move_target_error"),
5962 } else if (!TNY_IS_FOLDER (src_folder)) {
5963 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5968 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5969 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5971 info->src_folder = g_object_ref (src_folder);
5972 info->dst_folder = g_object_ref (dst_folder);
5973 info->delete_original = TRUE;
5974 info->folder_view = folder_view;
5976 connect_info->callback = on_move_folder_cb;
5977 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5978 connect_info->data = info;
5980 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5981 TNY_FOLDER_STORE (src_folder),
5986 g_object_unref (src_folder);
5992 modest_ui_actions_transfer_messages_helper (GtkWindow *win,
5993 TnyFolder *src_folder,
5995 TnyFolder *dst_folder)
5997 gboolean need_connection = TRUE;
5998 gboolean do_xfer = TRUE;
5999 XferMsgsHelper *helper;
6001 g_return_if_fail (TNY_IS_FOLDER (src_folder));
6002 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6003 g_return_if_fail (TNY_IS_LIST (headers));
6005 modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
6006 headers, TNY_FOLDER (dst_folder),
6007 TRUE, &need_connection,
6010 /* If we don't want to transfer just return */
6014 /* Create the helper */
6015 helper = g_slice_new (XferMsgsHelper);
6016 helper->dst_folder = g_object_ref (dst_folder);
6017 helper->headers = g_object_ref (headers);
6019 if (need_connection) {
6020 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
6021 connect_info->callback = xfer_messages_performer;
6022 connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
6023 connect_info->data = helper;
6025 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
6026 TNY_FOLDER_STORE (src_folder),
6029 TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
6030 xfer_messages_performer (FALSE, NULL, GTK_WINDOW (win),
6031 src_account, helper);
6032 g_object_unref (src_account);
6037 * UI handler for the "Move to" action when invoked from the
6038 * ModestMsgViewWindow
6041 modest_ui_actions_on_window_move_to (GtkAction *action,
6043 TnyFolderStore *dst_folder,
6046 TnyFolder *src_folder = NULL;
6048 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6051 TnyHeader *header = NULL;
6054 iter = tny_list_create_iterator (headers);
6055 header = (TnyHeader *) tny_iterator_get_current (iter);
6056 src_folder = tny_header_get_folder (header);
6058 /* Transfer the messages */
6059 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
6061 TNY_FOLDER (dst_folder));
6064 g_object_unref (header);
6065 g_object_unref (iter);
6066 g_object_unref (src_folder);
6071 modest_ui_actions_on_move_to (GtkAction *action,
6074 modest_ui_actions_on_edit_mode_move_to (win);
6078 modest_ui_actions_on_edit_mode_move_to (ModestWindow *win)
6080 GtkWidget *dialog = NULL;
6081 MoveToInfo *helper = NULL;
6082 TnyList *list_to_move;
6084 g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
6086 #ifndef MODEST_TOOLKIT_HILDON2
6087 /* Get the main window if exists */
6088 ModestMainWindow *main_window;
6089 if (MODEST_IS_MAIN_WINDOW (win))
6090 main_window = MODEST_MAIN_WINDOW (win);
6093 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
6094 FALSE)); /* don't create */
6097 list_to_move = modest_platform_get_list_to_move (MODEST_WINDOW (win));
6102 if (tny_list_get_length (list_to_move) < 1) {
6103 g_object_unref (list_to_move);
6107 /* Create and run the dialog */
6108 dialog = create_move_to_dialog (GTK_WINDOW (win), NULL, list_to_move);
6109 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
6110 GTK_WINDOW (dialog),
6114 helper = g_slice_new0 (MoveToInfo);
6115 helper->list = list_to_move;
6118 /* Listen to response signal */
6119 g_signal_connect (dialog, "response", G_CALLBACK (on_move_to_dialog_response), helper);
6121 /* Show the dialog */
6122 gtk_widget_show (dialog);
6128 * Calls #HeadersFunc for each header already selected in the main
6129 * window or the message currently being shown in the msg view window
6132 do_headers_action (ModestWindow *win,
6136 TnyList *headers_list = NULL;
6137 TnyIterator *iter = NULL;
6138 TnyHeader *header = NULL;
6139 TnyFolder *folder = NULL;
6142 headers_list = get_selected_headers (win);
6146 /* Get the folder */
6147 iter = tny_list_create_iterator (headers_list);
6148 header = TNY_HEADER (tny_iterator_get_current (iter));
6150 folder = tny_header_get_folder (header);
6151 g_object_unref (header);
6154 /* Call the function for each header */
6155 while (!tny_iterator_is_done (iter)) {
6156 header = TNY_HEADER (tny_iterator_get_current (iter));
6157 func (header, win, user_data);
6158 g_object_unref (header);
6159 tny_iterator_next (iter);
6162 /* Trick: do a poke status in order to speed up the signaling
6165 tny_folder_poke_status (folder);
6166 g_object_unref (folder);
6170 g_object_unref (iter);
6171 g_object_unref (headers_list);
6175 modest_ui_actions_view_attachment (GtkAction *action,
6176 ModestWindow *window)
6178 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6179 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
6181 /* not supported window for this action */
6182 g_return_if_reached ();
6187 modest_ui_actions_save_attachments (GtkAction *action,
6188 ModestWindow *window)
6190 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6192 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
6195 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
6197 /* not supported window for this action */
6198 g_return_if_reached ();
6203 modest_ui_actions_remove_attachments (GtkAction *action,
6204 ModestWindow *window)
6206 if (MODEST_IS_MAIN_WINDOW (window)) {
6207 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
6208 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6209 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
6211 /* not supported window for this action */
6212 g_return_if_reached ();
6217 modest_ui_actions_on_settings (GtkAction *action,
6222 dialog = modest_platform_get_global_settings_dialog ();
6223 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
6224 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
6225 gtk_widget_show_all (dialog);
6227 gtk_dialog_run (GTK_DIALOG (dialog));
6229 gtk_widget_destroy (dialog);
6233 modest_ui_actions_on_help (GtkAction *action,
6236 /* Help app is not available at all in fremantle */
6237 #ifndef MODEST_TOOLKIT_HILDON2
6238 const gchar *help_id;
6240 g_return_if_fail (win && GTK_IS_WINDOW(win));
6242 help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
6245 modest_platform_show_help (GTK_WINDOW (win), help_id);
6250 modest_ui_actions_on_csm_help (GtkAction *action,
6253 /* Help app is not available at all in fremantle */
6254 #ifndef MODEST_TOOLKIT_HILDON2
6256 const gchar* help_id = NULL;
6257 GtkWidget *folder_view;
6258 TnyFolderStore *folder_store;
6260 g_return_if_fail (win && MODEST_IS_MAIN_WINDOW (win));
6262 /* Get selected folder */
6263 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
6264 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6265 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6267 /* Switch help_id */
6268 if (folder_store && TNY_IS_FOLDER (folder_store))
6269 help_id = modest_tny_folder_get_help_id (TNY_FOLDER (folder_store));
6272 g_object_unref (folder_store);
6275 modest_platform_show_help (GTK_WINDOW (win), help_id);
6277 modest_ui_actions_on_help (action, win);
6282 retrieve_contents_cb (ModestMailOperation *mail_op,
6289 /* We only need this callback to show an error in case of
6290 memory low condition */
6291 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
6292 g_debug ("%s: message failed to retrieve. Memory low?", __FUNCTION__);
6297 retrieve_msg_contents_performer (gboolean canceled,
6299 GtkWindow *parent_window,
6300 TnyAccount *account,
6303 ModestMailOperation *mail_op;
6304 TnyList *headers = TNY_LIST (user_data);
6306 if (err || canceled) {
6307 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
6308 (GtkWidget *) parent_window, err,
6313 /* Create mail operation */
6314 mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
6315 modest_ui_actions_disk_operations_error_handler,
6317 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
6318 modest_mail_operation_get_msgs_full (mail_op, headers, retrieve_contents_cb, NULL, NULL);
6321 g_object_unref (mail_op);
6323 g_object_unref (headers);
6324 g_object_unref (account);
6328 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
6329 ModestWindow *window)
6331 TnyList *headers = NULL;
6332 TnyAccount *account = NULL;
6333 TnyIterator *iter = NULL;
6334 TnyHeader *header = NULL;
6335 TnyFolder *folder = NULL;
6338 headers = get_selected_headers (window);
6342 /* Pick the account */
6343 iter = tny_list_create_iterator (headers);
6344 header = TNY_HEADER (tny_iterator_get_current (iter));
6345 folder = tny_header_get_folder (header);
6346 account = tny_folder_get_account (folder);
6347 g_object_unref (folder);
6348 g_object_unref (header);
6349 g_object_unref (iter);
6351 /* Connect and perform the message retrieval */
6352 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6353 g_object_ref (account),
6354 retrieve_msg_contents_performer,
6355 g_object_ref (headers));
6358 g_object_unref (account);
6359 g_object_unref (headers);
6363 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
6365 g_return_if_fail (MODEST_IS_WINDOW (window));
6368 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_TOOLBAR);
6372 modest_ui_actions_check_menu_dimming_rules (ModestWindow *window)
6374 g_return_if_fail (MODEST_IS_WINDOW (window));
6377 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_MENU);
6381 modest_ui_actions_on_email_menu_activated (GtkAction *action,
6382 ModestWindow *window)
6384 g_return_if_fail (MODEST_IS_WINDOW (window));
6387 modest_ui_actions_check_menu_dimming_rules (window);
6391 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
6392 ModestWindow *window)
6394 g_return_if_fail (MODEST_IS_WINDOW (window));
6397 modest_ui_actions_check_menu_dimming_rules (window);
6401 modest_ui_actions_on_view_menu_activated (GtkAction *action,
6402 ModestWindow *window)
6404 g_return_if_fail (MODEST_IS_WINDOW (window));
6407 modest_ui_actions_check_menu_dimming_rules (window);
6411 modest_ui_actions_on_format_menu_activated (GtkAction *action,
6412 ModestWindow *window)
6414 g_return_if_fail (MODEST_IS_WINDOW (window));
6417 modest_ui_actions_check_menu_dimming_rules (window);
6421 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
6422 ModestWindow *window)
6424 g_return_if_fail (MODEST_IS_WINDOW (window));
6427 modest_ui_actions_check_menu_dimming_rules (window);
6431 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
6432 ModestWindow *window)
6434 g_return_if_fail (MODEST_IS_WINDOW (window));
6437 modest_ui_actions_check_menu_dimming_rules (window);
6441 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
6442 ModestWindow *window)
6444 g_return_if_fail (MODEST_IS_WINDOW (window));
6447 modest_ui_actions_check_menu_dimming_rules (window);
6451 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
6452 ModestWindow *window)
6454 g_return_if_fail (MODEST_IS_WINDOW (window));
6457 modest_ui_actions_check_menu_dimming_rules (window);
6461 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
6462 ModestWindow *window)
6464 g_return_if_fail (MODEST_IS_WINDOW (window));
6467 modest_ui_actions_check_menu_dimming_rules (window);
6471 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
6473 g_return_if_fail (MODEST_IS_WINDOW (window));
6475 /* we check for low-mem; in that case, show a warning, and don't allow
6478 if (modest_platform_check_memory_low (window, TRUE))
6481 modest_platform_show_search_messages (GTK_WINDOW (window));
6485 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
6487 g_return_if_fail (MODEST_IS_WINDOW (win));
6490 /* we check for low-mem; in that case, show a warning, and don't allow
6491 * for the addressbook
6493 if (modest_platform_check_memory_low (win, TRUE))
6497 modest_platform_show_addressbook (GTK_WINDOW (win));
6502 modest_ui_actions_on_toggle_find_in_page (GtkAction *action,
6503 ModestWindow *window)
6506 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
6508 if (GTK_IS_TOGGLE_ACTION (action))
6509 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
6513 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window),
6518 on_send_receive_finished (ModestMailOperation *mail_op,
6521 GtkWidget *header_view, *folder_view;
6522 TnyFolderStore *folder_store;
6523 ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
6525 /* Set send/receive operation finished */
6526 modest_main_window_notify_send_receive_completed (main_win);
6528 /* Don't refresh the current folder if there were any errors */
6529 if (modest_mail_operation_get_status (mail_op) !=
6530 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
6533 /* Refresh the current folder if we're viewing a window. We do
6534 this because the user won't be able to see the new mails in
6535 the selected folder after a Send&Receive because it only
6536 performs a poke_status, i.e, only the number of read/unread
6537 messages is updated, but the new headers are not
6539 folder_view = modest_main_window_get_child_widget (main_win,
6540 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6544 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6546 /* Do not need to refresh INBOX again because the
6547 update_account does it always automatically */
6548 if (folder_store && TNY_IS_FOLDER (folder_store) &&
6549 tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
6550 ModestMailOperation *refresh_op;
6552 header_view = modest_main_window_get_child_widget (main_win,
6553 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6555 /* We do not need to set the contents style
6556 because it hasn't changed. We also do not
6557 need to save the widget status. Just force
6559 refresh_op = modest_mail_operation_new (G_OBJECT (main_win));
6560 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), refresh_op);
6561 modest_mail_operation_refresh_folder (refresh_op, TNY_FOLDER (folder_store),
6562 folder_refreshed_cb, main_win);
6563 g_object_unref (refresh_op);
6567 g_object_unref (folder_store);
6572 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
6578 const gchar* server_name = NULL;
6579 TnyTransportAccount *transport;
6580 gchar *message = NULL;
6581 ModestProtocol *protocol;
6583 /* Don't show anything if the user cancelled something or the
6584 * send receive request is not interactive. Authentication
6585 * errors are managed by the account store so no need to show
6586 * a dialog here again */
6587 if (err->code == TNY_SYSTEM_ERROR_CANCEL ||
6588 err->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
6589 !modest_tny_send_queue_get_requested_send_receive (MODEST_TNY_SEND_QUEUE (self)))
6593 /* Get the server name. Note that we could be using a
6594 connection specific transport account */
6595 transport = (TnyTransportAccount *)
6596 tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
6598 ModestTnyAccountStore *acc_store;
6599 const gchar *acc_name;
6600 TnyTransportAccount *conn_specific;
6602 acc_store = modest_runtime_get_account_store();
6603 acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
6604 conn_specific = (TnyTransportAccount *)
6605 modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
6606 if (conn_specific) {
6607 server_name = tny_account_get_hostname (TNY_ACCOUNT (conn_specific));
6608 g_object_unref (conn_specific);
6610 server_name = tny_account_get_hostname (TNY_ACCOUNT (transport));
6612 g_object_unref (transport);
6616 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
6617 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
6618 tny_account_get_proto (TNY_ACCOUNT (transport)));
6620 g_warning ("%s: Account with no proto", __FUNCTION__);
6624 /* Show the appropriate message text for the GError: */
6625 switch (err->code) {
6626 case TNY_SERVICE_ERROR_CONNECT:
6627 message = modest_protocol_get_translation (protocol,
6628 MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
6631 case TNY_SERVICE_ERROR_SEND:
6632 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6634 case TNY_SERVICE_ERROR_UNAVAILABLE:
6635 message = modest_protocol_get_translation (protocol,
6636 MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR,
6640 g_warning ("%s: unexpected ERROR %d",
6641 __FUNCTION__, err->code);
6642 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6646 modest_platform_run_information_dialog (NULL, message, FALSE);
6651 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
6656 ModestWindow *top_window = NULL;
6657 ModestWindowMgr *mgr = NULL;
6658 GtkWidget *header_view = NULL;
6659 TnyFolder *selected_folder = NULL;
6660 TnyFolderType folder_type;
6662 mgr = modest_runtime_get_window_mgr ();
6663 top_window = modest_window_mgr_get_current_top (mgr);
6668 #ifndef MODEST_TOOLKIT_HILDON2
6669 if (MODEST_IS_MAIN_WINDOW (top_window)) {
6670 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (top_window),
6671 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6674 if (MODEST_IS_HEADER_WINDOW (top_window)) {
6675 header_view = (GtkWidget *)
6676 modest_header_window_get_header_view (MODEST_HEADER_WINDOW (top_window));
6680 /* Get selected folder */
6682 selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
6683 if (!selected_folder)
6686 /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
6687 #if GTK_CHECK_VERSION(2, 8, 0)
6688 folder_type = modest_tny_folder_guess_folder_type (selected_folder);
6689 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
6690 GtkTreeViewColumn *tree_column;
6692 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
6693 TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
6695 gtk_tree_view_column_queue_resize (tree_column);
6697 #else /* #if GTK_CHECK_VERSION(2, 8, 0) */
6698 gtk_widget_queue_draw (header_view);
6701 #ifndef MODEST_TOOLKIT_HILDON2
6702 /* Rerun dimming rules, because the message could become deletable for example */
6703 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6704 MODEST_DIMMING_RULES_TOOLBAR);
6705 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6706 MODEST_DIMMING_RULES_MENU);
6710 g_object_unref (selected_folder);
6714 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
6715 TnyAccount *account)
6717 ModestProtocolType protocol_type;
6718 ModestProtocol *protocol;
6719 gchar *error_note = NULL;
6721 protocol_type = modest_tny_account_get_protocol_type (account);
6722 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6725 error_note = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, tny_account_get_hostname (account));
6726 if (error_note == NULL) {
6727 g_warning ("%s: This should not be reached", __FUNCTION__);
6729 modest_platform_run_information_dialog (parent_window, error_note, FALSE);
6730 g_free (error_note);
6735 modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
6739 TnyFolderStore *folder = NULL;
6740 TnyAccount *account = NULL;
6741 ModestProtocolType proto;
6742 ModestProtocol *protocol;
6743 TnyHeader *header = NULL;
6745 if (MODEST_IS_MAIN_WINDOW (win)) {
6746 GtkWidget *header_view;
6747 TnyList* headers = NULL;
6749 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
6750 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6751 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6752 if (!headers || tny_list_get_length (headers) == 0) {
6754 g_object_unref (headers);
6757 iter = tny_list_create_iterator (headers);
6758 header = TNY_HEADER (tny_iterator_get_current (iter));
6759 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6760 g_object_unref (iter);
6761 g_object_unref (headers);
6762 #ifdef MODEST_TOOLKIT_HILDON2
6763 } else if (MODEST_IS_HEADER_WINDOW (win)) {
6764 GtkWidget *header_view;
6765 TnyList* headers = NULL;
6767 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
6768 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6769 if (!headers || tny_list_get_length (headers) == 0) {
6771 g_object_unref (headers);
6774 iter = tny_list_create_iterator (headers);
6775 header = TNY_HEADER (tny_iterator_get_current (iter));
6777 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6779 g_warning ("List should contain headers");
6781 g_object_unref (iter);
6782 g_object_unref (headers);
6784 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
6785 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
6787 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6790 if (!header || !folder)
6793 /* Get the account type */
6794 account = tny_folder_get_account (TNY_FOLDER (folder));
6795 proto = modest_tny_account_get_protocol_type (account);
6796 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6799 subject = tny_header_dup_subject (header);
6800 msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
6804 msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
6810 g_object_unref (account);
6812 g_object_unref (folder);
6814 g_object_unref (header);
6820 modest_ui_actions_on_delete_account (GtkWindow *parent_window,
6821 const gchar *account_name,
6822 const gchar *account_title)
6824 ModestAccountMgr *account_mgr;
6827 ModestProtocol *protocol;
6828 gboolean removed = FALSE;
6830 g_return_val_if_fail (account_name, FALSE);
6831 g_return_val_if_fail (account_title, FALSE);
6833 account_mgr = modest_runtime_get_account_mgr();
6835 /* The warning text depends on the account type: */
6836 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6837 modest_account_mgr_get_store_protocol (account_mgr,
6839 txt = modest_protocol_get_translation (protocol,
6840 MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX,
6843 txt = g_strdup_printf (_("emev_nc_delete_mailbox"), account_title);
6845 response = modest_platform_run_confirmation_dialog (parent_window, txt);
6849 if (response == GTK_RESPONSE_OK) {
6850 /* Remove account. If it succeeds then it also removes
6851 the account from the ModestAccountView: */
6852 gboolean is_default = FALSE;
6853 gchar *default_account_name = modest_account_mgr_get_default_account (account_mgr);
6854 if (default_account_name && (strcmp (default_account_name, account_name) == 0))
6856 g_free (default_account_name);
6858 removed = modest_account_mgr_remove_account (account_mgr, account_name);
6860 g_warning ("%s: modest_account_mgr_remove_account() failed.\n", __FUNCTION__);
6866 on_fetch_images_performer (gboolean canceled,
6868 GtkWindow *parent_window,
6869 TnyAccount *account,
6872 if (err || canceled) {
6873 /* Show an unable to retrieve images ??? */
6877 /* Note that the user could have closed the window while connecting */
6878 if (GTK_WIDGET_VISIBLE (parent_window))
6879 modest_msg_view_window_fetch_images ((ModestMsgViewWindow *) parent_window);
6880 g_object_unref ((GObject *) user_data);
6884 modest_ui_actions_on_fetch_images (GtkAction *action,
6885 ModestWindow *window)
6887 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
6889 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6891 on_fetch_images_performer,
6892 g_object_ref (window));
6896 modest_ui_actions_on_reload_message (const gchar *msg_id)
6898 ModestWindow *window = NULL;
6900 g_return_if_fail (msg_id && msg_id[0] != '\0');
6901 if (!modest_window_mgr_find_registered_message_uid (modest_runtime_get_window_mgr (),
6907 if (window == NULL || !MODEST_IS_MSG_VIEW_WINDOW (window))
6910 modest_msg_view_window_reload (MODEST_MSG_VIEW_WINDOW (window));