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-gtk.h>
56 #include <modest-header-window.h>
57 #include <modest-folder-window.h>
58 #include <modest-maemo-utils.h>
60 #include "modest-utils.h"
61 #include "widgets/modest-connection-specific-smtp-window.h"
62 #include "widgets/modest-ui-constants.h"
63 #include <widgets/modest-main-window.h>
64 #include <widgets/modest-msg-view-window.h>
65 #include <widgets/modest-account-view-window.h>
66 #include <widgets/modest-details-dialog.h>
67 #include <widgets/modest-attachments-view.h>
68 #include "widgets/modest-folder-view.h"
69 #include "widgets/modest-global-settings-dialog.h"
70 #include "modest-account-mgr-helpers.h"
71 #include "modest-mail-operation.h"
72 #include "modest-text-utils.h"
73 #include <modest-widget-memory.h>
74 #include <tny-error.h>
75 #include <tny-simple-list.h>
76 #include <tny-msg-view.h>
77 #include <tny-device.h>
78 #include <tny-merge-folder.h>
80 #include <gtkhtml/gtkhtml.h>
82 #define MODEST_MOVE_TO_DIALOG_FOLDER_VIEW "move-to-dialog-folder-view"
84 typedef struct _GetMsgAsyncHelper {
86 ModestMailOperation *mail_op;
93 typedef enum _ReplyForwardAction {
99 typedef struct _ReplyForwardHelper {
100 guint reply_forward_type;
101 ReplyForwardAction action;
104 GtkWidget *parent_window;
106 } ReplyForwardHelper;
108 typedef struct _MoveToHelper {
109 GtkTreeRowReference *reference;
113 typedef struct _PasteAsAttachmentHelper {
114 ModestMsgEditWindow *window;
116 } PasteAsAttachmentHelper;
124 * The do_headers_action uses this kind of functions to perform some
125 * action to each member of a list of headers
127 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
129 static void do_headers_action (ModestWindow *win,
133 static void open_msg_cb (ModestMailOperation *mail_op,
140 static void reply_forward_cb (ModestMailOperation *mail_op,
147 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
149 #ifndef MODEST_TOOLKIT_HILDON2
150 static void folder_refreshed_cb (ModestMailOperation *mail_op,
154 static void on_send_receive_finished (ModestMailOperation *mail_op,
158 static gint header_list_count_uncached_msgs (TnyList *header_list);
160 static gboolean connect_to_get_msg (ModestWindow *win,
161 gint num_of_uncached_msgs,
162 TnyAccount *account);
164 static gboolean remote_folder_has_leave_on_server (TnyFolderStore *folder);
166 static void do_create_folder (GtkWindow *window,
167 TnyFolderStore *parent_folder,
168 const gchar *suggested_name);
170 static TnyAccount *get_account_from_folder_store (TnyFolderStore *folder_store);
172 #ifndef MODEST_TOOLKIT_HILDON2
173 static void modest_ui_actions_on_main_window_move_to (GtkAction *action,
174 GtkWidget *folder_view,
175 TnyFolderStore *dst_folder,
176 ModestMainWindow *win);
179 static void modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
180 TnyFolderStore *dst_folder,
185 static void modest_ui_actions_on_window_move_to (GtkAction *action,
186 TnyList *list_to_move,
187 TnyFolderStore *dst_folder,
191 * This function checks whether a TnyFolderStore is a pop account
194 remote_folder_has_leave_on_server (TnyFolderStore *folder)
199 g_return_val_if_fail (TNY_IS_FOLDER_STORE (folder), FALSE);
201 account = get_account_from_folder_store (folder);
202 result = (modest_protocol_registry_protocol_type_has_leave_on_server (modest_runtime_get_protocol_registry (),
203 modest_tny_account_get_protocol_type (account)));
204 g_object_unref (account);
209 /* FIXME: this should be merged with the similar code in modest-account-view-window */
210 /* Show the account creation wizard dialog.
211 * returns: TRUE if an account was created. FALSE if the user cancelled.
214 modest_ui_actions_run_account_setup_wizard (ModestWindow *win)
216 gboolean result = FALSE;
218 gint dialog_response;
220 /* there is no such wizard yet */
221 wizard = GTK_WINDOW (modest_platform_get_account_settings_wizard ());
222 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (wizard), (GtkWindow *) win);
224 #ifndef MODEST_TOOLKIT_HILDON2
225 /* always present a main window in the background
226 * we do it here, so we cannot end up with two wizards (as this
227 * function might be called in modest_window_mgr_get_main_window as well */
229 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
230 TRUE); /* create if not existent */
234 ModestWindowMgr *mgr;
236 mgr = modest_runtime_get_window_mgr ();
238 window_list = modest_window_mgr_get_window_list (mgr);
239 if (window_list == NULL) {
240 win = MODEST_WINDOW (modest_accounts_window_new ());
241 if (modest_window_mgr_register_window (mgr, win, NULL)) {
242 gtk_widget_show_all (GTK_WIDGET (win));
244 gtk_widget_destroy (GTK_WIDGET (win));
249 g_list_free (window_list);
255 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
257 /* make sure the mainwindow is visible. We need to present the
258 wizard again to give it the focus back. show_all are needed
259 in order to get the widgets properly drawn (MainWindow main
260 paned won't be in its right position and the dialog will be
262 #ifndef MODEST_TOOLKIT_HILDON2
263 gtk_widget_show_all (GTK_WIDGET (win));
264 gtk_widget_show_all (GTK_WIDGET (wizard));
265 gtk_window_present (GTK_WINDOW (win));
266 gtk_window_present (GTK_WINDOW (wizard));
269 dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
270 gtk_widget_destroy (GTK_WIDGET (wizard));
271 if (gtk_events_pending ())
272 gtk_main_iteration ();
274 if (dialog_response == GTK_RESPONSE_CANCEL) {
277 /* Check whether an account was created: */
278 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
285 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
288 const gchar *authors[] = {
289 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
292 about = gtk_about_dialog_new ();
293 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
294 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
295 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
296 _("Copyright (c) 2006, Nokia Corporation\n"
297 "All rights reserved."));
298 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
299 _("a modest e-mail client\n\n"
300 "design and implementation: Dirk-Jan C. Binnema\n"
301 "contributions from the fine people at KC and Ig\n"
302 "uses the tinymail email framework written by Philip van Hoof"));
303 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
304 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
305 gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
306 gtk_window_set_modal (GTK_WINDOW (about), TRUE);
308 gtk_dialog_run (GTK_DIALOG (about));
309 gtk_widget_destroy(about);
313 * Gets the list of currently selected messages. If the win is the
314 * main window, then it returns a newly allocated list of the headers
315 * selected in the header view. If win is the msg view window, then
316 * the value returned is a list with just a single header.
318 * The caller of this funcion must free the list.
321 get_selected_headers (ModestWindow *win)
323 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
324 /* for MsgViewWindows, we simply return a list with one element */
326 TnyList *list = NULL;
328 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
329 if (header != NULL) {
330 list = tny_simple_list_new ();
331 tny_list_prepend (list, G_OBJECT(header));
332 g_object_unref (G_OBJECT(header));
336 #ifndef MODEST_TOOLKIT_HILDON2
337 } else if (MODEST_IS_MAIN_WINDOW(win)) {
338 GtkWidget *header_view;
340 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
341 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
342 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
344 } else if (MODEST_IS_HEADER_WINDOW (win)) {
345 GtkWidget *header_view;
347 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
348 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
355 #ifndef MODEST_TOOLKIT_HILDON2
356 static GtkTreeRowReference *
357 get_next_after_selected_headers (ModestHeaderView *header_view)
359 GtkTreeSelection *sel;
360 GList *selected_rows, *node;
362 GtkTreeRowReference *result;
365 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
366 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
367 selected_rows = gtk_tree_selection_get_selected_rows (sel, NULL);
369 if (selected_rows == NULL)
372 node = g_list_last (selected_rows);
373 path = gtk_tree_path_copy ((GtkTreePath *) node->data);
374 gtk_tree_path_next (path);
376 result = gtk_tree_row_reference_new (model, path);
378 gtk_tree_path_free (path);
379 g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
380 g_list_free (selected_rows);
387 headers_action_mark_as_read (TnyHeader *header,
391 TnyHeaderFlags flags;
393 g_return_if_fail (TNY_IS_HEADER(header));
395 flags = tny_header_get_flags (header);
396 if (flags & TNY_HEADER_FLAG_SEEN) return;
397 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
401 headers_action_mark_as_unread (TnyHeader *header,
405 TnyHeaderFlags flags;
407 g_return_if_fail (TNY_IS_HEADER(header));
409 flags = tny_header_get_flags (header);
410 if (flags & TNY_HEADER_FLAG_SEEN) {
411 tny_header_unset_flag (header, TNY_HEADER_FLAG_SEEN);
415 /** After deleing a message that is currently visible in a window,
416 * show the next message from the list, or close the window if there are no more messages.
419 modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
421 /* Close msg view window or select next */
422 if (!modest_msg_view_window_select_next_message (win) &&
423 !modest_msg_view_window_select_previous_message (win)) {
425 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
431 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
433 modest_ui_actions_on_edit_mode_delete_message (win);
437 modest_ui_actions_on_edit_mode_delete_message (ModestWindow *win)
439 TnyList *header_list = NULL;
440 TnyIterator *iter = NULL;
441 TnyHeader *header = NULL;
442 gchar *message = NULL;
445 ModestWindowMgr *mgr;
446 gboolean retval = TRUE;
448 g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
450 #ifndef MODEST_TOOLKIT_HILDON2
451 /* Check first if the header view has the focus */
452 if (MODEST_IS_MAIN_WINDOW (win)) {
453 GtkWidget *header_view = NULL;
456 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
457 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
458 if (!gtk_widget_is_focus (header_view))
462 /* Get the headers, either from the header view (if win is the main window),
463 * or from the message view window: */
464 header_list = get_selected_headers (win);
465 if (!header_list) return FALSE;
467 /* Check if any of the headers are already opened, or in the process of being opened */
468 #ifndef MODEST_TOOLKIT_HILDON2
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);
501 if (tny_list_get_length(header_list) == 1) {
502 iter = tny_list_create_iterator (header_list);
503 header = TNY_HEADER (tny_iterator_get_current (iter));
506 subject = tny_header_dup_subject (header);
508 subject = g_strdup (_("mail_va_no_subject"));
509 desc = g_strdup_printf ("%s", subject);
511 g_object_unref (header);
514 g_object_unref (iter);
516 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
517 tny_list_get_length(header_list)), desc);
519 /* Confirmation dialog */
520 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
523 if (response == GTK_RESPONSE_OK) {
524 GtkTreeSelection *sel = NULL;
525 GList *sel_list = NULL;
526 ModestMailOperation *mail_op = NULL;
528 /* Find last selected row */
529 #ifndef MODEST_TOOLKIT_HILDON2
530 if (MODEST_IS_MAIN_WINDOW (win)) {
532 ModestWindowMgr *mgr = NULL;
533 GtkTreeModel *model = NULL;
534 GtkTreeRowReference *next_row_reference = NULL, *prev_row_reference = NULL;
535 GtkTreePath *next_path = NULL, *prev_path = NULL;
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);
555 /* Disable window dimming management */
556 modest_window_disable_dimming (win);
558 /* Remove each header. If it's a view window header_view == NULL */
559 mail_op = modest_mail_operation_new ((GObject *) win);
560 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
562 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
563 g_object_unref (mail_op);
565 /* Enable window dimming management */
567 gtk_tree_selection_unselect_all (sel);
569 modest_window_enable_dimming (win);
571 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
572 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
574 /* Get main window */
575 mgr = modest_runtime_get_window_mgr ();
576 #ifndef MODEST_TOOLKIT_HILDON2
577 } else if (MODEST_IS_MAIN_WINDOW (win)) {
578 /* Select next or previous row */
579 if (gtk_tree_row_reference_valid (next_row_reference)) {
580 gtk_tree_selection_select_path (sel, next_path);
582 else if (gtk_tree_row_reference_valid (prev_row_reference)) {
583 gtk_tree_selection_select_path (sel, prev_path);
587 if (gtk_tree_row_reference_valid (next_row_reference))
588 gtk_tree_row_reference_free (next_row_reference);
589 if (next_path != NULL)
590 gtk_tree_path_free (next_path);
591 if (gtk_tree_row_reference_valid (prev_row_reference))
592 gtk_tree_row_reference_free (prev_row_reference);
593 if (prev_path != NULL)
594 gtk_tree_path_free (prev_path);
598 /* Update toolbar dimming state */
599 modest_ui_actions_check_menu_dimming_rules (win);
600 modest_ui_actions_check_toolbar_dimming_rules (win);
603 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
604 g_list_free (sel_list);
613 g_object_unref (header_list);
621 /* delete either message or folder, based on where we are */
623 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
625 g_return_if_fail (MODEST_IS_WINDOW(win));
627 /* Check first if the header view has the focus */
628 #ifndef MODEST_TOOLKIT_HILDON2
629 if (MODEST_IS_MAIN_WINDOW (win)) {
631 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
632 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
633 if (gtk_widget_is_focus (w)) {
634 modest_ui_actions_on_delete_folder (action, MODEST_WINDOW(win));
639 modest_ui_actions_on_delete_message (action, win);
643 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
645 ModestWindowMgr *mgr = NULL;
647 #ifdef MODEST_PLATFORM_MAEMO
648 modest_window_mgr_save_state_for_all_windows (modest_runtime_get_window_mgr ());
649 #endif /* MODEST_PLATFORM_MAEMO */
651 g_debug ("closing down, clearing %d item(s) from operation queue",
652 modest_mail_operation_queue_num_elements
653 (modest_runtime_get_mail_operation_queue()));
655 /* cancel all outstanding operations */
656 modest_mail_operation_queue_cancel_all
657 (modest_runtime_get_mail_operation_queue());
659 g_debug ("queue has been cleared");
662 /* Check if there are opened editing windows */
663 mgr = modest_runtime_get_window_mgr ();
664 modest_window_mgr_close_all_windows (mgr);
666 /* note: when modest-tny-account-store is finalized,
667 it will automatically set all network connections
670 /* gtk_main_quit (); */
674 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
678 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
680 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
681 /* gtk_widget_destroy (GTK_WIDGET (win)); */
682 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
683 /* gboolean ret_value; */
684 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
685 /* } else if (MODEST_IS_WINDOW (win)) { */
686 /* gtk_widget_destroy (GTK_WIDGET (win)); */
688 /* g_return_if_reached (); */
693 modest_ui_actions_add_to_contacts (GtkAction *action, ModestWindow *win)
695 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
697 modest_msg_view_window_add_to_contacts (MODEST_MSG_VIEW_WINDOW (win));
701 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
703 GtkClipboard *clipboard = NULL;
704 gchar *selection = NULL;
706 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
707 selection = gtk_clipboard_wait_for_text (clipboard);
710 modest_address_book_add_address (selection, (GtkWindow *) win);
716 modest_ui_actions_on_new_account (GtkAction *action,
717 ModestWindow *window)
719 if (!modest_ui_actions_run_account_setup_wizard (window)) {
720 g_debug ("%s: wizard was already running", __FUNCTION__);
725 modest_ui_actions_on_accounts (GtkAction *action,
728 /* This is currently only implemented for Maemo */
729 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
730 if (!modest_ui_actions_run_account_setup_wizard (win))
731 g_debug ("%s: wizard was already running", __FUNCTION__);
735 /* Show the list of accounts */
736 GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
738 /* The accounts dialog must be modal */
739 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (account_win), (GtkWindow *) win);
740 modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
745 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
747 /* This is currently only implemented for Maemo,
748 * because it requires an API (libconic) to detect different connection
751 #ifndef MODEST_TOOLKIT_GTK /* Defined in config.h */
753 /* Create the window if necessary: */
754 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
755 modest_connection_specific_smtp_window_fill_with_connections (
756 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
757 modest_runtime_get_account_mgr());
759 /* Show the window: */
760 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
761 GTK_WINDOW (specific_window), (GtkWindow *) win);
762 gtk_widget_show (specific_window);
763 #endif /* !MODEST_TOOLKIT_GTK */
767 count_part_size (const gchar *part)
769 GnomeVFSURI *vfs_uri;
770 gchar *escaped_filename;
772 GnomeVFSFileInfo *info;
775 /* Estimation of attachment size if we cannot get it from file info */
778 vfs_uri = gnome_vfs_uri_new (part);
780 escaped_filename = g_path_get_basename (gnome_vfs_uri_get_path (vfs_uri));
781 filename = gnome_vfs_unescape_string_for_display (escaped_filename);
782 g_free (escaped_filename);
783 gnome_vfs_uri_unref (vfs_uri);
785 info = gnome_vfs_file_info_new ();
787 if (gnome_vfs_get_file_info (part,
789 GNOME_VFS_FILE_INFO_GET_MIME_TYPE)
791 if (info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) {
796 gnome_vfs_file_info_unref (info);
802 count_parts_size (GSList *parts)
807 for (node = parts; node != NULL; node = g_slist_next (node)) {
808 result += count_part_size ((const gchar *) node->data);
815 modest_ui_actions_compose_msg(ModestWindow *win,
818 const gchar *bcc_str,
819 const gchar *subject_str,
820 const gchar *body_str,
822 gboolean set_as_modified)
824 gchar *account_name = NULL;
825 const gchar *mailbox;
827 TnyAccount *account = NULL;
828 TnyFolder *folder = NULL;
829 gchar *from_str = NULL, *signature = NULL, *body = NULL;
830 gchar *recipient = NULL;
831 gboolean use_signature = FALSE;
832 ModestWindow *msg_win = NULL;
833 ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
834 ModestTnyAccountStore *store = modest_runtime_get_account_store();
835 GnomeVFSFileSize total_size, allowed_size;
836 guint64 available_disk, expected_size, parts_size;
839 /* we check for low-mem */
840 if (modest_platform_check_memory_low (win, TRUE))
843 available_disk = modest_utils_get_available_space (NULL);
844 parts_count = g_slist_length (attachments);
845 parts_size = count_parts_size (attachments);
846 expected_size = modest_tny_msg_estimate_size (body, NULL, parts_count, parts_size);
848 /* Double check: disk full condition or message too big */
849 if (available_disk < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE ||
850 expected_size > available_disk) {
851 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
852 modest_platform_system_banner (NULL, NULL, msg);
858 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
859 modest_platform_run_information_dialog (
861 _("mail_ib_error_attachment_size"),
867 #ifdef MODEST_TOOLKIT_HILDON2
869 account_name = g_strdup (modest_window_get_active_account(win));
872 account_name = modest_account_mgr_get_default_account(mgr);
875 g_printerr ("modest: no account found\n");
880 mailbox = modest_window_get_active_mailbox (win);
883 account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
885 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
888 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
890 g_printerr ("modest: failed to find Drafts folder\n");
893 from_str = modest_account_mgr_get_from_string (mgr, account_name, mailbox);
895 g_printerr ("modest: failed get from string for '%s'\n", account_name);
899 recipient = modest_text_utils_get_email_address (from_str);
900 signature = modest_account_mgr_get_signature_from_recipient (mgr, recipient, &use_signature);
902 if (body_str != NULL) {
903 body = use_signature ? g_strconcat(body_str, "\n",
904 MODEST_TEXT_UTILS_SIGNATURE_MARKER,
905 "\n", signature, NULL) : g_strdup(body_str);
907 body = use_signature ? g_strconcat("\n", MODEST_TEXT_UTILS_SIGNATURE_MARKER,
908 "\n", signature, NULL) : g_strdup("");
911 msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, NULL, NULL, body, NULL, NULL, NULL);
913 g_printerr ("modest: failed to create new msg\n");
917 /* Create and register edit window */
918 /* This is destroyed by TODO. */
920 allowed_size = MODEST_MAX_ATTACHMENT_SIZE;
921 msg_win = modest_msg_edit_window_new (msg, account_name, mailbox, FALSE);
923 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win, win)) {
924 gtk_widget_destroy (GTK_WIDGET (msg_win));
927 modest_msg_edit_window_set_modified (MODEST_MSG_EDIT_WINDOW (msg_win), set_as_modified);
928 gtk_widget_show_all (GTK_WIDGET (msg_win));
930 while (attachments) {
931 GnomeVFSFileSize att_size;
933 modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
934 attachments->data, allowed_size);
935 total_size += att_size;
937 if (att_size > allowed_size) {
938 g_debug ("%s: total size: %u",
939 __FUNCTION__, (unsigned int)total_size);
942 allowed_size -= att_size;
944 attachments = g_slist_next(attachments);
951 g_free (account_name);
953 g_object_unref (G_OBJECT(account));
955 g_object_unref (G_OBJECT(folder));
957 g_object_unref (G_OBJECT(msg));
961 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
963 /* if there are no accounts yet, just show the wizard */
964 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
965 if (!modest_ui_actions_run_account_setup_wizard (win))
968 modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL, FALSE);
973 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
977 ModestMailOperationStatus status;
979 /* If there is no message or the operation was not successful */
980 status = modest_mail_operation_get_status (mail_op);
981 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
984 /* If it's a memory low issue, then show a banner */
985 error = modest_mail_operation_get_error (mail_op);
986 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
987 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
988 GObject *source = modest_mail_operation_get_source (mail_op);
989 modest_platform_run_information_dialog (GTK_IS_WINDOW (source) ? GTK_WINDOW (source) : NULL,
990 _KR("memr_ib_operation_disabled"),
992 g_object_unref (source);
995 if (error && ((error->code == TNY_SERVICE_ERROR_NO_SUCH_MESSAGE) ||
996 error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE)) {
997 gchar *subject, *msg, *format = NULL;
1000 subject = (header) ? tny_header_dup_subject (header) : NULL;
1002 subject = g_strdup (_("mail_va_no_subject"));
1004 account = modest_mail_operation_get_account (mail_op);
1006 ModestProtocolType proto = modest_tny_account_get_protocol_type (account);
1007 ModestProtocol *protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (), proto);
1010 if (tny_account_get_connection_status (account) ==
1011 TNY_CONNECTION_STATUS_CONNECTED) {
1012 format = modest_protocol_get_translation (protocol,
1013 MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE,
1016 format = g_strdup_printf (_("mail_ib_backend_server_invalid"),
1017 tny_account_get_hostname (account));
1020 g_object_unref (account);
1024 format = g_strdup (_("emev_ni_ui_imap_message_not_available_in_server"));
1026 msg = g_strdup_printf (format, subject);
1027 modest_platform_run_information_dialog (NULL, msg, FALSE);
1033 /* Remove the header from the preregistered uids */
1034 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1047 } OpenMsgBannerInfo;
1050 GtkTreeModel *model;
1052 ModestWindow *caller_window;
1053 OpenMsgBannerInfo *banner_info;
1054 GtkTreeRowReference *rowref;
1058 open_msg_banner_idle (gpointer userdata)
1060 OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) userdata;
1062 gdk_threads_enter ();
1063 banner_info->idle_handler = 0;
1064 banner_info->banner = modest_platform_animation_banner (NULL, NULL, banner_info->message);
1065 if (banner_info->banner)
1066 g_object_ref (banner_info->banner);
1068 gdk_threads_leave ();
1074 get_header_view_from_window (ModestWindow *window)
1076 GtkWidget *header_view;
1078 #ifndef MODEST_TOOLKIT_HILDON2
1079 if (MODEST_IS_MAIN_WINDOW (window)) {
1080 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
1081 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1083 if (MODEST_IS_HEADER_WINDOW (window)){
1084 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
1094 get_info_from_header (TnyHeader *header, gboolean *is_draft, gboolean *can_open)
1097 gchar *account = NULL;
1098 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
1103 folder = tny_header_get_folder (header);
1104 /* Gets folder type (OUTBOX headers will be opened in edit window */
1105 if (modest_tny_folder_is_local_folder (folder)) {
1106 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1107 if (folder_type == TNY_FOLDER_TYPE_INVALID)
1108 g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
1111 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
1112 TnyTransportAccount *traccount = NULL;
1113 ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
1114 traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
1116 ModestTnySendQueue *send_queue = NULL;
1117 ModestTnySendQueueStatus status;
1119 account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
1120 TNY_ACCOUNT(traccount)));
1121 send_queue = modest_runtime_get_send_queue(traccount, TRUE);
1122 if (TNY_IS_SEND_QUEUE (send_queue)) {
1123 msg_id = modest_tny_send_queue_get_msg_id (header);
1124 status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
1126 /* Only open messages in outbox with the editor if they are in Failed state */
1127 if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
1130 #ifdef MODEST_TOOLKIT_HILDON2
1132 /* In Fremantle we can not
1133 open any message from
1134 outbox which is not in
1140 g_object_unref(traccount);
1142 g_warning("Cannot get transport account for message in outbox!!");
1144 } else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
1145 *is_draft = TRUE; /* Open in editor if the message is in the Drafts folder */
1149 TnyAccount *acc = tny_folder_get_account (folder);
1152 g_strdup (modest_tny_account_get_parent_modest_account_name_for_server_account (acc));
1153 g_object_unref (acc);
1157 g_object_unref (folder);
1163 open_msg_cb (ModestMailOperation *mail_op,
1170 ModestWindowMgr *mgr = NULL;
1171 ModestWindow *parent_win = NULL;
1172 ModestWindow *win = NULL;
1173 gchar *account = NULL;
1174 gboolean open_in_editor = FALSE;
1176 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1178 /* Do nothing if there was any problem with the mail
1179 operation. The error will be shown by the error_handler of
1180 the mail operation */
1181 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1184 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
1186 /* Mark header as read */
1187 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
1189 account = get_info_from_header (header, &open_in_editor, &can_open);
1193 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
1195 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1197 if (open_in_editor) {
1198 ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
1199 gchar *from_header = NULL, *acc_name;
1200 gchar *mailbox = NULL;
1202 from_header = tny_header_dup_from (header);
1204 /* we cannot edit without a valid account... */
1205 if (!modest_account_mgr_has_accounts(mgr, TRUE)) {
1206 if (!modest_ui_actions_run_account_setup_wizard(parent_win)) {
1207 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1209 g_free (from_header);
1214 acc_name = modest_utils_get_account_name_from_recipient (from_header, &mailbox);
1215 g_free (from_header);
1221 win = modest_msg_edit_window_new (msg, account, mailbox, TRUE);
1225 gchar *uid = modest_tny_folder_get_header_unique_id (header);
1226 const gchar *mailbox = NULL;
1228 if (parent_win && MODEST_IS_WINDOW (parent_win))
1229 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_win));
1231 if (helper->rowref && helper->model) {
1232 win = modest_msg_view_window_new_with_header_model (msg, account, mailbox, (const gchar*) uid,
1233 helper->model, helper->rowref);
1235 win = modest_msg_view_window_new_for_attachment (msg, account, mailbox, (const gchar*) uid);
1240 /* Register and show new window */
1242 mgr = modest_runtime_get_window_mgr ();
1243 if (!modest_window_mgr_register_window (mgr, win, NULL)) {
1244 gtk_widget_destroy (GTK_WIDGET (win));
1247 gtk_widget_show_all (GTK_WIDGET(win));
1250 #ifndef MODEST_TOOLKIT_HILDON2
1251 /* Update toolbar dimming state */
1252 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
1253 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
1260 g_object_unref (parent_win);
1264 modest_ui_actions_disk_operations_error_handler (ModestMailOperation *mail_op,
1267 const GError *error;
1268 GObject *win = NULL;
1269 ModestMailOperationStatus status;
1271 win = modest_mail_operation_get_source (mail_op);
1272 error = modest_mail_operation_get_error (mail_op);
1273 status = modest_mail_operation_get_status (mail_op);
1275 /* If the mail op has been cancelled then it's not an error:
1276 don't show any message */
1277 if (status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
1278 TnyAccount *account = modest_mail_operation_get_account (mail_op);
1279 if (modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
1280 (GError *) error, account)) {
1281 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
1282 modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
1284 } else if (error->code == TNY_SYSTEM_ERROR_MEMORY) {
1285 modest_platform_information_banner ((GtkWidget *) win,
1286 NULL, _("emev_ui_imap_inbox_select_error"));
1287 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
1288 error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
1289 modest_platform_information_banner ((GtkWidget *) win,
1290 NULL, _CS ("sfil_ni_unable_to_open_file_not_found"));
1291 } else if (user_data) {
1292 modest_platform_information_banner ((GtkWidget *) win,
1296 g_object_unref (account);
1300 g_object_unref (win);
1304 * Returns the account a list of headers belongs to. It returns a
1305 * *new* reference so don't forget to unref it
1308 get_account_from_header_list (TnyList *headers)
1310 TnyAccount *account = NULL;
1312 if (tny_list_get_length (headers) > 0) {
1313 TnyIterator *iter = tny_list_create_iterator (headers);
1314 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1315 TnyFolder *folder = tny_header_get_folder (header);
1318 g_object_unref (header);
1320 while (!tny_iterator_is_done (iter)) {
1321 header = TNY_HEADER (tny_iterator_get_current (iter));
1322 folder = tny_header_get_folder (header);
1325 g_object_unref (header);
1327 tny_iterator_next (iter);
1332 account = tny_folder_get_account (folder);
1333 g_object_unref (folder);
1337 g_object_unref (header);
1339 g_object_unref (iter);
1345 get_account_from_header (TnyHeader *header)
1347 TnyAccount *account = NULL;
1350 folder = tny_header_get_folder (header);
1353 account = tny_folder_get_account (folder);
1354 g_object_unref (folder);
1360 caller_win_destroyed (OpenMsgHelper *helper, GObject *object)
1362 if (helper->caller_window)
1363 helper->caller_window = NULL;
1367 open_msg_helper_destroyer (gpointer user_data)
1369 OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
1371 if (helper->caller_window) {
1372 g_object_weak_unref ((GObject *) helper->caller_window, (GWeakNotify) caller_win_destroyed, helper);
1373 helper->caller_window = NULL;
1376 if (helper->banner_info) {
1377 g_free (helper->banner_info->message);
1378 if (helper->banner_info->idle_handler > 0) {
1379 g_source_remove (helper->banner_info->idle_handler);
1380 helper->banner_info->idle_handler = 0;
1382 if (helper->banner_info->banner != NULL) {
1383 gtk_widget_destroy (helper->banner_info->banner);
1384 g_object_unref (helper->banner_info->banner);
1385 helper->banner_info->banner = NULL;
1387 g_slice_free (OpenMsgBannerInfo, helper->banner_info);
1388 helper->banner_info = NULL;
1390 g_object_unref (helper->model);
1391 g_object_unref (helper->header);
1392 gtk_tree_row_reference_free (helper->rowref);
1393 g_slice_free (OpenMsgHelper, helper);
1397 open_msg_performer(gboolean canceled,
1399 GtkWindow *parent_window,
1400 TnyAccount *account,
1403 ModestMailOperation *mail_op = NULL;
1404 gchar *error_msg = NULL;
1405 ModestProtocolType proto;
1406 TnyConnectionStatus status;
1407 OpenMsgHelper *helper = NULL;
1408 ModestProtocol *protocol;
1409 ModestProtocolRegistry *protocol_registry;
1412 helper = (OpenMsgHelper *) user_data;
1414 status = tny_account_get_connection_status (account);
1415 if (err || canceled || helper->caller_window == NULL) {
1416 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1417 /* Free the helper */
1418 open_msg_helper_destroyer (helper);
1420 /* In disk full conditions we could get this error here */
1421 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
1422 (GtkWidget *) parent_window, err,
1428 /* Get the error message depending on the protocol */
1429 proto = modest_tny_account_get_protocol_type (account);
1430 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
1431 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
1434 protocol_registry = modest_runtime_get_protocol_registry ();
1435 subject = tny_header_dup_subject (helper->header);
1437 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, proto);
1438 error_msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
1442 if (error_msg == NULL) {
1443 error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1446 #ifndef MODEST_TOOLKIT_HILDON2
1447 gboolean show_open_draft = FALSE;
1448 if (modest_protocol_registry_protocol_type_has_tag (protocol_registry,
1450 MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS)) {
1452 TnyFolderType folder_type;
1454 folder = tny_header_get_folder (helper->header);
1455 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1456 show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
1457 g_object_unref (folder);
1461 #ifdef MODEST_TOOLKIT_HILDON2
1464 gchar *account_name = get_info_from_header (helper->header, &is_draft, &can_open);
1467 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
1468 g_free (account_name);
1469 open_msg_helper_destroyer (helper);
1474 ModestWindow *window;
1475 GtkWidget *header_view;
1478 header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
1479 uid = modest_tny_folder_get_header_unique_id (helper->header);
1481 const gchar *mailbox = NULL;
1482 mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_window));
1483 window = modest_msg_view_window_new_from_header_view
1484 (MODEST_HEADER_VIEW (header_view), account_name, mailbox, uid, helper->rowref);
1485 if (window != NULL) {
1486 if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr (),
1488 gtk_widget_destroy (GTK_WIDGET (window));
1490 gtk_widget_show_all (GTK_WIDGET(window));
1494 g_free (account_name);
1496 open_msg_helper_destroyer (helper);
1499 g_free (account_name);
1501 /* Create the mail operation */
1503 modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
1504 modest_ui_actions_disk_operations_error_handler,
1505 g_strdup (error_msg), g_free);
1506 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1510 #ifndef MODEST_TOOLKIT_HILDON2
1511 if (show_open_draft) {
1512 helper->banner_info = g_slice_new (OpenMsgBannerInfo);
1513 helper->banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
1514 helper->banner_info->banner = NULL;
1515 helper->banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle,
1516 helper->banner_info);
1522 headers = TNY_LIST (tny_simple_list_new ());
1523 tny_list_prepend (headers, G_OBJECT (helper->header));
1524 modest_mail_operation_get_msgs_full (mail_op,
1528 open_msg_helper_destroyer);
1529 g_object_unref (headers);
1536 g_object_unref (mail_op);
1537 g_object_unref (account);
1541 * This function is used by both modest_ui_actions_on_open and
1542 * modest_ui_actions_on_header_activated. This way we always do the
1543 * same when trying to open messages.
1546 open_msg_from_header (TnyHeader *header, GtkTreeRowReference *rowref, ModestWindow *win)
1548 ModestWindowMgr *mgr = NULL;
1549 TnyAccount *account;
1550 gboolean cached = FALSE;
1552 GtkWidget *header_view = NULL;
1553 OpenMsgHelper *helper;
1554 ModestWindow *window;
1556 g_return_if_fail (header != NULL && rowref != NULL && gtk_tree_row_reference_valid (rowref));
1558 mgr = modest_runtime_get_window_mgr ();
1561 header_view = get_header_view_from_window (MODEST_WINDOW (win));
1562 if (header_view == NULL)
1565 /* Get the account */
1566 account = get_account_from_header (header);
1571 found = modest_window_mgr_find_registered_header (mgr, header, &window);
1573 /* Do not open again the message and present the
1574 window to the user */
1577 #ifndef MODEST_TOOLKIT_HILDON2
1578 gtk_window_present (GTK_WINDOW (window));
1581 /* the header has been registered already, we don't do
1582 * anything but wait for the window to come up*/
1583 g_debug ("header %p already registered, waiting for window", header);
1588 /* Open each message */
1589 cached = tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED;
1591 /* Allways download if we are online. */
1592 if (!tny_device_is_online (modest_runtime_get_device ())) {
1595 /* If ask for user permission to download the messages */
1596 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1597 _("mcen_nc_get_msg"));
1599 /* End if the user does not want to continue */
1600 if (response == GTK_RESPONSE_CANCEL) {
1606 /* We register the window for opening */
1607 modest_window_mgr_register_header (mgr, header, NULL);
1609 /* Create the helper. We need to get a reference to the model
1610 here because it could change while the message is readed
1611 (the user could switch between folders) */
1612 helper = g_slice_new (OpenMsgHelper);
1613 helper->model = g_object_ref (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)));
1614 helper->caller_window = win;
1615 g_object_weak_ref ((GObject *) helper->caller_window, (GWeakNotify) caller_win_destroyed, helper);
1616 helper->header = g_object_ref (header);
1617 helper->rowref = gtk_tree_row_reference_copy (rowref);
1618 helper->banner_info = NULL;
1620 /* Connect to the account and perform */
1622 modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
1623 open_msg_performer, helper);
1625 /* Call directly the performer, do not need to connect */
1626 open_msg_performer (FALSE, NULL, (GtkWindow *) win,
1627 g_object_ref (account), helper);
1632 g_object_unref (account);
1636 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1643 /* we check for low-mem; in that case, show a warning, and don't allow
1646 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1650 headers = get_selected_headers (win);
1654 headers_count = tny_list_get_length (headers);
1655 if (headers_count != 1) {
1656 if (headers_count > 1) {
1657 /* Don't allow activation if there are more than one message selected */
1658 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
1661 g_object_unref (headers);
1665 iter = tny_list_create_iterator (headers);
1666 header = TNY_HEADER (tny_iterator_get_current (iter));
1667 g_object_unref (iter);
1671 open_msg_from_header (header, NULL, win);
1672 g_object_unref (header);
1675 g_object_unref(headers);
1679 rf_helper_window_closed (gpointer data,
1682 ReplyForwardHelper *helper = (ReplyForwardHelper *) data;
1684 helper->parent_window = NULL;
1687 static ReplyForwardHelper*
1688 create_reply_forward_helper (ReplyForwardAction action,
1690 guint reply_forward_type,
1693 ReplyForwardHelper *rf_helper = NULL;
1694 const gchar *active_acc = modest_window_get_active_account (win);
1695 const gchar *active_mailbox = modest_window_get_active_mailbox (win);
1697 rf_helper = g_slice_new0 (ReplyForwardHelper);
1698 rf_helper->reply_forward_type = reply_forward_type;
1699 rf_helper->action = action;
1700 rf_helper->parent_window = (MODEST_IS_WINDOW (win)) ? GTK_WIDGET (win) : NULL;
1701 rf_helper->header = (header) ? g_object_ref (header) : NULL;
1702 rf_helper->account_name = (active_acc) ?
1703 g_strdup (active_acc) :
1704 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1705 rf_helper->mailbox = g_strdup (active_mailbox);
1707 /* Note that window could be destroyed just AFTER calling
1708 register_window so we must ensure that this pointer does
1709 not hold invalid references */
1710 if (rf_helper->parent_window)
1711 g_object_weak_ref (G_OBJECT (rf_helper->parent_window),
1712 rf_helper_window_closed, rf_helper);
1718 free_reply_forward_helper (gpointer data)
1720 ReplyForwardHelper *helper;
1722 helper = (ReplyForwardHelper *) data;
1723 g_free (helper->account_name);
1724 g_free (helper->mailbox);
1726 g_object_unref (helper->header);
1727 if (helper->parent_window)
1728 g_object_weak_unref (G_OBJECT (helper->parent_window),
1729 rf_helper_window_closed, helper);
1730 g_slice_free (ReplyForwardHelper, helper);
1734 reply_forward_cb (ModestMailOperation *mail_op,
1741 TnyMsg *new_msg = NULL;
1742 ReplyForwardHelper *rf_helper;
1743 ModestWindow *msg_win = NULL;
1744 ModestEditType edit_type;
1746 TnyAccount *account = NULL;
1747 ModestWindowMgr *mgr = NULL;
1748 gchar *signature = NULL;
1749 gboolean use_signature;
1752 /* If there was any error. The mail operation could be NULL,
1753 this means that we already have the message downloaded and
1754 that we didn't do a mail operation to retrieve it */
1755 rf_helper = (ReplyForwardHelper *) user_data;
1756 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1759 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1760 rf_helper->account_name, rf_helper->mailbox);
1761 recipient = modest_text_utils_get_email_address (from);
1762 signature = modest_account_mgr_get_signature_from_recipient (modest_runtime_get_account_mgr(),
1767 /* Create reply mail */
1768 switch (rf_helper->action) {
1769 /* Use the msg_header to ensure that we have all the
1770 information. The summary can lack some data */
1771 TnyHeader *msg_header;
1773 msg_header = tny_msg_get_header (msg);
1775 modest_tny_msg_create_reply_msg (msg, msg_header, from,
1776 (use_signature) ? signature : NULL,
1777 rf_helper->reply_forward_type,
1778 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1779 g_object_unref (msg_header);
1781 case ACTION_REPLY_TO_ALL:
1782 msg_header = tny_msg_get_header (msg);
1784 modest_tny_msg_create_reply_msg (msg, msg_header, from,
1785 (use_signature) ? signature : NULL,
1786 rf_helper->reply_forward_type,
1787 MODEST_TNY_MSG_REPLY_MODE_ALL);
1788 edit_type = MODEST_EDIT_TYPE_REPLY;
1789 g_object_unref (msg_header);
1791 case ACTION_FORWARD:
1793 modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL,
1794 rf_helper->reply_forward_type);
1795 edit_type = MODEST_EDIT_TYPE_FORWARD;
1798 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1800 g_return_if_reached ();
1808 g_warning ("%s: failed to create message\n", __FUNCTION__);
1812 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1813 rf_helper->account_name,
1814 TNY_ACCOUNT_TYPE_STORE);
1816 g_warning ("%s: failed to get tnyaccount for '%s'\n", __FUNCTION__, rf_helper->account_name);
1820 /* Create and register the windows */
1821 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, rf_helper->mailbox, FALSE);
1822 mgr = modest_runtime_get_window_mgr ();
1823 modest_window_mgr_register_window (mgr, msg_win, (ModestWindow *) rf_helper->parent_window);
1825 /* Note that register_window could have deleted the account */
1826 if (MODEST_IS_WINDOW (rf_helper->parent_window)) {
1827 gdouble parent_zoom;
1829 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1830 modest_window_set_zoom (msg_win, parent_zoom);
1833 /* Show edit window */
1834 gtk_widget_show_all (GTK_WIDGET (msg_win));
1837 /* We always unregister the header because the message is
1838 forwarded or replied so the original one is no longer
1840 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
1843 g_object_unref (G_OBJECT (new_msg));
1845 g_object_unref (G_OBJECT (account));
1846 free_reply_forward_helper (rf_helper);
1849 /* Checks a list of headers. If any of them are not currently
1850 * downloaded (CACHED) then returns TRUE else returns FALSE.
1853 header_list_count_uncached_msgs (TnyList *header_list)
1856 gint uncached_messages = 0;
1858 iter = tny_list_create_iterator (header_list);
1859 while (!tny_iterator_is_done (iter)) {
1862 header = TNY_HEADER (tny_iterator_get_current (iter));
1864 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1865 uncached_messages ++;
1866 g_object_unref (header);
1869 tny_iterator_next (iter);
1871 g_object_unref (iter);
1873 return uncached_messages;
1876 /* Returns FALSE if the user does not want to download the
1877 * messages. Returns TRUE if the user allowed the download.
1880 connect_to_get_msg (ModestWindow *win,
1881 gint num_of_uncached_msgs,
1882 TnyAccount *account)
1884 GtkResponseType response;
1886 /* Allways download if we are online. */
1887 if (tny_device_is_online (modest_runtime_get_device ()))
1890 /* If offline, then ask for user permission to download the messages */
1891 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1892 ngettext("mcen_nc_get_msg",
1894 num_of_uncached_msgs));
1896 if (response == GTK_RESPONSE_CANCEL)
1899 return modest_platform_connect_and_wait((GtkWindow *) win, account);
1903 reply_forward_performer (gboolean canceled,
1905 GtkWindow *parent_window,
1906 TnyAccount *account,
1909 ReplyForwardHelper *rf_helper = NULL;
1910 ModestMailOperation *mail_op;
1912 rf_helper = (ReplyForwardHelper *) user_data;
1914 if (canceled || err) {
1915 free_reply_forward_helper (rf_helper);
1919 /* Retrieve the message */
1920 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), rf_helper->header, NULL);
1921 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (parent_window),
1922 modest_ui_actions_disk_operations_error_handler,
1924 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1925 modest_mail_operation_get_msg (mail_op, rf_helper->header, TRUE, reply_forward_cb, rf_helper);
1928 g_object_unref(mail_op);
1932 * Common code for the reply and forward actions
1935 reply_forward (ReplyForwardAction action, ModestWindow *win)
1937 ReplyForwardHelper *rf_helper = NULL;
1938 guint reply_forward_type;
1940 g_return_if_fail (win && MODEST_IS_WINDOW(win));
1942 /* we check for low-mem; in that case, show a warning, and don't allow
1943 * reply/forward (because it could potentially require a lot of memory */
1944 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
1948 /* we need an account when editing */
1949 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1950 if (!modest_ui_actions_run_account_setup_wizard (win))
1954 reply_forward_type =
1955 modest_conf_get_int (modest_runtime_get_conf (),
1956 (action == ACTION_FORWARD) ?
1957 MODEST_CONF_FORWARD_TYPE :
1958 MODEST_CONF_REPLY_TYPE,
1961 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1963 TnyHeader *header = NULL;
1964 /* Get header and message. Do not free them here, the
1965 reply_forward_cb must do it */
1966 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1967 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
1969 if (msg && header) {
1971 rf_helper = create_reply_forward_helper (action, win,
1972 reply_forward_type, header);
1973 reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
1975 g_warning("%s: no message or header found in viewer\n", __FUNCTION__);
1979 g_object_unref (msg);
1981 g_object_unref (header);
1983 TnyHeader *header = NULL;
1985 gboolean do_retrieve = TRUE;
1986 TnyList *header_list = NULL;
1988 header_list = get_selected_headers (win);
1991 /* Check that only one message is selected for replying */
1992 if (tny_list_get_length (header_list) != 1) {
1993 modest_platform_information_banner ((win) ? GTK_WIDGET (win) : NULL,
1994 NULL, _("mcen_ib_select_one_message"));
1995 g_object_unref (header_list);
1999 /* Only reply/forward to one message */
2000 iter = tny_list_create_iterator (header_list);
2001 header = TNY_HEADER (tny_iterator_get_current (iter));
2002 g_object_unref (iter);
2004 /* Retrieve messages */
2005 do_retrieve = (action == ACTION_FORWARD) ||
2006 (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
2009 TnyAccount *account = NULL;
2010 TnyFolder *folder = NULL;
2011 gdouble download = TRUE;
2012 guint uncached_msgs = 0;
2014 folder = tny_header_get_folder (header);
2016 goto do_retrieve_frees;
2017 account = tny_folder_get_account (folder);
2019 goto do_retrieve_frees;
2021 uncached_msgs = header_list_count_uncached_msgs (header_list);
2023 if (uncached_msgs > 0) {
2024 /* Allways download if we are online. */
2025 if (!tny_device_is_online (modest_runtime_get_device ())) {
2028 /* If ask for user permission to download the messages */
2029 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2030 ngettext("mcen_nc_get_msg",
2034 /* End if the user does not want to continue */
2035 if (response == GTK_RESPONSE_CANCEL)
2042 rf_helper = create_reply_forward_helper (action, win,
2043 reply_forward_type, header);
2044 if (uncached_msgs > 0) {
2045 modest_platform_connect_and_perform (GTK_WINDOW (win),
2047 reply_forward_performer,
2050 reply_forward_performer (FALSE, NULL, GTK_WINDOW (win),
2051 account, rf_helper);
2056 g_object_unref (account);
2058 g_object_unref (folder);
2060 reply_forward_cb (NULL, header, FALSE, NULL, NULL, NULL);
2063 g_object_unref (header_list);
2064 g_object_unref (header);
2069 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
2071 g_return_if_fail (MODEST_IS_WINDOW(win));
2073 reply_forward (ACTION_REPLY, win);
2077 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
2079 g_return_if_fail (MODEST_IS_WINDOW(win));
2081 reply_forward (ACTION_FORWARD, win);
2085 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
2087 g_return_if_fail (MODEST_IS_WINDOW(win));
2089 reply_forward (ACTION_REPLY_TO_ALL, win);
2093 modest_ui_actions_on_next (GtkAction *action,
2094 ModestWindow *window)
2096 #ifndef MODEST_TOOLKIT_HILDON2
2097 if (MODEST_IS_MAIN_WINDOW (window)) {
2098 GtkWidget *header_view;
2100 header_view = modest_main_window_get_child_widget (
2101 MODEST_MAIN_WINDOW(window),
2102 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2106 modest_header_view_select_next (
2107 MODEST_HEADER_VIEW(header_view));
2109 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2110 modest_msg_view_window_select_next_message (
2111 MODEST_MSG_VIEW_WINDOW (window));
2114 g_return_if_reached ();
2119 modest_ui_actions_on_prev (GtkAction *action,
2120 ModestWindow *window)
2122 g_return_if_fail (MODEST_IS_WINDOW(window));
2124 #ifndef MODEST_TOOLKIT_HILDON2
2125 if (MODEST_IS_MAIN_WINDOW (window)) {
2126 GtkWidget *header_view;
2127 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2128 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2132 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
2134 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2135 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
2138 g_return_if_reached ();
2143 modest_ui_actions_on_sort (GtkAction *action,
2144 ModestWindow *window)
2146 GtkWidget *header_view = NULL;
2148 g_return_if_fail (MODEST_IS_WINDOW(window));
2150 #ifndef MODEST_TOOLKIT_HILDON2
2151 if (MODEST_IS_MAIN_WINDOW (window)) {
2152 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
2153 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2155 if (MODEST_IS_HEADER_WINDOW (window)) {
2156 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
2161 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
2166 /* Show sorting dialog */
2167 modest_utils_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
2171 sync_folder_cb (ModestMailOperation *mail_op,
2175 ModestHeaderView *header_view = (ModestHeaderView *) user_data;
2177 if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
2178 ModestWindow *parent = (ModestWindow *) modest_mail_operation_get_source (mail_op);
2180 /* We must clear first, because otherwise set_folder will ignore */
2181 /* the change as the folders are the same */
2182 modest_header_view_clear (header_view);
2183 modest_header_view_set_folder (header_view, folder, TRUE, parent, NULL, NULL);
2185 g_object_unref (parent);
2188 g_object_unref (header_view);
2192 idle_refresh_folder (gpointer source)
2194 ModestHeaderView *header_view = NULL;
2196 /* If the window still exists */
2197 if (!GTK_IS_WIDGET (source) ||
2198 !GTK_WIDGET_VISIBLE (source))
2201 /* Refresh the current view */
2202 #ifdef MODEST_TOOLKIT_HILDON2
2203 if (MODEST_IS_HEADER_WINDOW (source))
2204 header_view = modest_header_window_get_header_view ((ModestHeaderWindow *) source);
2206 if (MODEST_IS_MAIN_WINDOW (source))
2207 header_view = MODEST_HEADER_VIEW (modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source),
2208 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW));
2211 TnyFolder *folder = modest_header_view_get_folder (header_view);
2213 /* Sync the folder status */
2214 ModestMailOperation *mail_op = modest_mail_operation_new (source);
2215 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2216 modest_mail_operation_sync_folder (mail_op, folder, FALSE, sync_folder_cb, g_object_ref (header_view));
2217 g_object_unref (folder);
2218 g_object_unref (mail_op);
2226 update_account_cb (ModestMailOperation *self,
2227 TnyList *new_headers,
2231 gboolean show_visual_notifications;
2233 top = modest_window_mgr_get_current_top (modest_runtime_get_window_mgr ());
2234 show_visual_notifications = (top) ? FALSE : TRUE;
2236 /* Notify new messages have been downloaded. If the
2237 send&receive was invoked by the user then do not show any
2238 visual notification, only play a sound and activate the LED
2239 (for the Maemo version) */
2240 if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0) {
2242 /* We only notify about really new messages (not seen) we get */
2243 TnyList *actually_new_list;
2244 TnyIterator *iterator;
2245 actually_new_list = TNY_LIST (tny_simple_list_new ());
2246 for (iterator = tny_list_create_iterator (new_headers);
2247 !tny_iterator_is_done (iterator);
2248 tny_iterator_next (iterator)) {
2250 TnyHeaderFlags flags;
2251 header = TNY_HEADER (tny_iterator_get_current (iterator));
2252 flags = tny_header_get_flags (header);
2254 if (!(flags & TNY_HEADER_FLAG_SEEN)) {
2255 /* Messages are ordered from most
2256 recent to oldest. But we want to
2257 show notifications starting from
2258 the oldest message. That's why we
2260 tny_list_prepend (actually_new_list, G_OBJECT (header));
2262 g_object_unref (header);
2264 g_object_unref (iterator);
2266 if (tny_list_get_length (actually_new_list) > 0) {
2267 GList *new_headers_list = NULL;
2269 new_headers_list = modest_utils_create_notification_list_from_header_list (actually_new_list);
2271 /* Send notifications */
2272 if (new_headers_list) {
2273 modest_platform_on_new_headers_received (new_headers_list,
2274 show_visual_notifications);
2276 modest_utils_free_notification_list (new_headers_list);
2279 g_object_unref (actually_new_list);
2283 /* Refresh the current folder in an idle. We do this
2284 in order to avoid refresh cancelations if the
2285 currently viewed folder is the inbox */
2286 g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
2287 idle_refresh_folder,
2294 TnyAccount *account;
2296 gchar *account_name;
2297 gboolean poke_status;
2298 gboolean interactive;
2299 ModestMailOperation *mail_op;
2303 do_send_receive_performer (gboolean canceled,
2305 GtkWindow *parent_window,
2306 TnyAccount *account,
2309 SendReceiveInfo *info;
2311 info = (SendReceiveInfo *) user_data;
2313 if (err || canceled) {
2314 /* In disk full conditions we could get this error here */
2315 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
2316 (GtkWidget *) parent_window, err,
2319 if (info->mail_op) {
2320 modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (),
2326 #ifndef MODEST_TOOLKIT_HILDON2
2327 /* Set send/receive operation in progress */
2328 if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
2329 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
2332 if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
2333 g_signal_connect (G_OBJECT (info->mail_op), "operation-finished",
2334 G_CALLBACK (on_send_receive_finished),
2338 /* Send & receive. */
2339 modest_mail_operation_update_account (info->mail_op, info->account_name,
2340 info->poke_status, info->interactive,
2341 update_account_cb, info->win);
2346 g_object_unref (G_OBJECT (info->mail_op));
2347 if (info->account_name)
2348 g_free (info->account_name);
2350 g_object_unref (info->win);
2352 g_object_unref (info->account);
2353 g_slice_free (SendReceiveInfo, info);
2357 * This function performs the send & receive required actions. The
2358 * window is used to create the mail operation. Typically it should
2359 * always be the main window, but we pass it as argument in order to
2363 modest_ui_actions_do_send_receive (const gchar *account_name,
2364 gboolean force_connection,
2365 gboolean poke_status,
2366 gboolean interactive,
2369 gchar *acc_name = NULL;
2370 SendReceiveInfo *info;
2371 ModestTnyAccountStore *acc_store;
2372 TnyAccount *account;
2374 /* If no account name was provided then get the current account, and if
2375 there is no current account then pick the default one: */
2376 if (!account_name) {
2378 acc_name = g_strdup (modest_window_get_active_account (win));
2380 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
2382 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2386 acc_name = g_strdup (account_name);
2389 acc_store = modest_runtime_get_account_store ();
2390 account = modest_tny_account_store_get_server_account (acc_store, acc_name, TNY_ACCOUNT_TYPE_STORE);
2394 modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
2398 /* Do not automatically refresh accounts that are flagged as
2399 NO_AUTO_UPDATE. This could be useful for accounts that
2400 handle their own update times */
2402 ModestProtocolType proto = modest_tny_account_get_protocol_type (account);
2403 if (proto != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
2404 const gchar *tag = MODEST_PROTOCOL_REGISTRY_NO_AUTO_UPDATE_PROTOCOLS;
2405 ModestProtocolRegistry *registry = modest_runtime_get_protocol_registry ();
2407 if (modest_protocol_registry_protocol_type_has_tag (registry, proto, tag)) {
2408 g_debug ("%s no auto update allowed for account %s", __FUNCTION__, account_name);
2409 g_object_unref (account);
2416 /* Create the info for the connect and perform */
2417 info = g_slice_new (SendReceiveInfo);
2418 info->account_name = acc_name;
2419 info->win = (win) ? g_object_ref (win) : NULL;
2420 info->poke_status = poke_status;
2421 info->interactive = interactive;
2422 info->account = account;
2423 /* We need to create the operation here, because otherwise it
2424 could happen that the queue emits the queue-empty signal
2425 while we're trying to connect the account */
2426 info->mail_op = modest_mail_operation_new_with_error_handling ((info->win) ? G_OBJECT (info->win) : NULL,
2427 modest_ui_actions_disk_operations_error_handler,
2429 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), info->mail_op);
2431 /* Invoke the connect and perform */
2432 modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
2433 force_connection, info->account,
2434 do_send_receive_performer, info);
2439 modest_ui_actions_do_cancel_send (const gchar *account_name,
2442 TnyTransportAccount *transport_account;
2443 TnySendQueue *send_queue = NULL;
2444 GError *error = NULL;
2446 /* Get transport account */
2448 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2449 (modest_runtime_get_account_store(),
2451 TNY_ACCOUNT_TYPE_TRANSPORT));
2452 if (!transport_account) {
2453 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2458 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account, TRUE));
2459 if (!TNY_IS_SEND_QUEUE(send_queue)) {
2460 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
2461 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
2462 "modest: could not find send queue for account\n");
2464 /* Cancel the current send */
2465 tny_account_cancel (TNY_ACCOUNT (transport_account));
2467 /* Suspend all pending messages */
2468 tny_send_queue_cancel (send_queue, TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, &error);
2472 if (transport_account != NULL)
2473 g_object_unref (G_OBJECT (transport_account));
2477 modest_ui_actions_cancel_send_all (ModestWindow *win)
2479 GSList *account_names, *iter;
2481 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2484 iter = account_names;
2486 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
2487 iter = g_slist_next (iter);
2490 modest_account_mgr_free_account_names (account_names);
2491 account_names = NULL;
2495 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
2498 /* Check if accounts exist */
2499 gboolean accounts_exist =
2500 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2502 /* If not, allow the user to create an account before trying to send/receive. */
2503 if (!accounts_exist)
2504 modest_ui_actions_on_accounts (NULL, win);
2506 /* Cancel all sending operaitons */
2507 modest_ui_actions_cancel_send_all (win);
2511 * Refreshes all accounts. This function will be used by automatic
2515 modest_ui_actions_do_send_receive_all (ModestWindow *win,
2516 gboolean force_connection,
2517 gboolean poke_status,
2518 gboolean interactive)
2520 GSList *account_names, *iter;
2522 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
2525 iter = account_names;
2527 modest_ui_actions_do_send_receive ((const char*) iter->data,
2529 poke_status, interactive, win);
2530 iter = g_slist_next (iter);
2533 modest_account_mgr_free_account_names (account_names);
2534 account_names = NULL;
2538 * Handler of the click on Send&Receive button in the main toolbar
2541 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
2543 /* Check if accounts exist */
2544 gboolean accounts_exist;
2547 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
2549 /* If not, allow the user to create an account before trying to send/receive. */
2550 if (!accounts_exist)
2551 modest_ui_actions_on_accounts (NULL, win);
2553 /* Refresh the current folder. The if is always TRUE it's just an extra check */
2554 #ifndef MODEST_TOOLKIT_HILDON2
2555 if (MODEST_IS_MAIN_WINDOW (win)) {
2556 GtkWidget *folder_view;
2557 TnyFolderStore *folder_store;
2560 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2561 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2565 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2568 g_object_unref (folder_store);
2569 /* Refresh the active account. Force the connection if needed
2570 and poke the status of all folders */
2571 modest_ui_actions_do_send_receive (NULL, TRUE, TRUE, TRUE, win);
2573 if (MODEST_IS_ACCOUNTS_WINDOW (win)) {
2574 modest_ui_actions_do_send_receive_all (win, TRUE, TRUE, TRUE);
2577 const gchar *active_account;
2578 active_account = modest_window_get_active_account (MODEST_WINDOW (win));
2580 modest_ui_actions_do_send_receive (active_account, TRUE, TRUE, TRUE, win);
2585 #ifndef MODEST_TOOLKIT_HILDON2
2587 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
2590 GtkWidget *header_view;
2592 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2594 header_view = modest_main_window_get_child_widget (main_window,
2595 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2599 conf = modest_runtime_get_conf ();
2601 /* what is saved/restored is depending on the style; thus; we save with
2602 * old style, then update the style, and restore for this new style
2604 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
2606 if (modest_header_view_get_style
2607 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
2608 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2609 MODEST_HEADER_VIEW_STYLE_TWOLINES);
2611 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
2612 MODEST_HEADER_VIEW_STYLE_DETAILS);
2614 modest_widget_memory_restore (conf, G_OBJECT(header_view),
2615 MODEST_CONF_HEADER_VIEW_KEY);
2619 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
2621 ModestMainWindow *main_window)
2623 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2624 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2626 /* in the case the folder is empty, show the empty folder message and focus
2628 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
2629 if (modest_header_view_is_empty (header_view)) {
2630 TnyFolder *folder = modest_header_view_get_folder (header_view);
2631 GtkWidget *folder_view =
2632 modest_main_window_get_child_widget (main_window,
2633 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2634 if (folder != NULL) {
2635 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
2636 g_object_unref (folder);
2638 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
2642 /* If no header has been selected then exit */
2647 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
2648 gtk_widget_grab_focus (GTK_WIDGET(header_view));
2650 /* Update toolbar dimming state */
2651 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2652 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2657 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
2660 ModestWindow *window)
2662 GtkTreeRowReference *rowref;
2664 g_return_if_fail (MODEST_IS_WINDOW(window));
2665 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2666 g_return_if_fail (TNY_IS_HEADER (header));
2668 if (modest_header_view_count_selected_headers (header_view) > 1) {
2669 /* Don't allow activation if there are more than one message selected */
2670 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
2674 /* we check for low-mem; in that case, show a warning, and don't allow
2675 * activating headers
2677 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
2680 #ifndef MODEST_TOOLKIT_HILDON2
2681 GtkWidget *open_widget;
2682 if (MODEST_IS_MAIN_WINDOW (window)) {
2683 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
2684 open_widget = modest_window_get_action_widget (MODEST_WINDOW (window), "/MenuBar/EmailMenu/EmailOpenMenu");
2685 if (!GTK_WIDGET_IS_SENSITIVE (open_widget))
2690 rowref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)), path);
2691 open_msg_from_header (header, rowref, MODEST_WINDOW (window));
2692 gtk_tree_row_reference_free (rowref);
2695 #ifndef MODEST_TOOLKIT_HILDON2
2697 set_active_account_from_tny_account (TnyAccount *account,
2698 ModestWindow *window)
2700 const gchar *server_acc_name = tny_account_get_id (account);
2702 /* We need the TnyAccount provided by the
2703 account store because that is the one that
2704 knows the name of the Modest account */
2705 TnyAccount *modest_server_account =
2706 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
2707 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
2709 if (!modest_server_account) {
2710 g_warning ("%s: could not get tny account\n", __FUNCTION__);
2714 /* Update active account, but only if it's not a pseudo-account */
2715 if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
2716 (!modest_tny_account_is_memory_card_account(modest_server_account))) {
2717 const gchar *modest_acc_name =
2718 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
2719 if (modest_acc_name)
2720 modest_window_set_active_account (window, modest_acc_name);
2723 g_object_unref (modest_server_account);
2727 folder_refreshed_cb (ModestMailOperation *mail_op,
2731 ModestMainWindow *win = NULL;
2732 GtkWidget *folder_view, *header_view;
2733 const GError *error;
2735 g_return_if_fail (TNY_IS_FOLDER (folder));
2737 win = MODEST_MAIN_WINDOW (user_data);
2739 /* Check if the operation failed due to memory low conditions */
2740 error = modest_mail_operation_get_error (mail_op);
2741 if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
2742 error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
2743 modest_platform_run_information_dialog (GTK_WINDOW (win),
2744 _KR("memr_ib_operation_disabled"),
2750 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2752 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2755 TnyFolderStore *current_folder;
2757 current_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2758 if (current_folder) {
2759 gboolean different = ((TnyFolderStore *) folder != current_folder);
2760 g_object_unref (current_folder);
2766 /* Check if folder is empty and set headers view contents style */
2767 if ((tny_folder_get_all_count (folder) == 0) ||
2768 modest_header_view_is_empty (MODEST_HEADER_VIEW (header_view)))
2769 modest_main_window_set_contents_style (win,
2770 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2774 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2775 TnyFolderStore *folder_store,
2777 ModestMainWindow *main_window)
2779 GtkWidget *header_view;
2781 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2783 header_view = modest_main_window_get_child_widget(main_window,
2784 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2789 if (TNY_IS_ACCOUNT (folder_store)) {
2791 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2793 /* Show account details */
2794 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2797 if (TNY_IS_FOLDER (folder_store) && selected) {
2798 TnyAccount *account;
2800 /* Update the active account */
2801 account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2803 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2804 g_object_unref (account);
2808 /* Set the header style by default, it could
2809 be changed later by the refresh callback to
2811 modest_main_window_set_contents_style (main_window,
2812 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2814 /* Set folder on header view. This function
2815 will call tny_folder_refresh_async so we
2816 pass a callback that will be called when
2817 finished. We use that callback to set the
2818 empty view if there are no messages */
2819 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2820 TNY_FOLDER (folder_store),
2822 MODEST_WINDOW (main_window),
2823 folder_refreshed_cb,
2826 /* Restore configuration. We need to do this
2827 *after* the set_folder because the widget
2828 memory asks the header view about its
2830 modest_widget_memory_restore (modest_runtime_get_conf (),
2831 G_OBJECT(header_view),
2832 MODEST_CONF_HEADER_VIEW_KEY);
2834 /* No need to save the header view
2835 configuration for Maemo because it only
2836 saves the sorting stuff and that it's
2837 already being done by the sort
2838 dialog. Remove it when the GNOME version
2839 has the same behaviour */
2840 #ifdef MODEST_TOOLKIT_GTK
2841 if (modest_main_window_get_contents_style (main_window) ==
2842 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2843 modest_widget_memory_save (modest_runtime_get_conf (),
2844 G_OBJECT (header_view),
2845 MODEST_CONF_HEADER_VIEW_KEY);
2847 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2851 /* Update dimming state */
2852 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2853 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2858 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2865 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2867 online = tny_device_is_online (modest_runtime_get_device());
2870 /* already online -- the item is simply not there... */
2871 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2873 GTK_MESSAGE_WARNING,
2875 _("The %s you selected cannot be found"),
2877 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2878 gtk_dialog_run (GTK_DIALOG(dialog));
2880 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2883 _("mcen_bd_dialog_cancel"),
2884 GTK_RESPONSE_REJECT,
2885 _("mcen_bd_dialog_ok"),
2886 GTK_RESPONSE_ACCEPT,
2888 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2889 "Do you want to get online?"), item);
2890 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
2891 gtk_label_new (txt), FALSE, FALSE, 0);
2892 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2895 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2896 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2897 /* TODO: Comment about why is this commented out: */
2898 /* modest_platform_connect_and_wait (); */
2901 gtk_widget_destroy (dialog);
2905 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2908 /* g_debug ("%s %s", __FUNCTION__, link); */
2913 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2916 modest_platform_activate_uri (link);
2920 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2923 modest_platform_show_uri_popup (link);
2927 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2930 /* we check for low-mem; in that case, show a warning, and don't allow
2931 * viewing attachments
2933 if (modest_platform_check_memory_low (MODEST_WINDOW(win), TRUE))
2936 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2940 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2941 const gchar *address,
2944 /* g_debug ("%s %s", __FUNCTION__, address); */
2948 on_save_to_drafts_cb (ModestMailOperation *mail_op,
2949 TnyMsg *saved_draft,
2952 ModestMsgEditWindow *edit_window;
2954 /* TODO: in hildon 2 we have to dim and undim the header views while we're saving */
2955 #ifndef MODEST_TOOLKIT_HILDON2
2956 ModestMainWindow *win;
2958 /* FIXME. Make the header view sensitive again. This is a
2959 * temporary hack. See modest_ui_actions_on_save_to_drafts()
2961 win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2962 modest_runtime_get_window_mgr(), FALSE));
2964 GtkWidget *hdrview = modest_main_window_get_child_widget(
2965 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2966 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2970 edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2972 /* Set draft is there was no error */
2973 if (!modest_mail_operation_get_error (mail_op))
2974 modest_msg_edit_window_set_draft (edit_window, saved_draft);
2976 g_object_unref(edit_window);
2980 enough_space_for_message (ModestMsgEditWindow *edit_window,
2983 guint64 available_disk, expected_size;
2988 available_disk = modest_utils_get_available_space (NULL);
2989 modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2990 expected_size = modest_tny_msg_estimate_size (data->plain_body,
2995 /* Double check: disk full condition or message too big */
2996 if (available_disk < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE ||
2997 expected_size > available_disk) {
2998 gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
2999 modest_platform_information_banner (NULL, NULL, msg);
3006 * djcb: if we're in low-memory state, we only allow for
3007 * saving messages smaller than
3008 * MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE (see modest-defs.h) this
3009 * should still allow for sending anything critical...
3011 if ((expected_size > MODEST_MAX_LOW_MEMORY_MESSAGE_SIZE) &&
3012 modest_platform_check_memory_low (MODEST_WINDOW(edit_window), TRUE))
3016 * djcb: we also make sure that the attachments are smaller than the max size
3017 * this is for the case where we'd try to forward a message with attachments
3018 * bigger than our max allowed size, or sending an message from drafts which
3019 * somehow got past our checks when attaching.
3021 if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
3022 modest_platform_run_information_dialog (
3023 GTK_WINDOW(edit_window),
3024 _("mail_ib_error_attachment_size"),
3033 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
3035 TnyTransportAccount *transport_account;
3036 ModestMailOperation *mail_operation;
3038 gchar *account_name;
3039 ModestAccountMgr *account_mgr;
3040 gboolean had_error = FALSE;
3042 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
3044 data = modest_msg_edit_window_get_msg_data (edit_window);
3047 if (!enough_space_for_message (edit_window, data)) {
3048 modest_msg_edit_window_free_msg_data (edit_window, data);
3052 account_name = g_strdup (data->account_name);
3053 account_mgr = modest_runtime_get_account_mgr();
3055 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
3057 account_name = modest_account_mgr_get_default_account (account_mgr);
3058 if (!account_name) {
3059 g_printerr ("modest: no account found\n");
3060 modest_msg_edit_window_free_msg_data (edit_window, data);
3064 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
3065 account_name = g_strdup (data->account_name);
3069 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3070 (modest_runtime_get_account_store (),
3072 TNY_ACCOUNT_TYPE_TRANSPORT));
3073 if (!transport_account) {
3074 g_printerr ("modest: no transport account found for '%s'\n", account_name);
3075 g_free (account_name);
3076 modest_msg_edit_window_free_msg_data (edit_window, data);
3080 /* Create the mail operation */
3081 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler,
3083 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3085 modest_mail_operation_save_to_drafts (mail_operation,
3097 data->priority_flags,
3100 on_save_to_drafts_cb,
3101 g_object_ref(edit_window));
3103 #ifdef MODEST_TOOLKIT_HILDON2
3104 /* In hildon2 we always show the information banner on saving to drafts.
3105 * It will be a system information banner in this case.
3107 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3108 modest_platform_information_banner (NULL, NULL, text);
3111 ModestMainWindow *win = NULL;
3113 /* Use the main window as the parent of the banner, if the
3114 main window does not exist it won't be shown, if the parent
3115 window exists then it's properly shown. We don't use the
3116 editor window because it could be closed (save to drafts
3117 could happen after closing the window */
3118 win = (ModestMainWindow *)
3119 modest_window_mgr_get_main_window( modest_runtime_get_window_mgr(), FALSE);
3121 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
3122 modest_platform_information_banner (GTK_WIDGET (win), NULL, text);
3126 modest_msg_edit_window_set_modified (edit_window, FALSE);
3129 g_free (account_name);
3130 g_object_unref (G_OBJECT (transport_account));
3131 g_object_unref (G_OBJECT (mail_operation));
3133 modest_msg_edit_window_free_msg_data (edit_window, data);
3135 #ifndef MODEST_TOOLKIT_HILDON2
3137 * If the drafts folder is selected then make the header view
3138 * insensitive while the message is being saved to drafts
3139 * (it'll be sensitive again in on_save_to_drafts_cb()). This
3140 * is not very clean but it avoids letting the drafts folder
3141 * in an inconsistent state: the user could edit the message
3142 * being saved and undesirable things would happen.
3143 * In the average case the user won't notice anything at
3144 * all. In the worst case (the user is editing a really big
3145 * file from Drafts) the header view will be insensitive
3146 * during the saving process (10 or 20 seconds, depending on
3147 * the message). Anyway this is just a quick workaround: once
3148 * we find a better solution it should be removed
3149 * See NB#65125 (commend #18) for details.
3151 if (!had_error && win != NULL) {
3152 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
3153 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
3155 TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
3157 if (modest_tny_folder_is_local_folder(folder)) {
3158 TnyFolderType folder_type;
3159 folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
3160 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
3161 GtkWidget *hdrview = modest_main_window_get_child_widget(
3162 win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
3163 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
3167 if (folder != NULL) g_object_unref(folder);
3175 /* For instance, when clicking the Send toolbar button when editing a message: */
3177 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
3179 TnyTransportAccount *transport_account = NULL;
3180 gboolean had_error = FALSE;
3182 ModestAccountMgr *account_mgr;
3183 gchar *account_name;
3184 ModestMailOperation *mail_operation;
3187 g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
3189 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
3192 data = modest_msg_edit_window_get_msg_data (edit_window);
3194 recipients = g_strconcat (data->to?data->to:"",
3195 data->cc?data->cc:"",
3196 data->bcc?data->bcc:"",
3198 if (recipients == NULL || recipients[0] == '\0') {
3199 /* Empty subject -> no send */
3200 g_free (recipients);
3201 modest_msg_edit_window_free_msg_data (edit_window, data);
3204 g_free (recipients);
3207 if (!enough_space_for_message (edit_window, data)) {
3208 modest_msg_edit_window_free_msg_data (edit_window, data);
3212 account_mgr = modest_runtime_get_account_mgr();
3213 account_name = g_strdup (data->account_name);
3215 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
3218 account_name = modest_account_mgr_get_default_account (account_mgr);
3220 if (!account_name) {
3221 modest_msg_edit_window_free_msg_data (edit_window, data);
3222 /* Run account setup wizard */
3223 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window))) {
3228 /* Get the currently-active transport account for this modest account: */
3229 if (account_name && strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
3231 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
3232 (modest_runtime_get_account_store (),
3233 account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
3236 if (!transport_account) {
3237 modest_msg_edit_window_free_msg_data (edit_window, data);
3238 /* Run account setup wizard */
3239 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
3244 /* Create the mail operation */
3245 mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler, NULL, NULL);
3246 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
3248 modest_mail_operation_send_new_mail (mail_operation,
3262 data->priority_flags);
3264 if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3265 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
3267 if (modest_mail_operation_get_error (mail_operation) != NULL) {
3268 const GError *error = modest_mail_operation_get_error (mail_operation);
3269 if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3270 error->code == MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED) {
3271 g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_operation))->message);
3272 modest_platform_information_banner (NULL, NULL, _CS("sfil_ni_not_enough_memory"));
3278 g_free (account_name);
3279 g_object_unref (G_OBJECT (transport_account));
3280 g_object_unref (G_OBJECT (mail_operation));
3282 modest_msg_edit_window_free_msg_data (edit_window, data);
3285 modest_msg_edit_window_set_sent (edit_window, TRUE);
3287 /* Save settings and close the window: */
3288 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
3295 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
3296 ModestMsgEditWindow *window)
3298 ModestMsgEditFormatState *format_state = NULL;
3300 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3301 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3303 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3306 format_state = modest_msg_edit_window_get_format_state (window);
3307 g_return_if_fail (format_state != NULL);
3309 format_state->bold = gtk_toggle_action_get_active (action);
3310 modest_msg_edit_window_set_format_state (window, format_state);
3311 g_free (format_state);
3316 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
3317 ModestMsgEditWindow *window)
3319 ModestMsgEditFormatState *format_state = NULL;
3321 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3322 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3324 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3327 format_state = modest_msg_edit_window_get_format_state (window);
3328 g_return_if_fail (format_state != NULL);
3330 format_state->italics = gtk_toggle_action_get_active (action);
3331 modest_msg_edit_window_set_format_state (window, format_state);
3332 g_free (format_state);
3337 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
3338 ModestMsgEditWindow *window)
3340 ModestMsgEditFormatState *format_state = NULL;
3342 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3343 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
3345 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3348 format_state = modest_msg_edit_window_get_format_state (window);
3349 g_return_if_fail (format_state != NULL);
3351 format_state->bullet = gtk_toggle_action_get_active (action);
3352 modest_msg_edit_window_set_format_state (window, format_state);
3353 g_free (format_state);
3358 modest_ui_actions_on_change_justify (GtkRadioAction *action,
3359 GtkRadioAction *selected,
3360 ModestMsgEditWindow *window)
3362 ModestMsgEditFormatState *format_state = NULL;
3363 GtkJustification value;
3365 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3367 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3370 value = gtk_radio_action_get_current_value (selected);
3372 format_state = modest_msg_edit_window_get_format_state (window);
3373 g_return_if_fail (format_state != NULL);
3375 format_state->justification = value;
3376 modest_msg_edit_window_set_format_state (window, format_state);
3377 g_free (format_state);
3381 modest_ui_actions_on_select_editor_color (GtkAction *action,
3382 ModestMsgEditWindow *window)
3384 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3385 g_return_if_fail (GTK_IS_ACTION (action));
3387 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3390 modest_msg_edit_window_select_color (window);
3394 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
3395 ModestMsgEditWindow *window)
3397 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3398 g_return_if_fail (GTK_IS_ACTION (action));
3400 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3403 modest_msg_edit_window_select_background_color (window);
3407 modest_ui_actions_on_insert_image (GObject *object,
3408 ModestMsgEditWindow *window)
3410 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3413 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3416 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
3419 modest_msg_edit_window_insert_image (window);
3423 modest_ui_actions_on_attach_file (GtkAction *action,
3424 ModestMsgEditWindow *window)
3426 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3427 g_return_if_fail (GTK_IS_ACTION (action));
3429 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
3432 modest_msg_edit_window_offer_attach_file (window);
3436 modest_ui_actions_on_remove_attachments (GtkAction *action,
3437 ModestMsgEditWindow *window)
3439 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3441 modest_msg_edit_window_remove_attachments (window, NULL);
3445 do_create_folder_cb (ModestMailOperation *mail_op,
3446 TnyFolderStore *parent_folder,
3447 TnyFolder *new_folder,
3450 gchar *suggested_name = (gchar *) user_data;
3451 GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
3452 const GError *error;
3454 error = modest_mail_operation_get_error (mail_op);
3456 gboolean disk_full = FALSE;
3457 TnyAccount *account;
3458 /* Show an error. If there was some problem writing to
3459 disk, show it, otherwise show the generic folder
3460 create error. We do it here and not in an error
3461 handler because the call to do_create_folder will
3462 stop the main loop in a gtk_dialog_run and then,
3463 the message won't be shown until that dialog is
3465 account = modest_mail_operation_get_account (mail_op);
3468 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3469 (GtkWidget *) source_win,
3472 _("mail_in_ui_folder_create_error_memory"));
3473 g_object_unref (account);
3476 /* Show an error and try again if there is no
3477 full memory condition */
3478 modest_platform_information_banner ((GtkWidget *) source_win, NULL,
3479 _("mail_in_ui_folder_create_error"));
3480 do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
3484 /* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
3485 * FIXME: any other? */
3486 GtkWidget *folder_view;
3488 #ifndef MODEST_TOOLKIT_HILDON2
3489 if (MODEST_IS_MAIN_WINDOW(source_win))
3491 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
3492 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3495 folder_view = GTK_WIDGET(g_object_get_data (G_OBJECT (source_win),
3496 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
3498 /* Select the newly created folder. It could happen
3499 that the widget is no longer there (i.e. the window
3500 has been destroyed, so we need to check this */
3502 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
3504 g_object_unref (new_folder);
3506 /* Free. Note that the first time it'll be NULL so noop */
3507 g_free (suggested_name);
3508 g_object_unref (source_win);
3513 TnyFolderStore *parent;
3514 } CreateFolderConnect;
3517 do_create_folder_performer (gboolean canceled,
3519 GtkWindow *parent_window,
3520 TnyAccount *account,
3523 CreateFolderConnect *helper = (CreateFolderConnect *) user_data;
3524 ModestMailOperation *mail_op;
3526 if (canceled || err) {
3527 /* In disk full conditions we could get this error here */
3528 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3529 (GtkWidget *) parent_window, err,
3530 NULL, _("mail_in_ui_folder_create_error_memory"));
3532 /* This happens if we have selected the outbox folder
3534 if (err && err->code == TNY_SERVICE_ERROR_UNKNOWN &&
3535 TNY_IS_MERGE_FOLDER (helper->parent)) {
3536 /* Show an error and retry */
3537 modest_platform_information_banner ((GtkWidget *) parent_window,
3539 _("mail_in_ui_folder_create_error"));
3541 do_create_folder (parent_window, helper->parent, helper->folder_name);
3547 mail_op = modest_mail_operation_new ((GObject *) parent_window);
3548 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3550 modest_mail_operation_create_folder (mail_op,
3552 (const gchar *) helper->folder_name,
3553 do_create_folder_cb,
3554 g_strdup (helper->folder_name));
3555 g_object_unref (mail_op);
3559 g_object_unref (helper->parent);
3560 if (helper->folder_name)
3561 g_free (helper->folder_name);
3562 g_slice_free (CreateFolderConnect, helper);
3567 do_create_folder (GtkWindow *parent_window,
3568 TnyFolderStore *suggested_parent,
3569 const gchar *suggested_name)
3572 gchar *folder_name = NULL;
3573 TnyFolderStore *parent_folder = NULL;
3575 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
3577 (gchar *) suggested_name,
3581 if (result == GTK_RESPONSE_ACCEPT && parent_folder) {
3582 CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderConnect);
3583 helper->folder_name = g_strdup (folder_name);
3584 helper->parent = g_object_ref (parent_folder);
3586 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
3589 do_create_folder_performer,
3594 g_free (folder_name);
3596 g_object_unref (parent_folder);
3600 modest_ui_actions_create_folder(GtkWidget *parent_window,
3601 GtkWidget *folder_view,
3602 TnyFolderStore *parent_folder)
3604 if (!parent_folder) {
3605 #ifdef MODEST_TOOLKIT_HILDON2
3606 ModestTnyAccountStore *acc_store;
3608 acc_store = modest_runtime_get_account_store ();
3610 parent_folder = (TnyFolderStore *)
3611 modest_tny_account_store_get_local_folders_account (acc_store);
3613 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3617 if (parent_folder) {
3618 do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
3619 g_object_unref (parent_folder);
3624 modest_ui_actions_on_new_folder (GtkAction *action, ModestWindow *window)
3627 g_return_if_fail (MODEST_IS_WINDOW(window));
3629 #ifndef MODEST_TOOLKIT_HILDON2
3630 if (MODEST_IS_MAIN_WINDOW (window)) {
3631 GtkWidget *folder_view;
3633 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3634 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3638 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3640 if (MODEST_IS_FOLDER_WINDOW (window)) {
3641 GtkWidget *folder_view;
3643 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3644 modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
3647 g_assert_not_reached ();
3652 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
3655 const GError *error = NULL;
3656 gchar *message = NULL;
3658 TnyAccount *account = modest_mail_operation_get_account (mail_op);
3660 /* Get error message */
3661 error = modest_mail_operation_get_error (mail_op);
3663 g_return_if_reached ();
3665 mem_full = modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
3666 (GError *) error, account);
3668 message = g_strdup_printf (_KR("cerm_device_memory_full"), "");
3669 } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
3670 error->code == MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS) {
3671 message = _CS("ckdg_ib_folder_already_exists");
3672 } else if (error->domain == TNY_ERROR_DOMAIN &&
3673 error->code == TNY_SERVICE_ERROR_STATE) {
3674 /* This means that the folder is already in use (a
3675 message is opened for example */
3676 message = _("emev_ni_internal_error");
3678 message = _CS("ckdg_ib_unable_to_rename");
3681 /* We don't set a parent for the dialog because the dialog
3682 will be destroyed so the banner won't appear */
3683 modest_platform_information_banner (NULL, NULL, message);
3686 g_object_unref (account);
3692 TnyFolderStore *folder;
3697 on_rename_folder_cb (ModestMailOperation *mail_op,
3698 TnyFolder *new_folder,
3701 ModestFolderView *folder_view;
3703 /* If the window was closed when renaming a folder, or if
3704 * it's not a main window this will happen */
3705 if (!MODEST_IS_FOLDER_VIEW (user_data))
3708 folder_view = MODEST_FOLDER_VIEW (user_data);
3709 /* Note that if the rename fails new_folder will be NULL */
3711 modest_folder_view_select_folder (folder_view, new_folder, FALSE);
3712 #ifndef MODEST_TOOLKIT_HILDON2
3714 modest_folder_view_select_first_inbox_or_local (folder_view);
3717 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
3721 on_rename_folder_performer (gboolean canceled,
3723 GtkWindow *parent_window,
3724 TnyAccount *account,
3727 ModestMailOperation *mail_op = NULL;
3728 GtkTreeSelection *sel = NULL;
3729 GtkWidget *folder_view = NULL;
3730 RenameFolderInfo *data = (RenameFolderInfo*)user_data;
3732 if (canceled || err) {
3733 /* In disk full conditions we could get this error here */
3734 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3735 (GtkWidget *) parent_window, err,
3740 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3741 modest_ui_actions_rename_folder_error_handler,
3742 parent_window, NULL);
3744 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3746 #ifndef MODEST_TOOLKIT_HILDON2
3747 if (MODEST_IS_MAIN_WINDOW(parent_window)) {
3749 folder_view = modest_main_window_get_child_widget (
3750 MODEST_MAIN_WINDOW (parent_window),
3751 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3754 if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3755 ModestFolderWindow *folder_window = (ModestFolderWindow *) parent_window;
3756 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (folder_window));
3760 /* Clear the folders view */
3761 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3762 gtk_tree_selection_unselect_all (sel);
3764 /* Actually rename the folder */
3765 modest_mail_operation_rename_folder (mail_op,
3766 TNY_FOLDER (data->folder),
3767 (const gchar *) (data->new_name),
3768 on_rename_folder_cb,
3770 g_object_unref (mail_op);
3773 g_object_unref (data->folder);
3774 g_free (data->new_name);
3779 modest_ui_actions_on_rename_folder (GtkAction *action,
3780 ModestWindow *window)
3782 modest_ui_actions_on_edit_mode_rename_folder (window);
3786 modest_ui_actions_on_edit_mode_rename_folder (ModestWindow *window)
3788 TnyFolderStore *folder;
3789 GtkWidget *folder_view;
3790 gboolean do_rename = TRUE;
3792 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3794 #ifndef MODEST_TOOLKIT_HILDON2
3795 if (MODEST_IS_MAIN_WINDOW (window)) {
3796 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3797 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3801 if (MODEST_IS_FOLDER_WINDOW (window)) {
3802 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3808 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
3813 if (TNY_IS_FOLDER (folder)) {
3814 gchar *folder_name = NULL;
3816 const gchar *current_name;
3817 TnyFolderStore *parent;
3819 current_name = tny_folder_get_name (TNY_FOLDER (folder));
3820 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
3821 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (window),
3822 parent, current_name,
3824 g_object_unref (parent);
3826 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
3829 RenameFolderInfo *rename_folder_data = g_new0 (RenameFolderInfo, 1);
3830 rename_folder_data->folder = g_object_ref (folder);
3831 rename_folder_data->new_name = folder_name;
3832 modest_platform_connect_if_remote_and_perform (GTK_WINDOW(window), TRUE,
3833 folder, on_rename_folder_performer, rename_folder_data);
3836 g_object_unref (folder);
3841 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
3844 GObject *win = modest_mail_operation_get_source (mail_op);
3846 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
3847 _("mail_in_ui_folder_delete_error"),
3849 g_object_unref (win);
3853 TnyFolderStore *folder;
3854 gboolean move_to_trash;
3858 on_delete_folder_cb (gboolean canceled,
3860 GtkWindow *parent_window,
3861 TnyAccount *account,
3864 DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
3865 GtkWidget *folder_view;
3866 ModestMailOperation *mail_op;
3867 GtkTreeSelection *sel;
3869 if (!MODEST_IS_WINDOW(parent_window) || canceled || (err!=NULL)) {
3870 /* Note that the connection process can fail due to
3871 memory low conditions as it can not successfully
3872 store the summary */
3873 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
3874 (GtkWidget*) parent_window, err,
3876 g_debug ("Error connecting when trying to delete a folder");
3877 g_object_unref (G_OBJECT (info->folder));
3882 #ifndef MODEST_TOOLKIT_HILDON2
3883 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
3884 folder_view = modest_main_window_get_child_widget (
3885 MODEST_MAIN_WINDOW (parent_window),
3886 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3888 if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
3889 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (parent_window)));
3892 g_object_unref (G_OBJECT (info->folder));
3897 /* Unselect the folder before deleting it to free the headers */
3898 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3899 gtk_tree_selection_unselect_all (sel);
3901 /* Create the mail operation */
3903 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3904 modest_ui_actions_delete_folder_error_handler,
3907 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3909 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
3911 #ifndef MODEST_TOOLKIT_HILDON2
3912 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
3915 g_object_unref (mail_op);
3916 g_object_unref (info->folder);
3921 delete_folder (ModestWindow *window, gboolean move_to_trash)
3923 TnyFolderStore *folder;
3924 GtkWidget *folder_view;
3928 g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
3930 #ifndef MODEST_TOOLKIT_HILDON2
3931 if (MODEST_IS_MAIN_WINDOW (window)) {
3933 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3934 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3936 if (MODEST_IS_FOLDER_WINDOW (window)) {
3937 folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
3945 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3950 /* Show an error if it's an account */
3951 if (!TNY_IS_FOLDER (folder)) {
3952 modest_platform_run_information_dialog (GTK_WINDOW (window),
3953 _("mail_in_ui_folder_delete_error"),
3955 g_object_unref (G_OBJECT (folder));
3960 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
3961 tny_folder_get_name (TNY_FOLDER (folder)));
3962 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
3963 (const gchar *) message);
3966 if (response == GTK_RESPONSE_OK) {
3967 TnyAccount *account = NULL;
3968 DeleteFolderInfo *info = NULL;
3969 info = g_new0(DeleteFolderInfo, 1);
3970 info->folder = g_object_ref (folder);
3971 info->move_to_trash = move_to_trash;
3973 account = tny_folder_get_account (TNY_FOLDER (folder));
3974 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (window),
3976 TNY_FOLDER_STORE (account),
3977 on_delete_folder_cb, info);
3978 g_object_unref (account);
3979 g_object_unref (folder);
3987 modest_ui_actions_on_delete_folder (GtkAction *action,
3988 ModestWindow *window)
3990 modest_ui_actions_on_edit_mode_delete_folder (window);
3994 modest_ui_actions_on_edit_mode_delete_folder (ModestWindow *window)
3996 g_return_val_if_fail (MODEST_IS_WINDOW(window), TRUE);
3998 return delete_folder (window, FALSE);
4001 #ifndef MODEST_TOOLKIT_HILDON2
4003 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
4005 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
4007 delete_folder (MODEST_WINDOW (main_window), TRUE);
4011 typedef struct _PasswordDialogFields {
4012 GtkWidget *username;
4013 GtkWidget *password;
4015 } PasswordDialogFields;
4018 password_dialog_check_field (GtkEditable *editable,
4019 PasswordDialogFields *fields)
4022 gboolean any_value_empty = FALSE;
4024 value = modest_entry_get_text (fields->username);
4025 if ((value == NULL) || value[0] == '\0') {
4026 any_value_empty = TRUE;
4028 value = modest_entry_get_text (fields->password);
4029 if ((value == NULL) || value[0] == '\0') {
4030 any_value_empty = TRUE;
4032 gtk_dialog_set_response_sensitive (GTK_DIALOG (fields->dialog), GTK_RESPONSE_ACCEPT, !any_value_empty);
4036 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
4037 const gchar* server_account_name,
4042 ModestMainWindow *main_window)
4044 g_return_if_fail(server_account_name);
4045 gboolean completed = FALSE;
4046 PasswordDialogFields *fields = NULL;
4048 /* Initalize output parameters: */
4055 #ifndef MODEST_TOOLKIT_GTK
4056 /* Maemo uses a different (awkward) button order,
4057 * It should probably just use gtk_alternative_dialog_button_order ().
4059 #ifdef MODEST_TOOLKIT_HILDON2
4061 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4064 _HL("wdgt_bd_done"),
4065 GTK_RESPONSE_ACCEPT,
4067 gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
4068 HILDON_MARGIN_DOUBLE);
4071 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4074 _("mcen_bd_dialog_ok"),
4075 GTK_RESPONSE_ACCEPT,
4076 _("mcen_bd_dialog_cancel"),
4077 GTK_RESPONSE_REJECT,
4079 #endif /* MODEST_TOOLKIT_HILDON2 */
4082 gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
4086 GTK_RESPONSE_REJECT,
4088 GTK_RESPONSE_ACCEPT,
4090 #endif /* MODEST_TOOLKIT_GTK */
4092 modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog), NULL);
4094 gchar *server_name = modest_account_mgr_get_server_account_hostname (
4095 modest_runtime_get_account_mgr(), server_account_name);
4096 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
4097 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
4100 gtk_widget_destroy (dialog);
4104 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
4105 GtkWidget *label = gtk_label_new (txt);
4106 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4108 g_free (server_name);
4109 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
4114 gchar *initial_username = modest_account_mgr_get_server_account_username (
4115 modest_runtime_get_account_mgr(), server_account_name);
4117 GtkWidget *entry_username = modest_toolkit_factory_create_entry (modest_runtime_get_toolkit_factory ());
4118 if (initial_username)
4119 modest_entry_set_text (entry_username, initial_username);
4121 /* Dim this if a connection has ever succeeded with this username,
4122 * as per the UI spec: */
4123 /* const gboolean username_known = */
4124 /* modest_account_mgr_get_server_account_username_has_succeeded( */
4125 /* modest_runtime_get_account_mgr(), server_account_name); */
4126 /* gtk_widget_set_sensitive (entry_username, !username_known); */
4128 /* We drop the username sensitive code and disallow changing it here
4129 * as tinymail does not support really changing the username in the callback
4131 gtk_widget_set_sensitive (entry_username, FALSE);
4133 #ifndef MODEST_TOOLKIT_GTK
4134 /* Auto-capitalization is the default, so let's turn it off: */
4135 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
4137 /* Create a size group to be used by all captions.
4138 * Note that HildonCaption does not create a default size group if we do not specify one.
4139 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
4140 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
4142 #ifdef MODEST_TOOLKIT_HILDON2
4143 GtkWidget *caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4144 _("mail_fi_username"), FALSE,
4147 GtkWidget *caption = hildon_caption_new (sizegroup,
4148 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
4150 gtk_widget_show (entry_username);
4151 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4152 FALSE, FALSE, MODEST_MARGIN_HALF);
4153 gtk_widget_show (caption);
4155 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
4157 #endif /* !MODEST_TOOLKIT_GTK */
4160 GtkWidget *entry_password = modest_toolkit_factory_create_entry (modest_runtime_get_toolkit_factory ());
4161 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
4162 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
4164 #ifndef MODEST_TOOLKIT_GTK
4165 /* Auto-capitalization is the default, so let's turn it off: */
4166 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
4167 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
4169 caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
4170 _("mail_fi_password"), FALSE,
4172 gtk_widget_show (entry_password);
4173 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
4174 FALSE, FALSE, MODEST_MARGIN_HALF);
4175 gtk_widget_show (caption);
4176 g_object_unref (sizegroup);
4178 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
4180 #endif /* !MODEST_TOOLKIT_GTK */
4182 if (initial_username != NULL)
4183 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
4185 /* This is not in the Maemo UI spec:
4186 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
4187 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
4191 fields = g_slice_new0 (PasswordDialogFields);
4192 fields->username = entry_username;
4193 fields->password = entry_password;
4194 fields->dialog = dialog;
4196 g_signal_connect (entry_username, "changed", G_CALLBACK (password_dialog_check_field), fields);
4197 g_signal_connect (entry_password, "changed", G_CALLBACK (password_dialog_check_field), fields);
4198 password_dialog_check_field (NULL, fields);
4200 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
4202 while (!completed) {
4204 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
4206 *username = g_strdup (modest_entry_get_text (entry_username));
4208 /* Note that an empty field becomes the "" string */
4209 if (*username && strlen (*username) > 0) {
4210 modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
4211 server_account_name,
4215 const gboolean username_was_changed =
4216 (strcmp (*username, initial_username) != 0);
4217 if (username_was_changed) {
4218 g_warning ("%s: tinymail does not yet support changing the "
4219 "username in the get_password() callback.\n", __FUNCTION__);
4225 modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
4226 _("mcen_ib_username_pw_incorrect"));
4232 *password = g_strdup (modest_entry_get_text (entry_password));
4234 /* We do not save the password in the configuration,
4235 * because this function is only called for passwords that should
4236 * not be remembered:
4237 modest_server_account_set_password (
4238 modest_runtime_get_account_mgr(), server_account_name,
4245 #ifndef MODEST_TOOLKIT_HILDON2
4246 /* Set parent to NULL or the banner will disappear with its parent dialog */
4247 modest_platform_information_banner(NULL, NULL, _("mail_ib_login_cancelled"));
4259 /* This is not in the Maemo UI spec:
4260 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
4266 g_free (initial_username);
4267 gtk_widget_destroy (dialog);
4268 g_slice_free (PasswordDialogFields, fields);
4270 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
4274 modest_ui_actions_on_cut (GtkAction *action,
4275 ModestWindow *window)
4277 GtkWidget *focused_widget;
4278 GtkClipboard *clipboard;
4280 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4281 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4282 if (GTK_IS_EDITABLE (focused_widget)) {
4283 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
4284 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4285 gtk_clipboard_store (clipboard);
4286 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4287 GtkTextBuffer *buffer;
4289 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4290 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4291 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
4292 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4293 gtk_clipboard_store (clipboard);
4295 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4296 TnyList *header_list = modest_header_view_get_selected_headers (
4297 MODEST_HEADER_VIEW (focused_widget));
4298 gboolean continue_download = FALSE;
4299 gint num_of_unc_msgs;
4301 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4303 if (num_of_unc_msgs) {
4304 TnyAccount *account = get_account_from_header_list (header_list);
4306 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4307 g_object_unref (account);
4311 if (num_of_unc_msgs == 0 || continue_download) {
4312 /* modest_platform_information_banner (
4313 NULL, NULL, _CS("mcen_ib_getting_items"));*/
4314 modest_header_view_cut_selection (
4315 MODEST_HEADER_VIEW (focused_widget));
4318 g_object_unref (header_list);
4319 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4320 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
4325 modest_ui_actions_on_copy (GtkAction *action,
4326 ModestWindow *window)
4328 GtkClipboard *clipboard;
4329 GtkWidget *focused_widget;
4330 gboolean copied = TRUE;
4332 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4333 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4335 if (GTK_IS_LABEL (focused_widget)) {
4337 selection = modest_text_utils_label_get_selection (GTK_LABEL (focused_widget));
4338 gtk_clipboard_set_text (clipboard, selection, -1);
4340 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4341 gtk_clipboard_store (clipboard);
4342 } else if (GTK_IS_EDITABLE (focused_widget)) {
4343 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
4344 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4345 gtk_clipboard_store (clipboard);
4346 } else if (GTK_IS_HTML (focused_widget)) {
4349 sel = gtk_html_get_selection_html (GTK_HTML (focused_widget), &len);
4350 if ((sel == NULL) || (sel[0] == '\0')) {
4353 gtk_html_copy (GTK_HTML (focused_widget));
4354 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4355 gtk_clipboard_store (clipboard);
4357 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4358 GtkTextBuffer *buffer;
4359 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4360 if (modest_text_utils_buffer_selection_is_valid (buffer)) {
4361 gtk_text_buffer_copy_clipboard (buffer, clipboard);
4362 gtk_clipboard_set_can_store (clipboard, NULL, 0);
4363 gtk_clipboard_store (clipboard);
4365 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
4366 TnyList *header_list = modest_header_view_get_selected_headers (
4367 MODEST_HEADER_VIEW (focused_widget));
4368 gboolean continue_download = FALSE;
4369 gint num_of_unc_msgs;
4371 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
4373 if (num_of_unc_msgs) {
4374 TnyAccount *account = get_account_from_header_list (header_list);
4376 continue_download = connect_to_get_msg (window, num_of_unc_msgs, account);
4377 g_object_unref (account);
4381 if (num_of_unc_msgs == 0 || continue_download) {
4382 modest_platform_information_banner (
4383 NULL, NULL, _CS("mcen_ib_getting_items"));
4384 modest_header_view_copy_selection (
4385 MODEST_HEADER_VIEW (focused_widget));
4389 g_object_unref (header_list);
4391 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4392 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
4395 /* Show information banner if there was a copy to clipboard */
4397 modest_platform_information_banner (
4398 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
4402 modest_ui_actions_on_undo (GtkAction *action,
4403 ModestWindow *window)
4405 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4406 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
4407 #ifndef MODEST_TOOLKIT_HILDON2
4408 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4409 ModestEmailClipboard *clipboard = NULL;
4410 /* Clear clipboard source */
4411 clipboard = modest_runtime_get_email_clipboard ();
4412 modest_email_clipboard_clear (clipboard);
4415 g_return_if_reached ();
4420 modest_ui_actions_on_redo (GtkAction *action,
4421 ModestWindow *window)
4423 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4424 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
4427 g_return_if_reached ();
4433 destroy_information_note (ModestMailOperation *mail_op,
4436 /* destroy information note */
4437 gtk_widget_destroy (GTK_WIDGET(user_data));
4441 destroy_folder_information_note (ModestMailOperation *mail_op,
4442 TnyFolder *new_folder,
4445 /* destroy information note */
4446 gtk_widget_destroy (GTK_WIDGET(user_data));
4451 paste_as_attachment_free (gpointer data)
4453 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
4455 if (helper->banner) {
4456 gtk_widget_destroy (helper->banner);
4457 g_object_unref (helper->banner);
4463 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
4468 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
4469 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
4474 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
4479 modest_ui_actions_on_paste (GtkAction *action,
4480 ModestWindow *window)
4482 GtkWidget *focused_widget = NULL;
4483 GtkWidget *inf_note = NULL;
4484 ModestMailOperation *mail_op = NULL;
4486 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4487 if (GTK_IS_EDITABLE (focused_widget)) {
4488 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
4489 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4490 ModestEmailClipboard *e_clipboard = NULL;
4491 e_clipboard = modest_runtime_get_email_clipboard ();
4492 if (modest_email_clipboard_cleared (e_clipboard)) {
4493 GtkTextBuffer *buffer;
4494 GtkClipboard *clipboard;
4496 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
4497 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4498 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
4499 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
4500 ModestMailOperation *mail_op;
4501 TnyFolder *src_folder = NULL;
4502 TnyList *data = NULL;
4504 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
4505 helper->window = MODEST_MSG_EDIT_WINDOW (window);
4506 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4507 _CS("ckct_nw_pasting"));
4508 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
4509 mail_op = modest_mail_operation_new (G_OBJECT (window));
4510 if (helper->banner != NULL) {
4511 g_object_ref (G_OBJECT (helper->banner));
4512 gtk_widget_show (GTK_WIDGET (helper->banner));
4516 modest_mail_operation_get_msgs_full (mail_op,
4518 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
4520 paste_as_attachment_free);
4524 g_object_unref (data);
4526 g_object_unref (src_folder);
4529 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
4530 ModestEmailClipboard *clipboard = NULL;
4531 TnyFolder *src_folder = NULL;
4532 TnyFolderStore *folder_store = NULL;
4533 TnyList *data = NULL;
4534 gboolean delete = FALSE;
4536 /* Check clipboard source */
4537 clipboard = modest_runtime_get_email_clipboard ();
4538 if (modest_email_clipboard_cleared (clipboard))
4541 /* Get elements to paste */
4542 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
4544 /* Create a new mail operation */
4545 mail_op = modest_mail_operation_new (G_OBJECT(window));
4547 /* Get destination folder */
4548 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
4550 /* transfer messages */
4554 /* Ask for user confirmation */
4556 modest_ui_actions_msgs_move_to_confirmation (window,
4557 TNY_FOLDER (folder_store),
4561 if (response == GTK_RESPONSE_OK) {
4562 /* Launch notification */
4563 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4564 _CS("ckct_nw_pasting"));
4565 if (inf_note != NULL) {
4566 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4567 gtk_widget_show (GTK_WIDGET(inf_note));
4570 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4571 modest_mail_operation_xfer_msgs (mail_op,
4573 TNY_FOLDER (folder_store),
4575 destroy_information_note,
4578 g_object_unref (mail_op);
4581 } else if (src_folder != NULL) {
4582 /* Launch notification */
4583 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
4584 _CS("ckct_nw_pasting"));
4585 if (inf_note != NULL) {
4586 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4587 gtk_widget_show (GTK_WIDGET(inf_note));
4590 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4591 modest_mail_operation_xfer_folder (mail_op,
4595 destroy_folder_information_note,
4601 g_object_unref (data);
4602 if (src_folder != NULL)
4603 g_object_unref (src_folder);
4604 if (folder_store != NULL)
4605 g_object_unref (folder_store);
4611 modest_ui_actions_on_select_all (GtkAction *action,
4612 ModestWindow *window)
4614 GtkWidget *focused_widget;
4616 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
4617 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
4618 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
4619 } else if (GTK_IS_LABEL (focused_widget)) {
4620 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
4621 } else if (GTK_IS_EDITABLE (focused_widget)) {
4622 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
4623 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
4624 GtkTextBuffer *buffer;
4625 GtkTextIter start, end;
4627 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
4628 gtk_text_buffer_get_start_iter (buffer, &start);
4629 gtk_text_buffer_get_end_iter (buffer, &end);
4630 gtk_text_buffer_select_range (buffer, &start, &end);
4631 } else if (GTK_IS_HTML (focused_widget)) {
4632 gtk_html_select_all (GTK_HTML (focused_widget));
4633 #ifndef MODEST_TOOLKIT_HILDON2
4634 } else if (MODEST_IS_MAIN_WINDOW (window)) {
4635 GtkWidget *header_view = focused_widget;
4636 GtkTreeSelection *selection = NULL;
4638 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
4639 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
4640 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4643 /* Disable window dimming management */
4644 modest_window_disable_dimming (MODEST_WINDOW(window));
4646 /* Select all messages */
4647 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
4648 gtk_tree_selection_select_all (selection);
4650 /* Set focuse on header view */
4651 gtk_widget_grab_focus (header_view);
4653 /* Enable window dimming management */
4654 modest_window_enable_dimming (MODEST_WINDOW(window));
4655 modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
4656 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
4663 modest_ui_actions_on_mark_as_read (GtkAction *action,
4664 ModestWindow *window)
4666 g_return_if_fail (MODEST_IS_WINDOW(window));
4668 /* Mark each header as read */
4669 do_headers_action (window, headers_action_mark_as_read, NULL);
4673 modest_ui_actions_on_mark_as_unread (GtkAction *action,
4674 ModestWindow *window)
4676 g_return_if_fail (MODEST_IS_WINDOW(window));
4678 /* Mark each header as read */
4679 do_headers_action (window, headers_action_mark_as_unread, NULL);
4683 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
4684 GtkRadioAction *selected,
4685 ModestWindow *window)
4689 value = gtk_radio_action_get_current_value (selected);
4690 if (MODEST_IS_WINDOW (window)) {
4691 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
4696 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
4697 GtkRadioAction *selected,
4698 ModestWindow *window)
4700 TnyHeaderFlags flags;
4701 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4703 flags = gtk_radio_action_get_current_value (selected);
4704 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
4708 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
4709 GtkRadioAction *selected,
4710 ModestWindow *window)
4714 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4716 file_format = gtk_radio_action_get_current_value (selected);
4717 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
4722 modest_ui_actions_on_zoom_plus (GtkAction *action,
4723 ModestWindow *window)
4725 g_return_if_fail (MODEST_IS_WINDOW (window));
4727 modest_window_zoom_plus (MODEST_WINDOW (window));
4731 modest_ui_actions_on_zoom_minus (GtkAction *action,
4732 ModestWindow *window)
4734 g_return_if_fail (MODEST_IS_WINDOW (window));
4736 modest_window_zoom_minus (MODEST_WINDOW (window));
4740 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
4741 ModestWindow *window)
4743 ModestWindowMgr *mgr;
4744 gboolean fullscreen, active;
4745 g_return_if_fail (MODEST_IS_WINDOW (window));
4747 mgr = modest_runtime_get_window_mgr ();
4749 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
4750 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4752 if (active != fullscreen) {
4753 modest_window_mgr_set_fullscreen_mode (mgr, active);
4754 #ifndef MODEST_TOOLKIT_HILDON2
4755 gtk_window_present (GTK_WINDOW (window));
4761 modest_ui_actions_on_change_fullscreen (GtkAction *action,
4762 ModestWindow *window)
4764 ModestWindowMgr *mgr;
4765 gboolean fullscreen;
4767 g_return_if_fail (MODEST_IS_WINDOW (window));
4769 mgr = modest_runtime_get_window_mgr ();
4770 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
4771 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
4773 #ifndef MODEST_TOOLKIT_HILDON2
4774 gtk_window_present (GTK_WINDOW (window));
4779 * Used by modest_ui_actions_on_details to call do_headers_action
4782 headers_action_show_details (TnyHeader *header,
4783 ModestWindow *window,
4787 gboolean async_retrieval;
4790 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4791 async_retrieval = TRUE;
4792 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (window));
4794 async_retrieval = FALSE;
4796 modest_platform_run_header_details_dialog (GTK_WINDOW (window), header, async_retrieval, msg);
4798 g_object_unref (msg);
4802 * Show the header details in a ModestDetailsDialog widget
4805 modest_ui_actions_on_details (GtkAction *action,
4808 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4812 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
4816 header = tny_msg_get_header (msg);
4818 headers_action_show_details (header, win, NULL);
4819 g_object_unref (header);
4821 g_object_unref (msg);
4822 #ifndef MODEST_TOOLKIT_HILDON2
4823 } else if (MODEST_IS_MAIN_WINDOW (win)) {
4824 GtkWidget *folder_view, *header_view;
4826 /* Check which widget has the focus */
4827 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4828 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
4829 if (gtk_widget_is_focus (folder_view)) {
4830 TnyFolderStore *folder_store
4831 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4832 if (!folder_store) {
4833 g_warning ("%s: No item was selected.\n", __FUNCTION__);
4836 /* Show only when it's a folder */
4837 /* This function should not be called for account items,
4838 * because we dim the menu item for them. */
4839 if (TNY_IS_FOLDER (folder_store)) {
4840 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4841 TNY_FOLDER (folder_store));
4844 g_object_unref (folder_store);
4847 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4848 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
4849 /* Show details of each header */
4850 do_headers_action (win, headers_action_show_details, header_view);
4853 } else if (MODEST_IS_HEADER_WINDOW (win)) {
4855 GtkWidget *header_view;
4857 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
4858 folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
4860 modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
4862 g_object_unref (folder);
4869 modest_ui_actions_on_limit_error (GtkAction *action,
4872 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
4874 modest_platform_information_banner ((GtkWidget *) win, NULL, _CS("ckdg_ib_maximum_characters_reached"));
4879 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
4880 ModestMsgEditWindow *window)
4882 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4884 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
4888 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
4889 ModestMsgEditWindow *window)
4891 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4893 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
4896 #ifndef MODEST_TOOLKIT_HILDON2
4898 modest_ui_actions_toggle_folders_view (GtkAction *action,
4899 ModestMainWindow *main_window)
4901 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
4903 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
4904 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
4906 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
4911 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
4912 ModestWindow *window)
4914 gboolean active, fullscreen = FALSE;
4915 ModestWindowMgr *mgr;
4917 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
4919 /* Check if we want to toggle the toolbar view in fullscreen
4921 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
4922 "ViewShowToolbarFullScreen")) {
4926 /* Toggle toolbar */
4927 mgr = modest_runtime_get_window_mgr ();
4928 modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
4932 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
4933 ModestMsgEditWindow *window)
4935 modest_msg_edit_window_select_font (window);
4940 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
4941 const gchar *display_name,
4944 /* don't update the display name if it was already set;
4945 * updating the display name apparently is expensive */
4946 const gchar* old_name = gtk_window_get_title (window);
4948 if (display_name == NULL)
4951 if (old_name && display_name && strcmp (old_name, display_name) == 0)
4952 return; /* don't do anything */
4954 /* This is usually used to change the title of the main window, which
4955 * is the one that holds the folder view. Note that this change can
4956 * happen even when the widget doesn't have the focus. */
4957 gtk_window_set_title (window, display_name);
4962 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
4964 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4965 modest_msg_edit_window_select_contacts (window);
4969 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
4971 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4972 modest_msg_edit_window_check_names (window, FALSE);
4975 #ifndef MODEST_TOOLKIT_HILDON2
4977 * This function is used to track changes in the selection of the
4978 * folder view that is inside the "move to" dialog to enable/disable
4979 * the OK button because we do not want the user to select a disallowed
4980 * destination for a folder.
4981 * The user also not desired to be able to use NEW button on items where
4982 * folder creation is not possibel.
4985 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
4986 TnyFolderStore *folder_store,
4990 GtkWidget *dialog = NULL;
4991 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
4992 gboolean moving_folder = FALSE;
4993 gboolean is_local_account = TRUE;
4994 GtkWidget *folder_view = NULL;
4995 ModestTnyFolderRules rules;
4997 g_return_if_fail (MODEST_IS_FOLDER_VIEW(self));
5002 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
5006 /* check if folder_store is an remote account */
5007 if (TNY_IS_ACCOUNT (folder_store)) {
5008 TnyAccount *local_account = NULL;
5009 TnyAccount *mmc_account = NULL;
5010 ModestTnyAccountStore *account_store = NULL;
5012 account_store = modest_runtime_get_account_store ();
5013 local_account = modest_tny_account_store_get_local_folders_account (account_store);
5014 mmc_account = modest_tny_account_store_get_mmc_folders_account (account_store);
5016 if ((gpointer) local_account != (gpointer) folder_store &&
5017 (gpointer) mmc_account != (gpointer) folder_store) {
5018 ModestProtocolType proto;
5019 proto = modest_tny_account_get_protocol_type (TNY_ACCOUNT (folder_store));
5020 if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
5021 proto = MODEST_PROTOCOLS_STORE_MAILDIR;
5023 is_local_account = FALSE;
5024 /* New button should be dimmed on remote
5026 new_sensitive = (modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
5028 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS));
5030 g_object_unref (local_account);
5032 /* It could not exist */
5034 g_object_unref (mmc_account);
5037 /* Check the target folder rules */
5038 if (TNY_IS_FOLDER (folder_store)) {
5039 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
5040 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
5041 ok_sensitive = FALSE;
5042 new_sensitive = FALSE;
5047 /* Check if we're moving a folder */
5048 if (MODEST_IS_MAIN_WINDOW (user_data)) {
5049 /* Get the widgets */
5050 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
5051 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5052 if (gtk_widget_is_focus (folder_view))
5053 moving_folder = TRUE;
5056 if (moving_folder) {
5057 TnyFolderStore *moved_folder = NULL, *parent = NULL;
5059 /* Get the folder to move */
5060 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5062 /* Check that we're not moving to the same folder */
5063 if (TNY_IS_FOLDER (moved_folder)) {
5064 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
5065 if (parent == folder_store)
5066 ok_sensitive = FALSE;
5067 g_object_unref (parent);
5070 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
5071 /* Do not allow to move to an account unless it's the
5072 local folders account */
5073 if (!is_local_account)
5074 ok_sensitive = FALSE;
5077 if (ok_sensitive && (moved_folder == folder_store)) {
5078 /* Do not allow to move to itself */
5079 ok_sensitive = FALSE;
5081 g_object_unref (moved_folder);
5083 TnyFolder *src_folder = NULL;
5085 /* Moving a message */
5086 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
5088 TnyHeader *header = NULL;
5089 header = modest_msg_view_window_get_header
5090 (MODEST_MSG_VIEW_WINDOW (user_data));
5091 if (!TNY_IS_HEADER(header))
5092 g_warning ("%s: could not get source header", __FUNCTION__);
5094 src_folder = tny_header_get_folder (header);
5097 g_object_unref (header);
5100 TNY_FOLDER (modest_folder_view_get_selected
5101 (MODEST_FOLDER_VIEW (folder_view)));
5104 if (TNY_IS_FOLDER(src_folder)) {
5105 /* Do not allow to move the msg to the same folder */
5106 /* Do not allow to move the msg to an account */
5107 if ((gpointer) src_folder == (gpointer) folder_store ||
5108 TNY_IS_ACCOUNT (folder_store))
5109 ok_sensitive = FALSE;
5110 g_object_unref (src_folder);
5112 g_warning ("%s: could not get source folder", __FUNCTION__);
5116 /* Set sensitivity of the OK and NEW button */
5117 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, ok_sensitive);
5118 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), MODEST_GTK_RESPONSE_NEW_FOLDER, new_sensitive);
5123 on_move_to_dialog_response (GtkDialog *dialog,
5127 GtkWidget *parent_win;
5128 MoveToInfo *helper = NULL;
5129 ModestFolderView *folder_view;
5130 gboolean unset_edit_mode = FALSE;
5132 helper = (MoveToInfo *) user_data;
5134 parent_win = (GtkWidget *) helper->win;
5135 folder_view = MODEST_FOLDER_VIEW (g_object_get_data (G_OBJECT (dialog),
5136 MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
5138 TnyFolderStore *dst_folder;
5139 TnyFolderStore *selected;
5141 case MODEST_GTK_RESPONSE_NEW_FOLDER:
5142 selected = modest_folder_view_get_selected (folder_view);
5143 modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view), selected);
5144 g_object_unref (selected);
5146 case GTK_RESPONSE_NONE:
5147 case GTK_RESPONSE_CANCEL:
5148 case GTK_RESPONSE_DELETE_EVENT:
5150 case GTK_RESPONSE_OK:
5151 dst_folder = modest_folder_view_get_selected (folder_view);
5153 #ifndef MODEST_TOOLKIT_HILDON2
5154 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
5155 /* Clean list to move used for filtering */
5156 modest_folder_view_set_list_to_move (folder_view, NULL);
5158 modest_ui_actions_on_main_window_move_to (NULL,
5159 GTK_WIDGET (folder_view),
5161 MODEST_MAIN_WINDOW (parent_win));
5163 if (MODEST_IS_FOLDER_WINDOW (parent_win)) {
5164 /* Clean list to move used for filtering */
5165 modest_folder_view_set_list_to_move (folder_view, NULL);
5167 modest_ui_actions_on_folder_window_move_to (GTK_WIDGET (folder_view),
5170 GTK_WINDOW (parent_win));
5173 /* if the user selected a root folder
5174 (account) then do not perform any action */
5175 if (TNY_IS_ACCOUNT (dst_folder)) {
5176 g_signal_stop_emission_by_name (dialog, "response");
5180 /* Clean list to move used for filtering */
5181 modest_folder_view_set_list_to_move (folder_view, NULL);
5183 /* Moving from headers window in edit mode */
5184 modest_ui_actions_on_window_move_to (NULL, helper->list,
5186 MODEST_WINDOW (parent_win));
5190 g_object_unref (dst_folder);
5192 unset_edit_mode = TRUE;
5195 g_warning ("%s unexpected response id %d", __FUNCTION__, response);
5198 /* Free the helper and exit */
5200 g_object_unref (helper->list);
5201 if (unset_edit_mode) {
5202 #ifdef MODEST_TOOLKIT_HILDON2
5203 modest_hildon2_window_unset_edit_mode (MODEST_HILDON2_WINDOW (helper->win));
5206 g_slice_free (MoveToInfo, helper);
5207 gtk_widget_destroy (GTK_WIDGET (dialog));
5211 create_move_to_dialog (GtkWindow *win,
5212 GtkWidget *folder_view,
5213 TnyList *list_to_move)
5215 GtkWidget *dialog, *tree_view = NULL;
5217 dialog = modest_platform_create_move_to_dialog (win, &tree_view);
5219 #ifndef MODEST_TOOLKIT_HILDON2
5220 /* Track changes in the selection to
5221 * disable the OK button whenever "Move to" is not possible
5222 * disbale NEW button whenever New is not possible */
5223 g_signal_connect (tree_view,
5224 "folder_selection_changed",
5225 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
5229 /* It could happen that we're trying to move a message from a
5230 window (msg window for example) after the main window was
5231 closed, so we can not just get the model of the folder
5233 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
5234 const gchar *visible_id = NULL;
5236 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5237 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5238 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
5239 MODEST_FOLDER_VIEW(tree_view));
5242 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
5244 /* Show the same account than the one that is shown in the main window */
5245 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(tree_view),
5248 const gchar *active_account_name = NULL;
5249 ModestAccountMgr *mgr = NULL;
5250 ModestAccountSettings *settings = NULL;
5251 ModestServerAccountSettings *store_settings = NULL;
5253 modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
5254 MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
5255 /* modest_folder_view_update_model (MODEST_FOLDER_VIEW (tree_view), */
5256 /* TNY_ACCOUNT_STORE (modest_runtime_get_account_store ())); */
5258 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
5259 mgr = modest_runtime_get_account_mgr ();
5260 settings = modest_account_mgr_load_account_settings (mgr, active_account_name);
5263 const gchar *store_account_name;
5264 store_settings = modest_account_settings_get_store_settings (settings);
5265 store_account_name = modest_server_account_settings_get_account_name (store_settings);
5267 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (tree_view),
5268 store_account_name);
5269 g_object_unref (store_settings);
5270 g_object_unref (settings);
5274 /* we keep a pointer to the embedded folder view, so we can
5275 * retrieve it with get_folder_view_from_move_to_dialog (see
5276 * above) later (needed for focus handling)
5278 g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, tree_view);
5280 /* Hide special folders */
5281 #ifndef MODEST_TOOLKIT_HILDON2
5282 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
5285 modest_folder_view_set_list_to_move (MODEST_FOLDER_VIEW (tree_view), list_to_move);
5286 #ifndef MODEST_TOOLKIT_HILDON2
5287 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
5290 gtk_widget_show (GTK_WIDGET (tree_view));
5296 * Shows a confirmation dialog to the user when we're moving messages
5297 * from a remote server to the local storage. Returns the dialog
5298 * response. If it's other kind of movement then it always returns
5301 * This one is used by the next functions:
5302 * modest_ui_actions_on_paste - commented out
5303 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
5306 modest_ui_actions_msgs_move_to_confirmation (ModestWindow *win,
5307 TnyFolder *dest_folder,
5311 gint response = GTK_RESPONSE_OK;
5312 TnyAccount *account = NULL;
5313 TnyFolder *src_folder = NULL;
5314 TnyIterator *iter = NULL;
5315 TnyHeader *header = NULL;
5317 /* return with OK if the destination is a remote folder */
5318 if (modest_tny_folder_is_remote_folder (dest_folder))
5319 return GTK_RESPONSE_OK;
5321 /* Get source folder */
5322 iter = tny_list_create_iterator (headers);
5323 header = TNY_HEADER (tny_iterator_get_current (iter));
5325 src_folder = tny_header_get_folder (header);
5326 g_object_unref (header);
5328 g_object_unref (iter);
5330 /* if no src_folder, message may be an attahcment */
5331 if (src_folder == NULL)
5332 return GTK_RESPONSE_CANCEL;
5334 /* If the source is a local or MMC folder */
5335 if (!modest_tny_folder_is_remote_folder (src_folder)) {
5336 g_object_unref (src_folder);
5337 return GTK_RESPONSE_OK;
5340 /* Get the account */
5341 account = tny_folder_get_account (src_folder);
5343 /* now if offline we ask the user */
5344 if(connect_to_get_msg (win, tny_list_get_length (headers), account))
5345 response = GTK_RESPONSE_OK;
5347 response = GTK_RESPONSE_CANCEL;
5350 g_object_unref (src_folder);
5351 g_object_unref (account);
5357 move_to_helper_destroyer (gpointer user_data)
5359 MoveToHelper *helper = (MoveToHelper *) user_data;
5361 /* Close the "Pasting" information banner */
5362 if (helper->banner) {
5363 gtk_widget_destroy (GTK_WIDGET (helper->banner));
5364 g_object_unref (helper->banner);
5366 if (gtk_tree_row_reference_valid (helper->reference)) {
5367 gtk_tree_row_reference_free (helper->reference);
5368 helper->reference = NULL;
5374 move_to_cb (ModestMailOperation *mail_op,
5377 MoveToHelper *helper = (MoveToHelper *) user_data;
5378 GObject *object = modest_mail_operation_get_source (mail_op);
5380 /* Note that the operation could have failed, in that case do
5382 if (modest_mail_operation_get_status (mail_op) !=
5383 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
5386 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
5387 ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
5389 if (!modest_msg_view_window_select_next_message (self) &&
5390 !modest_msg_view_window_select_previous_message (self)) {
5391 /* No more messages to view, so close this window */
5392 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
5394 #ifndef MODEST_TOOLKIT_HILDON2
5395 } else if (MODEST_IS_MAIN_WINDOW (object) &&
5396 gtk_tree_row_reference_valid (helper->reference)) {
5397 GtkWidget *header_view;
5399 GtkTreeSelection *sel;
5401 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5402 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5403 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
5404 path = gtk_tree_row_reference_get_path (helper->reference);
5405 /* We need to unselect the previous one
5406 because we could be copying instead of
5408 gtk_tree_selection_unselect_all (sel);
5409 gtk_tree_selection_select_path (sel, path);
5410 gtk_tree_path_free (path);
5413 g_object_unref (object);
5416 /* Destroy the helper */
5417 move_to_helper_destroyer (helper);
5421 folder_move_to_cb (ModestMailOperation *mail_op,
5422 TnyFolder *new_folder,
5427 object = modest_mail_operation_get_source (mail_op);
5428 #ifndef MODEST_TOOLKIT_HILDON2
5429 if (MODEST_IS_MAIN_WINDOW (object)) {
5430 GtkWidget *folder_view;
5431 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
5432 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5433 g_object_ref (folder_view);
5434 g_object_unref (object);
5435 move_to_cb (mail_op, user_data);
5436 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), new_folder, FALSE);
5437 g_object_unref (folder_view);
5442 move_to_cb (mail_op, user_data);
5447 msgs_move_to_cb (ModestMailOperation *mail_op,
5450 move_to_cb (mail_op, user_data);
5454 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
5457 GObject *win = NULL;
5458 const GError *error;
5459 TnyAccount *account = NULL;
5461 #ifndef MODEST_TOOLKIT_HILDON2
5462 ModestWindow *main_window = NULL;
5464 /* Disable next automatic folder selection */
5465 main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
5466 FALSE); /* don't create */
5468 /* Show notification dialog only if the main window exists */
5470 GtkWidget *folder_view = NULL;
5472 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
5473 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
5474 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
5476 if (user_data && TNY_IS_FOLDER (user_data)) {
5477 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
5478 TNY_FOLDER (user_data), FALSE);
5482 win = modest_mail_operation_get_source (mail_op);
5483 error = modest_mail_operation_get_error (mail_op);
5485 if (TNY_IS_FOLDER (user_data))
5486 account = modest_tny_folder_get_account (TNY_FOLDER (user_data));
5487 else if (TNY_IS_ACCOUNT (user_data))
5488 account = g_object_ref (user_data);
5490 /* If it's not a disk full error then show a generic error */
5491 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5492 (GtkWidget *) win, (GError *) error,
5494 modest_platform_run_information_dialog ((GtkWindow *) win,
5495 _("mail_in_ui_folder_move_target_error"),
5498 g_object_unref (account);
5500 g_object_unref (win);
5503 #ifndef MODEST_TOOLKIT_HILDON2
5505 open_msg_for_purge_cb (ModestMailOperation *mail_op,
5514 gint pending_purges = 0;
5515 gboolean some_purged = FALSE;
5516 ModestWindow *win = MODEST_WINDOW (user_data);
5517 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
5519 /* If there was any error */
5520 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
5521 modest_window_mgr_unregister_header (mgr, header);
5525 /* Once the message has been retrieved for purging, we check if
5526 * it's all ok for purging */
5528 parts = tny_simple_list_new ();
5529 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
5530 iter = tny_list_create_iterator (parts);
5532 while (!tny_iterator_is_done (iter)) {
5534 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5535 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
5536 if (tny_mime_part_is_purged (part))
5543 g_object_unref (part);
5545 tny_iterator_next (iter);
5547 g_object_unref (iter);
5550 if (pending_purges>0) {
5552 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
5554 if (response == GTK_RESPONSE_OK) {
5557 modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_me_inbox_remove_attachments"));
5558 iter = tny_list_create_iterator (parts);
5559 while (!tny_iterator_is_done (iter)) {
5562 part = TNY_MIME_PART (tny_iterator_get_current (iter));
5563 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
5564 tny_mime_part_set_purged (part);
5567 g_object_unref (part);
5569 tny_iterator_next (iter);
5571 g_object_unref (iter);
5573 tny_msg_rewrite_cache (msg);
5575 gtk_widget_destroy (info);
5579 modest_window_mgr_unregister_header (mgr, header);
5581 g_object_unref (parts);
5585 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
5586 ModestMainWindow *win)
5588 GtkWidget *header_view;
5589 TnyList *header_list;
5591 TnyHeaderFlags flags;
5592 ModestWindow *msg_view_window = NULL;
5595 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5597 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
5598 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5600 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
5602 g_warning ("%s: no header selected", __FUNCTION__);
5606 if (tny_list_get_length (header_list) == 1) {
5607 TnyIterator *iter = tny_list_create_iterator (header_list);
5608 header = TNY_HEADER (tny_iterator_get_current (iter));
5609 g_object_unref (iter);
5613 if (!header || !TNY_IS_HEADER(header)) {
5614 g_warning ("%s: header is not valid", __FUNCTION__);
5618 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
5619 header, &msg_view_window);
5620 flags = tny_header_get_flags (header);
5621 if (!(flags & TNY_HEADER_FLAG_CACHED))
5624 if (msg_view_window != NULL)
5625 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
5627 /* do nothing; uid was registered before, so window is probably on it's way */
5628 g_debug ("header %p has already been registered", header);
5631 ModestMailOperation *mail_op = NULL;
5632 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header, NULL);
5633 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (win),
5634 modest_ui_actions_disk_operations_error_handler,
5636 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
5637 modest_mail_operation_get_msg (mail_op, header, FALSE, open_msg_for_purge_cb, win);
5639 g_object_unref (mail_op);
5642 g_object_unref (header);
5644 g_object_unref (header_list);
5649 * Checks if we need a connection to do the transfer and if the user
5650 * wants to connect to complete it
5653 modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
5654 TnyFolderStore *src_folder,
5656 TnyFolder *dst_folder,
5657 gboolean delete_originals,
5658 gboolean *need_connection,
5661 TnyAccount *src_account;
5662 gint uncached_msgs = 0;
5664 /* We don't need any further check if
5666 * 1- the source folder is local OR
5667 * 2- the device is already online
5669 if (!modest_tny_folder_store_is_remote (src_folder) ||
5670 tny_device_is_online (modest_runtime_get_device())) {
5671 *need_connection = FALSE;
5676 /* We must ask for a connection when
5678 * - the message(s) is not already cached OR
5679 * - the message(s) is cached but the leave_on_server setting
5680 * is FALSE (because we need to sync the source folder to
5681 * delete the message from the server (for IMAP we could do it
5682 * offline, it'll take place the next time we get a
5685 uncached_msgs = header_list_count_uncached_msgs (headers);
5686 src_account = get_account_from_folder_store (src_folder);
5687 if (uncached_msgs > 0) {
5691 *need_connection = TRUE;
5692 num_headers = tny_list_get_length (headers);
5693 msg = ngettext ("mcen_nc_get_msg", "mcen_nc_get_msgs", num_headers);
5695 if (modest_platform_run_confirmation_dialog (parent_window, msg) ==
5696 GTK_RESPONSE_CANCEL) {
5702 /* The transfer is possible and the user wants to */
5705 if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
5706 const gchar *account_name;
5707 gboolean leave_on_server;
5709 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
5710 leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
5713 if (leave_on_server == TRUE) {
5714 *need_connection = FALSE;
5716 *need_connection = TRUE;
5719 *need_connection = FALSE;
5724 g_object_unref (src_account);
5728 xfer_messages_error_handler (ModestMailOperation *mail_op,
5732 const GError *error;
5733 TnyAccount *account;
5735 win = modest_mail_operation_get_source (mail_op);
5736 error = modest_mail_operation_get_error (mail_op);
5738 /* We cannot get the account from the mail op as that is the
5739 source account and for checking memory full conditions we
5740 need the destination one */
5741 account = TNY_ACCOUNT (user_data);
5744 !modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5745 (GtkWidget *) win, (GError*) error,
5746 account, _KR("cerm_memory_card_full"))) {
5747 modest_platform_run_information_dialog ((GtkWindow *) win,
5748 _("mail_in_ui_folder_move_target_error"),
5752 g_object_unref (win);
5756 TnyFolderStore *dst_folder;
5761 * Utility function that transfer messages from both the main window
5762 * and the msg view window when using the "Move to" dialog
5765 xfer_messages_performer (gboolean canceled,
5767 GtkWindow *parent_window,
5768 TnyAccount *account,
5771 ModestWindow *win = MODEST_WINDOW (parent_window);
5772 TnyAccount *dst_account = NULL;
5773 gboolean dst_forbids_message_add = FALSE;
5774 XferMsgsHelper *helper;
5775 MoveToHelper *movehelper;
5776 ModestMailOperation *mail_op;
5778 helper = (XferMsgsHelper *) user_data;
5780 if (canceled || err) {
5781 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5782 (GtkWidget *) parent_window, err,
5784 /* Show the proper error message */
5785 modest_ui_actions_on_account_connection_error (parent_window, account);
5790 dst_account = tny_folder_get_account (TNY_FOLDER (helper->dst_folder));
5792 /* tinymail will return NULL for local folders it seems */
5793 dst_forbids_message_add = modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
5794 modest_tny_account_get_protocol_type (dst_account),
5795 MODEST_PROTOCOL_REGISTRY_STORE_FORBID_INCOMING_XFERS);
5797 if (dst_forbids_message_add) {
5798 modest_platform_information_banner (GTK_WIDGET (win),
5800 ngettext("mail_in_ui_folder_move_target_error",
5801 "mail_in_ui_folder_move_targets_error",
5802 tny_list_get_length (helper->headers)));
5806 movehelper = g_new0 (MoveToHelper, 1);
5808 #ifndef MODEST_TOOLKIT_HILDON2
5809 movehelper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
5810 _CS("ckct_nw_pasting"));
5811 if (movehelper->banner != NULL) {
5812 g_object_ref (movehelper->banner);
5813 gtk_widget_show (GTK_WIDGET (movehelper->banner));
5816 if (MODEST_IS_MAIN_WINDOW (win)) {
5817 GtkWidget *header_view =
5818 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
5819 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5820 movehelper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
5824 /* Perform the mail operation */
5825 mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(win),
5826 xfer_messages_error_handler,
5827 g_object_ref (dst_account),
5829 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5832 modest_mail_operation_xfer_msgs (mail_op,
5834 TNY_FOLDER (helper->dst_folder),
5839 g_object_unref (G_OBJECT (mail_op));
5842 g_object_unref (dst_account);
5843 g_object_unref (helper->dst_folder);
5844 g_object_unref (helper->headers);
5845 g_slice_free (XferMsgsHelper, helper);
5849 TnyFolder *src_folder;
5850 TnyFolderStore *dst_folder;
5851 gboolean delete_original;
5852 GtkWidget *folder_view;
5856 on_move_folder_cb (gboolean canceled,
5858 GtkWindow *parent_window,
5859 TnyAccount *account,
5862 MoveFolderInfo *info = (MoveFolderInfo*)user_data;
5863 GtkTreeSelection *sel;
5864 ModestMailOperation *mail_op = NULL;
5866 if (canceled || err || !MODEST_IS_WINDOW (parent_window)) {
5867 /* Note that the connection process can fail due to
5868 memory low conditions as it can not successfully
5869 store the summary */
5870 if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
5871 (GtkWidget*) parent_window, err,
5873 g_debug ("Error connecting when trying to move a folder");
5875 g_object_unref (G_OBJECT (info->src_folder));
5876 g_object_unref (G_OBJECT (info->dst_folder));
5881 MoveToHelper *helper = g_new0 (MoveToHelper, 1);
5882 #ifndef MODEST_TOOLKIT_HILDON2
5883 helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
5884 _CS("ckct_nw_pasting"));
5885 if (helper->banner != NULL) {
5886 g_object_ref (helper->banner);
5887 gtk_widget_show (GTK_WIDGET(helper->banner));
5890 /* Clean folder on header view before moving it */
5891 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
5892 gtk_tree_selection_unselect_all (sel);
5894 /* Let gtk events run. We need that the folder
5895 view frees its reference to the source
5896 folder *before* issuing the mail operation
5897 so we need the signal handler of selection
5898 changed to happen before the mail
5900 while (gtk_events_pending ())
5901 gtk_main_iteration (); */
5904 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
5905 modest_ui_actions_move_folder_error_handler,
5906 g_object_ref (info->dst_folder), g_object_unref);
5907 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
5910 #ifndef MODEST_TOOLKIT_HILDON2
5911 if (MODEST_IS_MAIN_WINDOW (parent_window)) {
5912 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
5913 TNY_FOLDER (info->dst_folder), TRUE);
5916 modest_mail_operation_xfer_folder (mail_op,
5917 TNY_FOLDER (info->src_folder),
5919 info->delete_original,
5922 g_object_unref (G_OBJECT (info->src_folder));
5924 /* if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) { */
5927 /* Unref mail operation */
5928 g_object_unref (G_OBJECT (mail_op));
5929 g_object_unref (G_OBJECT (info->dst_folder));
5934 get_account_from_folder_store (TnyFolderStore *folder_store)
5936 if (TNY_IS_ACCOUNT (folder_store))
5937 return g_object_ref (folder_store);
5939 return tny_folder_get_account (TNY_FOLDER (folder_store));
5942 #ifndef MODEST_TOOLKIT_HILDON2
5944 * UI handler for the "Move to" action when invoked from the
5948 modest_ui_actions_on_main_window_move_to (GtkAction *action,
5949 GtkWidget *folder_view,
5950 TnyFolderStore *dst_folder,
5951 ModestMainWindow *win)
5953 ModestHeaderView *header_view = NULL;
5954 TnyFolderStore *src_folder = NULL;
5956 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
5958 /* Get the source folder */
5959 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
5961 /* Get header view */
5962 header_view = (ModestHeaderView *)
5963 modest_main_window_get_child_widget (win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
5965 /* Get folder or messages to transfer */
5966 if (gtk_widget_is_focus (folder_view)) {
5967 gboolean do_xfer = TRUE;
5969 /* Allow only to transfer folders to the local root folder */
5970 if (TNY_IS_ACCOUNT (dst_folder) &&
5971 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
5972 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
5974 } else if (!TNY_IS_FOLDER (src_folder)) {
5975 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
5980 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
5981 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
5983 info->src_folder = g_object_ref (src_folder);
5984 info->dst_folder = g_object_ref (dst_folder);
5985 info->delete_original = TRUE;
5986 info->folder_view = folder_view;
5988 connect_info->callback = on_move_folder_cb;
5989 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
5990 connect_info->data = info;
5992 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
5993 TNY_FOLDER_STORE (src_folder),
5996 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
5999 headers = modest_header_view_get_selected_headers(header_view);
6001 /* Transfer the messages */
6002 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
6003 headers, TNY_FOLDER (dst_folder));
6005 g_object_unref (headers);
6009 g_object_unref (src_folder);
6013 #ifdef MODEST_TOOLKIT_HILDON2
6015 * UI handler for the "Move to" action when invoked from the
6016 * ModestFolderWindow
6019 modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
6020 TnyFolderStore *dst_folder,
6024 TnyFolderStore *src_folder = NULL;
6025 TnyIterator *iterator;
6027 if (tny_list_get_length (selection) != 1)
6030 iterator = tny_list_create_iterator (selection);
6031 src_folder = TNY_FOLDER_STORE (tny_iterator_get_current (iterator));
6032 g_object_unref (iterator);
6035 gboolean do_xfer = TRUE;
6037 /* Allow only to transfer folders to the local root folder */
6038 if (TNY_IS_ACCOUNT (dst_folder) &&
6039 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
6040 !modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
6043 modest_platform_run_information_dialog (win,
6044 _("mail_in_ui_folder_move_target_error"),
6046 } else if (!TNY_IS_FOLDER (src_folder)) {
6047 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
6052 MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
6053 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
6055 info->src_folder = g_object_ref (src_folder);
6056 info->dst_folder = g_object_ref (dst_folder);
6057 info->delete_original = TRUE;
6058 info->folder_view = folder_view;
6060 connect_info->callback = on_move_folder_cb;
6061 connect_info->dst_account = get_account_from_folder_store (TNY_FOLDER_STORE (dst_folder));
6062 connect_info->data = info;
6064 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
6065 TNY_FOLDER_STORE (src_folder),
6070 g_object_unref (src_folder);
6076 modest_ui_actions_transfer_messages_helper (GtkWindow *win,
6077 TnyFolder *src_folder,
6079 TnyFolder *dst_folder)
6081 gboolean need_connection = TRUE;
6082 gboolean do_xfer = TRUE;
6083 XferMsgsHelper *helper;
6085 g_return_if_fail (TNY_IS_FOLDER (src_folder));
6086 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6087 g_return_if_fail (TNY_IS_LIST (headers));
6089 modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
6090 headers, TNY_FOLDER (dst_folder),
6091 TRUE, &need_connection,
6094 /* If we don't want to transfer just return */
6098 /* Create the helper */
6099 helper = g_slice_new (XferMsgsHelper);
6100 helper->dst_folder = g_object_ref (dst_folder);
6101 helper->headers = g_object_ref (headers);
6103 if (need_connection) {
6104 DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
6105 connect_info->callback = xfer_messages_performer;
6106 connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
6107 connect_info->data = helper;
6109 modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
6110 TNY_FOLDER_STORE (src_folder),
6113 TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
6114 xfer_messages_performer (FALSE, NULL, GTK_WINDOW (win),
6115 src_account, helper);
6116 g_object_unref (src_account);
6121 * UI handler for the "Move to" action when invoked from the
6122 * ModestMsgViewWindow
6125 modest_ui_actions_on_window_move_to (GtkAction *action,
6127 TnyFolderStore *dst_folder,
6130 TnyFolder *src_folder = NULL;
6132 g_return_if_fail (TNY_IS_FOLDER (dst_folder));
6135 TnyHeader *header = NULL;
6138 iter = tny_list_create_iterator (headers);
6139 header = (TnyHeader *) tny_iterator_get_current (iter);
6140 src_folder = tny_header_get_folder (header);
6142 /* Transfer the messages */
6143 modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
6145 TNY_FOLDER (dst_folder));
6148 g_object_unref (header);
6149 g_object_unref (iter);
6150 g_object_unref (src_folder);
6155 modest_ui_actions_on_move_to (GtkAction *action,
6158 modest_ui_actions_on_edit_mode_move_to (win);
6162 modest_ui_actions_on_edit_mode_move_to (ModestWindow *win)
6164 GtkWidget *dialog = NULL;
6165 MoveToInfo *helper = NULL;
6166 TnyList *list_to_move;
6168 g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
6170 #ifndef MODEST_TOOLKIT_HILDON2
6171 /* Get the main window if exists */
6172 ModestMainWindow *main_window;
6173 if (MODEST_IS_MAIN_WINDOW (win))
6174 main_window = MODEST_MAIN_WINDOW (win);
6177 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
6178 FALSE)); /* don't create */
6181 list_to_move = modest_platform_get_list_to_move (MODEST_WINDOW (win));
6186 if (tny_list_get_length (list_to_move) < 1) {
6187 g_object_unref (list_to_move);
6191 /* Create and run the dialog */
6192 dialog = create_move_to_dialog (GTK_WINDOW (win), NULL, list_to_move);
6193 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
6194 GTK_WINDOW (dialog),
6198 helper = g_slice_new0 (MoveToInfo);
6199 helper->list = list_to_move;
6202 /* Listen to response signal */
6203 g_signal_connect (dialog, "response", G_CALLBACK (on_move_to_dialog_response), helper);
6205 /* Show the dialog */
6206 gtk_widget_show (dialog);
6212 * Calls #HeadersFunc for each header already selected in the main
6213 * window or the message currently being shown in the msg view window
6216 do_headers_action (ModestWindow *win,
6220 TnyList *headers_list = NULL;
6221 TnyIterator *iter = NULL;
6222 TnyHeader *header = NULL;
6223 TnyFolder *folder = NULL;
6226 headers_list = get_selected_headers (win);
6230 /* Get the folder */
6231 iter = tny_list_create_iterator (headers_list);
6232 header = TNY_HEADER (tny_iterator_get_current (iter));
6234 folder = tny_header_get_folder (header);
6235 g_object_unref (header);
6238 /* Call the function for each header */
6239 while (!tny_iterator_is_done (iter)) {
6240 header = TNY_HEADER (tny_iterator_get_current (iter));
6241 func (header, win, user_data);
6242 g_object_unref (header);
6243 tny_iterator_next (iter);
6246 /* Trick: do a poke status in order to speed up the signaling
6249 tny_folder_poke_status (folder);
6250 g_object_unref (folder);
6254 g_object_unref (iter);
6255 g_object_unref (headers_list);
6259 modest_ui_actions_view_attachment (GtkAction *action,
6260 ModestWindow *window)
6262 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6263 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
6265 /* not supported window for this action */
6266 g_return_if_reached ();
6271 modest_ui_actions_save_attachments (GtkAction *action,
6272 ModestWindow *window)
6274 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6276 if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
6279 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
6281 /* not supported window for this action */
6282 g_return_if_reached ();
6287 modest_ui_actions_remove_attachments (GtkAction *action,
6288 ModestWindow *window)
6290 #ifndef MODEST_TOOLKIT_HILDON2
6291 if (MODEST_IS_MAIN_WINDOW (window)) {
6292 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
6293 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6295 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
6297 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
6299 /* not supported window for this action */
6300 g_return_if_reached ();
6305 modest_ui_actions_on_settings (GtkAction *action,
6310 dialog = modest_platform_get_global_settings_dialog ();
6311 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
6312 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
6313 gtk_widget_show_all (dialog);
6315 gtk_dialog_run (GTK_DIALOG (dialog));
6317 gtk_widget_destroy (dialog);
6321 modest_ui_actions_on_help (GtkAction *action,
6324 /* Help app is not available at all in fremantle */
6325 #ifndef MODEST_TOOLKIT_HILDON2
6326 const gchar *help_id;
6328 g_return_if_fail (win && GTK_IS_WINDOW(win));
6330 help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
6333 modest_platform_show_help (GTK_WINDOW (win), help_id);
6338 modest_ui_actions_on_csm_help (GtkAction *action,
6341 /* Help app is not available at all in fremantle */
6342 #ifndef MODEST_TOOLKIT_HILDON2
6344 const gchar* help_id = NULL;
6345 GtkWidget *folder_view;
6346 TnyFolderStore *folder_store;
6348 g_return_if_fail (win && MODEST_IS_MAIN_WINDOW (win));
6350 /* Get selected folder */
6351 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
6352 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6353 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6355 /* Switch help_id */
6356 if (folder_store && TNY_IS_FOLDER (folder_store))
6357 help_id = modest_tny_folder_get_help_id (TNY_FOLDER (folder_store));
6360 g_object_unref (folder_store);
6363 modest_platform_show_help (GTK_WINDOW (win), help_id);
6365 modest_ui_actions_on_help (action, win);
6370 retrieve_contents_cb (ModestMailOperation *mail_op,
6377 /* We only need this callback to show an error in case of
6378 memory low condition */
6379 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
6380 g_debug ("%s: message failed to retrieve. Memory low?", __FUNCTION__);
6385 retrieve_msg_contents_performer (gboolean canceled,
6387 GtkWindow *parent_window,
6388 TnyAccount *account,
6391 ModestMailOperation *mail_op;
6392 TnyList *headers = TNY_LIST (user_data);
6394 if (err || canceled) {
6395 modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
6396 (GtkWidget *) parent_window, err,
6401 /* Create mail operation */
6402 mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
6403 modest_ui_actions_disk_operations_error_handler,
6405 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
6406 modest_mail_operation_get_msgs_full (mail_op, headers, retrieve_contents_cb, NULL, NULL);
6409 g_object_unref (mail_op);
6411 g_object_unref (headers);
6412 g_object_unref (account);
6416 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
6417 ModestWindow *window)
6419 TnyList *headers = NULL;
6420 TnyAccount *account = NULL;
6421 TnyIterator *iter = NULL;
6422 TnyHeader *header = NULL;
6423 TnyFolder *folder = NULL;
6426 headers = get_selected_headers (window);
6430 /* Pick the account */
6431 iter = tny_list_create_iterator (headers);
6432 header = TNY_HEADER (tny_iterator_get_current (iter));
6433 folder = tny_header_get_folder (header);
6434 account = tny_folder_get_account (folder);
6435 g_object_unref (folder);
6436 g_object_unref (header);
6437 g_object_unref (iter);
6439 /* Connect and perform the message retrieval */
6440 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6441 g_object_ref (account),
6442 retrieve_msg_contents_performer,
6443 g_object_ref (headers));
6446 g_object_unref (account);
6447 g_object_unref (headers);
6451 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
6453 g_return_if_fail (MODEST_IS_WINDOW (window));
6456 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_TOOLBAR);
6460 modest_ui_actions_check_menu_dimming_rules (ModestWindow *window)
6462 g_return_if_fail (MODEST_IS_WINDOW (window));
6465 modest_window_check_dimming_rules_group (window, MODEST_DIMMING_RULES_MENU);
6469 modest_ui_actions_on_email_menu_activated (GtkAction *action,
6470 ModestWindow *window)
6472 g_return_if_fail (MODEST_IS_WINDOW (window));
6475 modest_ui_actions_check_menu_dimming_rules (window);
6479 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
6480 ModestWindow *window)
6482 g_return_if_fail (MODEST_IS_WINDOW (window));
6485 modest_ui_actions_check_menu_dimming_rules (window);
6489 modest_ui_actions_on_view_menu_activated (GtkAction *action,
6490 ModestWindow *window)
6492 g_return_if_fail (MODEST_IS_WINDOW (window));
6495 modest_ui_actions_check_menu_dimming_rules (window);
6499 modest_ui_actions_on_format_menu_activated (GtkAction *action,
6500 ModestWindow *window)
6502 g_return_if_fail (MODEST_IS_WINDOW (window));
6505 modest_ui_actions_check_menu_dimming_rules (window);
6509 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
6510 ModestWindow *window)
6512 g_return_if_fail (MODEST_IS_WINDOW (window));
6515 modest_ui_actions_check_menu_dimming_rules (window);
6519 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
6520 ModestWindow *window)
6522 g_return_if_fail (MODEST_IS_WINDOW (window));
6525 modest_ui_actions_check_menu_dimming_rules (window);
6529 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
6530 ModestWindow *window)
6532 g_return_if_fail (MODEST_IS_WINDOW (window));
6535 modest_ui_actions_check_menu_dimming_rules (window);
6539 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
6540 ModestWindow *window)
6542 g_return_if_fail (MODEST_IS_WINDOW (window));
6545 modest_ui_actions_check_menu_dimming_rules (window);
6549 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
6550 ModestWindow *window)
6552 g_return_if_fail (MODEST_IS_WINDOW (window));
6555 modest_ui_actions_check_menu_dimming_rules (window);
6559 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
6561 g_return_if_fail (MODEST_IS_WINDOW (window));
6563 /* we check for low-mem; in that case, show a warning, and don't allow
6566 if (modest_platform_check_memory_low (window, TRUE))
6569 modest_platform_show_search_messages (GTK_WINDOW (window));
6573 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
6575 g_return_if_fail (MODEST_IS_WINDOW (win));
6578 /* we check for low-mem; in that case, show a warning, and don't allow
6579 * for the addressbook
6581 if (modest_platform_check_memory_low (win, TRUE))
6585 modest_platform_show_addressbook (GTK_WINDOW (win));
6590 modest_ui_actions_on_toggle_find_in_page (GtkAction *action,
6591 ModestWindow *window)
6594 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
6596 if (GTK_IS_TOGGLE_ACTION (action))
6597 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
6601 modest_msg_edit_window_toggle_isearch_toolbar (MODEST_MSG_EDIT_WINDOW (window),
6605 #ifndef MODEST_TOOLKIT_HILDON2
6607 on_send_receive_finished (ModestMailOperation *mail_op,
6610 GtkWidget *header_view, *folder_view;
6611 TnyFolderStore *folder_store;
6612 ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
6614 /* Set send/receive operation finished */
6615 modest_main_window_notify_send_receive_completed (main_win);
6617 /* Don't refresh the current folder if there were any errors */
6618 if (modest_mail_operation_get_status (mail_op) !=
6619 MODEST_MAIL_OPERATION_STATUS_SUCCESS)
6622 /* Refresh the current folder if we're viewing a window. We do
6623 this because the user won't be able to see the new mails in
6624 the selected folder after a Send&Receive because it only
6625 performs a poke_status, i.e, only the number of read/unread
6626 messages is updated, but the new headers are not
6628 folder_view = modest_main_window_get_child_widget (main_win,
6629 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
6633 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
6635 /* Do not need to refresh INBOX again because the
6636 update_account does it always automatically */
6637 if (folder_store && TNY_IS_FOLDER (folder_store) &&
6638 tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
6639 ModestMailOperation *refresh_op;
6641 header_view = modest_main_window_get_child_widget (main_win,
6642 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6644 /* We do not need to set the contents style
6645 because it hasn't changed. We also do not
6646 need to save the widget status. Just force
6648 refresh_op = modest_mail_operation_new (G_OBJECT (main_win));
6649 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), refresh_op);
6650 modest_mail_operation_refresh_folder (refresh_op, TNY_FOLDER (folder_store),
6651 folder_refreshed_cb, main_win);
6652 g_object_unref (refresh_op);
6656 g_object_unref (folder_store);
6661 modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
6667 const gchar* server_name = NULL;
6668 TnyTransportAccount *transport;
6669 gchar *message = NULL;
6670 ModestProtocol *protocol;
6672 /* Don't show anything if the user cancelled something or the
6673 * send receive request is not interactive. Authentication
6674 * errors are managed by the account store so no need to show
6675 * a dialog here again */
6676 if (err->code == TNY_SYSTEM_ERROR_CANCEL ||
6677 err->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
6678 !modest_tny_send_queue_get_requested_send_receive (MODEST_TNY_SEND_QUEUE (self)))
6682 /* Get the server name. Note that we could be using a
6683 connection specific transport account */
6684 transport = (TnyTransportAccount *)
6685 tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
6687 ModestTnyAccountStore *acc_store;
6688 const gchar *acc_name;
6689 TnyTransportAccount *conn_specific;
6691 acc_store = modest_runtime_get_account_store();
6692 acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
6693 conn_specific = (TnyTransportAccount *)
6694 modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
6695 if (conn_specific) {
6696 server_name = tny_account_get_hostname (TNY_ACCOUNT (conn_specific));
6697 g_object_unref (conn_specific);
6699 server_name = tny_account_get_hostname (TNY_ACCOUNT (transport));
6701 g_object_unref (transport);
6705 protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
6706 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
6707 tny_account_get_proto (TNY_ACCOUNT (transport)));
6709 g_warning ("%s: Account with no proto", __FUNCTION__);
6713 /* Show the appropriate message text for the GError: */
6714 switch (err->code) {
6715 case TNY_SERVICE_ERROR_CONNECT:
6716 message = modest_protocol_get_translation (protocol,
6717 MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
6720 case TNY_SERVICE_ERROR_SEND:
6721 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6723 case TNY_SERVICE_ERROR_UNAVAILABLE:
6724 message = modest_protocol_get_translation (protocol,
6725 MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR,
6729 g_warning ("%s: unexpected ERROR %d",
6730 __FUNCTION__, err->code);
6731 message = g_strdup (_CS("sfil_ib_unable_to_send"));
6735 modest_platform_run_information_dialog (NULL, message, FALSE);
6740 modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
6745 ModestWindow *top_window = NULL;
6746 ModestWindowMgr *mgr = NULL;
6747 GtkWidget *header_view = NULL;
6748 TnyFolder *selected_folder = NULL;
6749 TnyFolderType folder_type;
6751 mgr = modest_runtime_get_window_mgr ();
6752 top_window = modest_window_mgr_get_current_top (mgr);
6757 #ifndef MODEST_TOOLKIT_HILDON2
6758 if (MODEST_IS_MAIN_WINDOW (top_window)) {
6759 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (top_window),
6760 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6763 if (MODEST_IS_HEADER_WINDOW (top_window)) {
6764 header_view = (GtkWidget *)
6765 modest_header_window_get_header_view (MODEST_HEADER_WINDOW (top_window));
6769 /* Get selected folder */
6771 selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
6772 if (!selected_folder)
6775 /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
6776 #if GTK_CHECK_VERSION(2, 8, 0)
6777 folder_type = modest_tny_folder_guess_folder_type (selected_folder);
6778 if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
6779 GtkTreeViewColumn *tree_column;
6781 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
6782 TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
6784 gtk_tree_view_column_queue_resize (tree_column);
6786 #else /* #if GTK_CHECK_VERSION(2, 8, 0) */
6787 gtk_widget_queue_draw (header_view);
6790 #ifndef MODEST_TOOLKIT_HILDON2
6791 /* Rerun dimming rules, because the message could become deletable for example */
6792 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6793 MODEST_DIMMING_RULES_TOOLBAR);
6794 modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
6795 MODEST_DIMMING_RULES_MENU);
6799 g_object_unref (selected_folder);
6803 modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
6804 TnyAccount *account)
6806 ModestProtocolType protocol_type;
6807 ModestProtocol *protocol;
6808 gchar *error_note = NULL;
6810 protocol_type = modest_tny_account_get_protocol_type (account);
6811 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6814 error_note = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, tny_account_get_hostname (account));
6815 if (error_note == NULL) {
6816 g_warning ("%s: This should not be reached", __FUNCTION__);
6818 modest_platform_run_information_dialog (parent_window, error_note, FALSE);
6819 g_free (error_note);
6824 modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
6828 TnyFolderStore *folder = NULL;
6829 TnyAccount *account = NULL;
6830 ModestProtocolType proto;
6831 ModestProtocol *protocol;
6832 TnyHeader *header = NULL;
6834 #ifndef MODEST_TOOLKIT_HILDON2
6835 if (MODEST_IS_MAIN_WINDOW (win)) {
6836 GtkWidget *header_view;
6837 TnyList* headers = NULL;
6839 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
6840 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
6841 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6842 if (!headers || tny_list_get_length (headers) == 0) {
6844 g_object_unref (headers);
6847 iter = tny_list_create_iterator (headers);
6848 header = TNY_HEADER (tny_iterator_get_current (iter));
6849 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6850 g_object_unref (iter);
6851 g_object_unref (headers);
6853 if (MODEST_IS_HEADER_WINDOW (win)) {
6854 GtkWidget *header_view;
6855 TnyList* headers = NULL;
6857 header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
6858 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
6859 if (!headers || tny_list_get_length (headers) == 0) {
6861 g_object_unref (headers);
6864 iter = tny_list_create_iterator (headers);
6865 header = TNY_HEADER (tny_iterator_get_current (iter));
6867 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6869 g_warning ("List should contain headers");
6871 g_object_unref (iter);
6872 g_object_unref (headers);
6874 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
6875 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
6877 folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
6880 if (!header || !folder)
6883 /* Get the account type */
6884 account = tny_folder_get_account (TNY_FOLDER (folder));
6885 proto = modest_tny_account_get_protocol_type (account);
6886 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6889 subject = tny_header_dup_subject (header);
6890 msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
6894 msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
6900 g_object_unref (account);
6902 g_object_unref (folder);
6904 g_object_unref (header);
6910 modest_ui_actions_on_delete_account (GtkWindow *parent_window,
6911 const gchar *account_name,
6912 const gchar *account_title)
6914 ModestAccountMgr *account_mgr;
6917 ModestProtocol *protocol;
6918 gboolean removed = FALSE;
6920 g_return_val_if_fail (account_name, FALSE);
6921 g_return_val_if_fail (account_title, FALSE);
6923 account_mgr = modest_runtime_get_account_mgr();
6925 /* The warning text depends on the account type: */
6926 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
6927 modest_account_mgr_get_store_protocol (account_mgr,
6929 txt = modest_protocol_get_translation (protocol,
6930 MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX,
6933 txt = g_strdup_printf (_("emev_nc_delete_mailbox"), account_title);
6935 response = modest_platform_run_confirmation_dialog (parent_window, txt);
6939 if (response == GTK_RESPONSE_OK) {
6940 /* Remove account. If it succeeds then it also removes
6941 the account from the ModestAccountView: */
6942 gboolean is_default = FALSE;
6943 gchar *default_account_name = modest_account_mgr_get_default_account (account_mgr);
6944 if (default_account_name && (strcmp (default_account_name, account_name) == 0))
6946 g_free (default_account_name);
6948 removed = modest_account_mgr_remove_account (account_mgr, account_name);
6950 /* Close all email notifications, we cannot
6951 distinguish if the notification belongs to
6952 this account or not, so for safety reasons
6953 we remove them all */
6954 modest_platform_remove_new_mail_notifications (FALSE);
6956 g_warning ("%s: modest_account_mgr_remove_account() failed.\n", __FUNCTION__);
6963 on_fetch_images_performer (gboolean canceled,
6965 GtkWindow *parent_window,
6966 TnyAccount *account,
6969 if (err || canceled) {
6970 /* Show an unable to retrieve images ??? */
6974 /* Note that the user could have closed the window while connecting */
6975 if (GTK_WIDGET_VISIBLE (parent_window))
6976 modest_msg_view_window_fetch_images ((ModestMsgViewWindow *) parent_window);
6977 g_object_unref ((GObject *) user_data);
6981 modest_ui_actions_on_fetch_images (GtkAction *action,
6982 ModestWindow *window)
6984 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
6986 modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
6988 on_fetch_images_performer,
6989 g_object_ref (window));
6993 modest_ui_actions_on_reload_message (const gchar *msg_id)
6995 ModestWindow *window = NULL;
6997 g_return_if_fail (msg_id && msg_id[0] != '\0');
6998 if (!modest_window_mgr_find_registered_message_uid (modest_runtime_get_window_mgr (),
7004 if (window == NULL || !MODEST_IS_MSG_VIEW_WINDOW (window))
7007 modest_msg_view_window_reload (MODEST_MSG_VIEW_WINDOW (window));
7010 /** Check whether any connections are active, and cancel them if
7012 * Returns TRUE is there was no problem,
7013 * or if an operation was cancelled so we can continue.
7014 * Returns FALSE if the user chose to cancel his request instead.
7018 modest_ui_actions_check_for_active_account (ModestWindow *self,
7019 const gchar* account_name)
7021 ModestTnySendQueue *send_queue;
7022 ModestTnyAccountStore *acc_store;
7023 ModestMailOperationQueue* queue;
7024 TnyConnectionStatus store_conn_status;
7025 TnyAccount *store_account = NULL, *transport_account = NULL;
7026 gboolean retval = TRUE, sending = FALSE;
7028 acc_store = modest_runtime_get_account_store ();
7029 queue = modest_runtime_get_mail_operation_queue ();
7032 modest_tny_account_store_get_server_account (acc_store,
7034 TNY_ACCOUNT_TYPE_STORE);
7036 /* This could happen if the account was deleted before the
7037 call to this function */
7042 modest_tny_account_store_get_server_account (acc_store,
7044 TNY_ACCOUNT_TYPE_TRANSPORT);
7046 /* This could happen if the account was deleted before the
7047 call to this function */
7048 if (!transport_account) {
7049 g_object_unref (store_account);
7053 /* If the transport account was not used yet, then the send
7054 queue could not exist (it's created on demand) */
7055 send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (transport_account), FALSE);
7056 if (TNY_IS_SEND_QUEUE (send_queue))
7057 sending = modest_tny_send_queue_sending_in_progress (send_queue);
7059 store_conn_status = tny_account_get_connection_status (store_account);
7060 if (store_conn_status == TNY_CONNECTION_STATUS_CONNECTED || sending) {
7063 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (self),
7064 _("emev_nc_disconnect_account"));
7065 if (response == GTK_RESPONSE_OK) {
7074 /* FIXME: We should only cancel those of this account */
7075 modest_mail_operation_queue_cancel_all (queue);
7077 /* Also disconnect the account */
7078 if ((tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED) &&
7079 (tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED_BROKEN)) {
7080 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account),
7084 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account),
7090 g_object_unref (store_account);
7091 g_object_unref (transport_account);