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-tny-folder.h>
39 #include <modest-tny-msg.h>
40 #include <modest-tny-account.h>
41 #include <modest-address-book.h>
42 #include "modest-error.h"
43 #include "modest-ui-actions.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
47 #include <tny-mime-part.h>
49 #ifdef MODEST_PLATFORM_MAEMO
50 #include "maemo/modest-osso-state-saving.h"
51 #include "maemo/modest-maemo-utils.h"
52 #endif /* MODEST_PLATFORM_MAEMO */
54 #include "widgets/modest-ui-constants.h"
55 #include <widgets/modest-main-window.h>
56 #include <widgets/modest-msg-view-window.h>
57 #include <widgets/modest-account-view-window.h>
58 #include <widgets/modest-details-dialog.h>
59 #include <widgets/modest-attachments-view.h>
60 #include "widgets/modest-folder-view.h"
61 #include "widgets/modest-global-settings-dialog.h"
62 #include "modest-connection-specific-smtp-window.h"
63 #include "modest-account-mgr-helpers.h"
64 #include "modest-mail-operation.h"
65 #include "modest-text-utils.h"
67 #ifdef MODEST_HAVE_EASYSETUP
68 #include "easysetup/modest-easysetup-wizard.h"
69 #endif /* MODEST_HAVE_EASYSETUP */
71 #include <modest-widget-memory.h>
72 #include <tny-error.h>
73 #include <tny-simple-list.h>
74 #include <tny-msg-view.h>
75 #include <tny-device.h>
76 #include <tny-merge-folder.h>
78 #include <gtkhtml/gtkhtml.h>
80 typedef struct _GetMsgAsyncHelper {
82 ModestMailOperation *mail_op;
89 typedef enum _ReplyForwardAction {
95 typedef struct _ReplyForwardHelper {
96 guint reply_forward_type;
97 ReplyForwardAction action;
99 GtkWidget *parent_window;
100 } ReplyForwardHelper;
104 * The do_headers_action uses this kind of functions to perform some
105 * action to each member of a list of headers
107 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
109 static void do_headers_action (ModestWindow *win,
113 static void open_msg_cb (ModestMailOperation *mail_op,
118 static void reply_forward_cb (ModestMailOperation *mail_op,
123 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
125 static void folder_refreshed_cb (ModestMailOperation *mail_op,
129 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
130 ModestMailOperationState *state,
136 run_account_setup_wizard (ModestWindow *win)
138 ModestEasysetupWizardDialog *wizard;
140 g_return_if_fail (MODEST_IS_WINDOW(win));
142 wizard = modest_easysetup_wizard_dialog_new ();
143 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
144 gtk_dialog_run (GTK_DIALOG (wizard));
145 gtk_widget_destroy (GTK_WIDGET (wizard));
150 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
153 const gchar *authors[] = {
154 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
157 about = gtk_about_dialog_new ();
158 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
159 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
160 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
161 _("Copyright (c) 2006, Nokia Corporation\n"
162 "All rights reserved."));
163 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
164 _("a modest e-mail client\n\n"
165 "design and implementation: Dirk-Jan C. Binnema\n"
166 "contributions from the fine people at KC and Ig\n"
167 "uses the tinymail email framework written by Philip van Hoof"));
168 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
169 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
171 gtk_dialog_run (GTK_DIALOG (about));
172 gtk_widget_destroy(about);
176 * Gets the list of currently selected messages. If the win is the
177 * main window, then it returns a newly allocated list of the headers
178 * selected in the header view. If win is the msg view window, then
179 * the value returned is a list with just a single header.
181 * The caller of this funcion must free the list.
184 get_selected_headers (ModestWindow *win)
186 if (MODEST_IS_MAIN_WINDOW(win)) {
187 GtkWidget *header_view;
189 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
190 MODEST_WIDGET_TYPE_HEADER_VIEW);
191 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
193 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
194 /* for MsgViewWindows, we simply return a list with one element */
196 TnyList *list = NULL;
198 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
199 if (header != NULL) {
200 list = tny_simple_list_new ();
201 tny_list_prepend (list, G_OBJECT(header));
202 g_object_unref (G_OBJECT(header));
212 headers_action_mark_as_read (TnyHeader *header,
216 TnyHeaderFlags flags;
218 g_return_if_fail (TNY_IS_HEADER(header));
220 flags = tny_header_get_flags (header);
221 if (flags & TNY_HEADER_FLAG_SEEN) return;
222 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
226 headers_action_mark_as_unread (TnyHeader *header,
230 TnyHeaderFlags flags;
232 g_return_if_fail (TNY_IS_HEADER(header));
234 flags = tny_header_get_flags (header);
235 if (flags & TNY_HEADER_FLAG_SEEN) {
236 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
242 headers_action_delete (TnyHeader *header,
246 ModestMailOperation *mail_op = NULL;
248 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
249 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
252 /* Always delete. TODO: Move to trash still not supported */
253 modest_mail_operation_remove_msg (mail_op, header, FALSE);
254 g_object_unref (G_OBJECT (mail_op));
256 /* refilter treemodel to hide marked-as-deleted rows */
257 if (MODEST_IS_HEADER_VIEW (user_data))
258 modest_header_view_refilter (MODEST_HEADER_VIEW (user_data));
262 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
264 TnyList *header_list = NULL;
265 TnyIterator *iter = NULL;
266 TnyHeader *header = NULL;
267 gchar *message = NULL;
270 ModestWindowMgr *mgr;
271 GtkWidget *header_view = NULL;
273 g_return_if_fail (MODEST_IS_WINDOW(win));
275 /* Check first if the header view has the focus */
276 if (MODEST_IS_MAIN_WINDOW (win)) {
278 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
279 MODEST_WIDGET_TYPE_HEADER_VIEW);
280 if (!gtk_widget_is_focus (header_view))
284 header_list = get_selected_headers (win);
285 if (!header_list) return;
287 /* Check if any of the headers is already opened, or in the process of being opened */
288 if (MODEST_IS_MAIN_WINDOW (win)) {
290 iter = tny_list_create_iterator (header_list);
292 mgr = modest_runtime_get_window_mgr ();
293 while (!tny_iterator_is_done (iter) && !found) {
294 header = TNY_HEADER (tny_iterator_get_current (iter));
295 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
296 g_object_unref (header);
297 tny_iterator_next (iter);
299 g_object_unref (iter);
304 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
305 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
307 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
311 g_object_unref (header_list);
317 if (tny_list_get_length(header_list) == 1) {
318 iter = tny_list_create_iterator (header_list);
319 header = TNY_HEADER (tny_iterator_get_current (iter));
320 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
321 g_object_unref (header);
322 g_object_unref (iter);
324 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
325 tny_list_get_length(header_list)), desc);
327 /* Confirmation dialog */
328 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
332 if (response == GTK_RESPONSE_OK) {
333 ModestWindow *main_window = NULL;
334 ModestWindowMgr *mgr = NULL;
335 GtkTreeModel *model = NULL;
336 GtkTreeSelection *sel = NULL;
337 GList *sel_list = NULL, *tmp = NULL;
338 GtkTreeRowReference *row_reference = NULL;
339 GtkTreePath *next_path = NULL;
341 /* Find last selected row */
342 if (MODEST_IS_MAIN_WINDOW (win)) {
343 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
344 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
345 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
346 for (tmp=sel_list; tmp; tmp=tmp->next) {
347 if (tmp->next == NULL) {
348 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
349 gtk_tree_path_next (next_path);
350 row_reference = gtk_tree_row_reference_new (model, next_path);
351 gtk_tree_path_free (next_path);
356 /* Remove each header. If it's a view window header_view == NULL */
357 do_headers_action (win, headers_action_delete, header_view);
359 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
360 /* Close msg view window or select next */
361 if (modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW (win)) &&
362 modest_msg_view_window_first_message_selected (MODEST_MSG_VIEW_WINDOW (win))) {
363 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
365 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (win));
368 /* Get main window */
369 mgr = modest_runtime_get_window_mgr ();
370 main_window = modest_window_mgr_get_main_window (mgr);
373 /* Move cursor to next row */
376 /* Select next row */
377 if (gtk_tree_row_reference_valid (row_reference)) {
378 next_path = gtk_tree_row_reference_get_path (row_reference);
379 gtk_tree_selection_select_path (sel, next_path);
380 gtk_tree_path_free (next_path);
382 if (row_reference != NULL)
383 gtk_tree_row_reference_free (row_reference);
386 /* Update toolbar dimming state */
387 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
390 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
391 g_list_free (sel_list);
397 g_object_unref (header_list);
403 /* delete either message or folder, based on where we are */
405 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
407 g_return_if_fail (MODEST_IS_WINDOW(win));
409 /* Check first if the header view has the focus */
410 if (MODEST_IS_MAIN_WINDOW (win)) {
412 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
413 MODEST_WIDGET_TYPE_FOLDER_VIEW);
414 if (gtk_widget_is_focus (w)) {
415 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
419 modest_ui_actions_on_delete_message (action, win);
425 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
427 #ifdef MODEST_PLATFORM_MAEMO
428 modest_osso_save_state();
429 #endif /* MODEST_PLATFORM_MAEMO */
431 g_debug ("closing down, clearing %d item(s) from operation queue",
432 modest_mail_operation_queue_num_elements
433 (modest_runtime_get_mail_operation_queue()));
435 /* cancel all outstanding operations */
436 modest_mail_operation_queue_cancel_all
437 (modest_runtime_get_mail_operation_queue());
439 g_debug ("queue has been cleared");
441 /* note: when modest-tny-account-store is finalized,
442 it will automatically set all network connections
449 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
452 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
454 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
455 /* gtk_widget_destroy (GTK_WIDGET (win)); */
456 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
457 /* gboolean ret_value; */
458 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
459 /* } else if (MODEST_IS_WINDOW (win)) { */
460 /* gtk_widget_destroy (GTK_WIDGET (win)); */
462 /* g_return_if_reached (); */
467 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
469 GtkClipboard *clipboard = NULL;
470 gchar *selection = NULL;
472 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
473 selection = gtk_clipboard_wait_for_text (clipboard);
475 /* Question: why is the clipboard being used here?
476 * It doesn't really make a lot of sense. */
480 modest_address_book_add_address (selection);
486 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
488 /* This is currently only implemented for Maemo */
489 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
490 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
491 run_account_setup_wizard (win);
494 /* Show the list of accounts: */
495 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
496 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
499 GtkWidget *dialog, *label;
501 /* Create the widgets */
503 dialog = gtk_dialog_new_with_buttons ("Message",
505 GTK_DIALOG_DESTROY_WITH_PARENT,
509 label = gtk_label_new ("Hello World!");
511 /* Ensure that the dialog box is destroyed when the user responds. */
513 g_signal_connect_swapped (dialog, "response",
514 G_CALLBACK (gtk_widget_destroy),
517 /* Add the label, and show everything we've added to the dialog. */
519 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
521 gtk_widget_show_all (dialog);
522 #endif /* MODEST_PLATFORM_MAEMO */
526 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
528 ModestWindow *main_window = MODEST_WINDOW (user_data);
530 /* Save any changes. */
531 modest_connection_specific_smtp_window_save_server_accounts (
532 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
533 modest_window_get_active_account (main_window));
534 gtk_widget_destroy (GTK_WIDGET (window));
540 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
542 /* This is currently only implemented for Maemo,
543 * because it requires an API (libconic) to detect different connection
546 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
548 /* Create the window if necessary: */
549 const gchar *active_account_name = modest_window_get_active_account (win);
551 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
552 * or show the default account?
553 * If we show the default account then the account name should be shown in
554 * the window when we show it. */
555 if (!active_account_name) {
556 g_warning ("%s: No account is active.", __FUNCTION__);
560 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
561 modest_connection_specific_smtp_window_fill_with_connections (
562 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
563 modest_runtime_get_account_mgr(),
564 active_account_name);
566 /* Show the window: */
567 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
568 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
569 gtk_widget_show (specific_window);
571 /* Save changes when the window is hidden: */
572 g_signal_connect (specific_window, "hide",
573 G_CALLBACK (on_smtp_servers_window_hide), win);
574 #endif /* MODEST_PLATFORM_MAEMO */
578 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
580 ModestWindow *msg_win = NULL;
582 TnyFolder *folder = NULL;
583 gchar *account_name = NULL;
584 gchar *from_str = NULL;
585 /* GError *err = NULL; */
586 TnyAccount *account = NULL;
587 ModestWindowMgr *mgr;
588 gchar *signature = NULL, *blank_and_signature = NULL;
590 /* if there are no accounts yet, just show the wizard */
591 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
592 run_account_setup_wizard (win);
596 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
598 account_name = g_strdup (modest_window_get_active_account (win));
600 g_printerr ("modest: no account found\n");
604 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
606 TNY_ACCOUNT_TYPE_STORE);
608 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
612 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
614 g_printerr ("modest: failed get from string for '%s'\n", account_name);
618 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
619 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
620 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
621 MODEST_ACCOUNT_SIGNATURE, FALSE);
622 blank_and_signature = g_strconcat ("\n", signature, NULL);
625 blank_and_signature = g_strdup ("");
628 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
630 g_printerr ("modest: failed to create new msg\n");
634 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
636 g_printerr ("modest: failed to find Drafts folder\n");
641 /* Create and register edit window */
642 /* This is destroyed by TOOD. */
643 msg_win = modest_msg_edit_window_new (msg, account_name);
644 mgr = modest_runtime_get_window_mgr ();
645 modest_window_mgr_register_window (mgr, msg_win);
648 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
650 gtk_widget_show_all (GTK_WIDGET (msg_win));
653 g_free (account_name);
655 g_free (blank_and_signature);
657 g_object_unref (msg_win);
659 g_object_unref (G_OBJECT(account));
661 g_object_unref (G_OBJECT(msg));
663 g_object_unref (G_OBJECT(folder));
667 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
671 ModestMailOperationStatus status;
673 /* If there is no message or the operation was not successful */
674 status = modest_mail_operation_get_status (mail_op);
675 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
677 /* Remove the header from the preregistered uids */
678 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
688 open_msg_cb (ModestMailOperation *mail_op,
693 ModestWindowMgr *mgr = NULL;
694 ModestWindow *parent_win = NULL;
695 ModestWindow *win = NULL;
696 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
697 gchar *account = NULL;
700 /* Do nothing if there was any problem with the mail
701 operation. The error will be shown by the error_handler of
702 the mail operation */
703 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
704 printf ("DEBUG: %s: modest_ui_actions_msg_retrieval_check() failed.\n",
709 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
710 folder = tny_header_get_folder (header);
712 /* Mark header as read */
713 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
716 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
718 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
720 /* Gets folder type (OUTBOX headers will be opened in edit window */
721 if (modest_tny_folder_is_local_folder (folder))
722 folder_type = modest_tny_folder_get_local_folder_type (folder);
724 /* If the header is in the drafts folder then open the editor,
725 else the message view window */
726 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
727 /* we cannot edit without a valid account... */
728 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
729 run_account_setup_wizard(parent_win);
732 win = modest_msg_edit_window_new (msg, account);
734 gchar *uid = modest_tny_folder_get_header_unique_id (header);
736 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
737 GtkWidget *header_view;
738 GtkTreeSelection *sel;
739 GList *sel_list = NULL;
742 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
743 MODEST_WIDGET_TYPE_HEADER_VIEW);
745 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
746 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
748 if (sel_list != NULL) {
749 GtkTreeRowReference *row_reference;
751 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
752 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
753 g_list_free (sel_list);
755 win = modest_msg_view_window_new_with_header_model (msg,
760 gtk_tree_row_reference_free (row_reference);
762 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
765 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
770 /* Register and show new window */
772 mgr = modest_runtime_get_window_mgr ();
773 modest_window_mgr_register_window (mgr, win);
774 g_object_unref (win);
775 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
776 gtk_widget_show_all (GTK_WIDGET(win));
779 /* Update toolbar dimming state */
780 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
781 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
787 g_object_unref (parent_win);
788 /* g_object_unref (msg); */
789 g_object_unref (folder);
793 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
797 GObject *win = modest_mail_operation_get_source (mail_op);
799 error = modest_mail_operation_get_error (mail_op);
800 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
802 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
804 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
807 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
808 _("mail_ni_ui_folder_get_msg_folder_error"));
812 g_object_unref (win);
816 * This function is used by both modest_ui_actions_on_open and
817 * modest_ui_actions_on_header_activated. This way we always do the
818 * same when trying to open messages.
821 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
823 ModestWindowMgr *mgr = NULL;
824 TnyIterator *iter = NULL;
825 ModestMailOperation *mail_op1 = NULL;
826 ModestMailOperation *mail_op2 = NULL;
827 TnyList *not_opened_headers = NULL;
828 TnyList *not_opened_cached_headers = NULL;
829 TnyHeaderFlags flags;
831 /* Look if we already have a message view for each header. If
832 true, then remove the header from the list of headers to
834 mgr = modest_runtime_get_window_mgr ();
835 iter = tny_list_create_iterator (headers);
836 not_opened_headers = tny_simple_list_new ();
837 not_opened_cached_headers = tny_simple_list_new ();
838 while (!tny_iterator_is_done (iter)) {
840 ModestWindow *window;
844 header = TNY_HEADER (tny_iterator_get_current (iter));
845 flags = tny_header_get_flags (header);
848 found = modest_window_mgr_find_registered_header (mgr, header, &window);
850 /* Do not open again the message and present the
851 window to the user */
854 gtk_window_present (GTK_WINDOW (window));
856 /* the header has been registered already, we don't do
857 * anything but wait for the window to come up*/
858 g_warning ("debug: header %p already registered, waiting for window",
861 if (!(flags & TNY_HEADER_FLAG_CACHED))
862 tny_list_append (not_opened_headers, G_OBJECT (header));
863 /* Check if msg has already been retreived */
865 tny_list_append (not_opened_cached_headers, G_OBJECT (header));
867 g_object_unref (header);
868 tny_iterator_next (iter);
870 g_object_unref (iter);
873 /* If some messages would have to be downloaded, ask the user to
874 * make a connection. It's generally easier to do this here (in the mainloop)
875 * than later in a thread:
877 if (tny_list_get_length (not_opened_cached_headers) > 0) {
878 gboolean connected = modest_platform_connect_and_wait (GTK_WINDOW (win));
880 /* Don't go further if a connection would be necessary but none is available: */
882 g_object_unref (not_opened_headers);
883 g_object_unref (not_opened_cached_headers);
888 /* Register the headers before actually creating the windows: */
889 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
890 while (!tny_iterator_is_done (iter_not_opened)) {
891 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
892 modest_window_mgr_register_header (mgr, header);
893 g_object_unref (header);
895 tny_iterator_next (iter_not_opened);
897 g_object_unref (iter_not_opened);
898 iter_not_opened = NULL;
900 TnyIterator *iter_cached = tny_list_create_iterator (not_opened_cached_headers);
901 while (!tny_iterator_is_done (iter_cached)) {
902 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_cached));
903 modest_window_mgr_register_header (mgr, header);
904 g_object_unref (header);
906 tny_iterator_next (iter_cached);
908 g_object_unref (iter_cached);
912 /* Open each uncached message */
913 if (tny_list_get_length (not_opened_headers) > 0) {
914 mail_op1 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
916 modest_ui_actions_get_msgs_full_error_handler,
918 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op1);
919 if (tny_list_get_length (not_opened_headers) > 1) {
920 modest_mail_operation_get_msgs_full (mail_op1,
926 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
927 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
928 modest_mail_operation_get_msg (mail_op1, header, open_msg_cb, NULL);
929 g_object_unref (header);
930 g_object_unref (iter);
934 /* Open each cached message */
935 if (tny_list_get_length (not_opened_cached_headers) > 0) {
936 mail_op2 = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
938 modest_ui_actions_get_msgs_full_error_handler,
940 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op2);
941 if (tny_list_get_length (not_opened_cached_headers) > 1) {
942 modest_mail_operation_get_msgs_full (mail_op2,
948 TnyIterator *iter = tny_list_create_iterator (not_opened_cached_headers);
949 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
950 modest_mail_operation_get_msg (mail_op2, header, open_msg_cb, NULL);
951 g_object_unref (header);
952 g_object_unref (iter);
957 if (not_opened_headers != NULL)
958 g_object_unref (not_opened_headers);
959 if (not_opened_cached_headers != NULL)
960 g_object_unref (not_opened_cached_headers);
962 g_object_unref (iter);
963 if (mail_op1 != NULL)
964 g_object_unref (mail_op1);
965 if (mail_op2 != NULL)
966 g_object_unref (mail_op2);
970 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
975 headers = get_selected_headers (win);
980 _modest_ui_actions_open (headers, win);
982 g_object_unref(headers);
987 free_reply_forward_helper (gpointer data)
989 ReplyForwardHelper *helper;
991 helper = (ReplyForwardHelper *) data;
992 g_free (helper->account_name);
993 g_slice_free (ReplyForwardHelper, helper);
997 reply_forward_cb (ModestMailOperation *mail_op,
1003 ReplyForwardHelper *rf_helper;
1004 ModestWindow *msg_win = NULL;
1005 ModestEditType edit_type;
1007 TnyAccount *account = NULL;
1008 ModestWindowMgr *mgr = NULL;
1009 gchar *signature = NULL;
1011 /* If there was any error. The mail operation could be NULL,
1012 this means that we already have the message downloaded and
1013 that we didn't do a mail operation to retrieve it */
1014 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1017 g_return_if_fail (user_data != NULL);
1018 rf_helper = (ReplyForwardHelper *) user_data;
1020 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1021 rf_helper->account_name);
1022 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1023 rf_helper->account_name,
1024 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1025 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1026 rf_helper->account_name,
1027 MODEST_ACCOUNT_SIGNATURE, FALSE);
1030 /* Create reply mail */
1031 switch (rf_helper->action) {
1034 modest_tny_msg_create_reply_msg (msg, from, signature,
1035 rf_helper->reply_forward_type,
1036 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1038 case ACTION_REPLY_TO_ALL:
1040 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
1041 MODEST_TNY_MSG_REPLY_MODE_ALL);
1042 edit_type = MODEST_EDIT_TYPE_REPLY;
1044 case ACTION_FORWARD:
1046 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1047 edit_type = MODEST_EDIT_TYPE_FORWARD;
1050 g_return_if_reached ();
1057 g_printerr ("modest: failed to create message\n");
1061 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1062 rf_helper->account_name,
1063 TNY_ACCOUNT_TYPE_STORE);
1065 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1069 /* Create and register the windows */
1070 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
1071 mgr = modest_runtime_get_window_mgr ();
1072 modest_window_mgr_register_window (mgr, msg_win);
1074 if (rf_helper->parent_window != NULL) {
1075 gdouble parent_zoom;
1077 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1078 modest_window_set_zoom (msg_win, parent_zoom);
1081 /* Show edit window */
1082 gtk_widget_show_all (GTK_WIDGET (msg_win));
1086 g_object_unref (msg_win);
1088 g_object_unref (G_OBJECT (new_msg));
1090 g_object_unref (G_OBJECT (account));
1091 /* g_object_unref (msg); */
1092 g_object_unref (header);
1093 free_reply_forward_helper (rf_helper);
1097 * Checks a list of headers. If any of them are not currently
1098 * downloaded (CACHED) then it asks the user for permission to
1101 * Returns FALSE if the user does not want to download the
1102 * messages. Returns TRUE if the user allowed the download or if all
1103 * of them are currently downloaded
1106 download_uncached_messages (TnyList *header_list, GtkWindow *win)
1110 gint uncached_messages = 0;
1112 iter = tny_list_create_iterator (header_list);
1113 while (!tny_iterator_is_done (iter)) {
1115 TnyHeaderFlags flags;
1117 header = TNY_HEADER (tny_iterator_get_current (iter));
1118 flags = tny_header_get_flags (header);
1119 /* TODO: is this the right flag?, it seems that some
1120 headers that have been previously downloaded do not
1122 if (! (flags & TNY_HEADER_FLAG_CACHED))
1123 uncached_messages ++;
1124 g_object_unref (header);
1125 tny_iterator_next (iter);
1127 g_object_unref (iter);
1129 /* Ask for user permission to download the messages */
1131 if (uncached_messages > 0) {
1132 GtkResponseType response;
1134 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1135 ngettext("mcen_nc_get_msg",
1137 uncached_messages));
1138 if (response == GTK_RESPONSE_CANCEL)
1141 /* If a download will be necessary, make sure that we have a connection: */
1142 retval = modest_platform_connect_and_wait(win);
1150 * Common code for the reply and forward actions
1153 reply_forward (ReplyForwardAction action, ModestWindow *win)
1155 ModestMailOperation *mail_op = NULL;
1156 TnyList *header_list = NULL;
1157 ReplyForwardHelper *rf_helper = NULL;
1158 guint reply_forward_type;
1159 gboolean continue_download;
1161 g_return_if_fail (MODEST_IS_WINDOW(win));
1163 /* we need an account when editing */
1164 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1165 run_account_setup_wizard (win);
1169 header_list = get_selected_headers (win);
1173 /* Check that the messages have been previously downloaded */
1174 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
1175 if (!continue_download) {
1176 g_object_unref (header_list);
1180 reply_forward_type =
1181 modest_conf_get_int (modest_runtime_get_conf (),
1182 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1184 /* We assume that we can only select messages of the
1185 same folder and that we reply all of them from the
1186 same account. In fact the interface currently only
1187 allows single selection */
1190 rf_helper = g_slice_new0 (ReplyForwardHelper);
1191 rf_helper->reply_forward_type = reply_forward_type;
1192 rf_helper->action = action;
1193 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1194 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1195 rf_helper->parent_window = GTK_WIDGET (win);
1196 if (!rf_helper->account_name)
1197 rf_helper->account_name =
1198 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1200 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1203 /* Get header and message. Do not free them here, the
1204 reply_forward_cb must do it */
1205 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1206 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1207 if (!msg || !header) {
1209 g_object_unref (msg);
1211 g_object_unref (header);
1212 g_printerr ("modest: no message found\n");
1215 reply_forward_cb (NULL, header, msg, rf_helper);
1221 /* Retrieve messages */
1222 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1224 modest_ui_actions_get_msgs_full_error_handler,
1226 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1228 /* Only reply/forward to one message */
1229 iter = tny_list_create_iterator (header_list);
1230 header = TNY_HEADER (tny_iterator_get_current (iter));
1231 g_object_unref (iter);
1233 modest_mail_operation_get_msg (mail_op,
1238 /* modest_mail_operation_get_msgs_full (mail_op, */
1240 /* reply_forward_cb, */
1242 /* free_reply_forward_helper); */
1245 g_object_unref(mail_op);
1249 g_object_unref (header_list);
1253 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1255 g_return_if_fail (MODEST_IS_WINDOW(win));
1257 reply_forward (ACTION_REPLY, win);
1261 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1263 g_return_if_fail (MODEST_IS_WINDOW(win));
1265 reply_forward (ACTION_FORWARD, win);
1269 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1271 g_return_if_fail (MODEST_IS_WINDOW(win));
1273 reply_forward (ACTION_REPLY_TO_ALL, win);
1277 modest_ui_actions_on_next (GtkAction *action,
1278 ModestWindow *window)
1280 if (MODEST_IS_MAIN_WINDOW (window)) {
1281 GtkWidget *header_view;
1283 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1284 MODEST_WIDGET_TYPE_HEADER_VIEW);
1288 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1289 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1290 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1292 g_return_if_reached ();
1297 modest_ui_actions_on_prev (GtkAction *action,
1298 ModestWindow *window)
1300 g_return_if_fail (MODEST_IS_WINDOW(window));
1302 if (MODEST_IS_MAIN_WINDOW (window)) {
1303 GtkWidget *header_view;
1304 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1305 MODEST_WIDGET_TYPE_HEADER_VIEW);
1309 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1310 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1311 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1313 g_return_if_reached ();
1318 modest_ui_actions_on_sort (GtkAction *action,
1319 ModestWindow *window)
1321 g_return_if_fail (MODEST_IS_WINDOW(window));
1323 if (MODEST_IS_MAIN_WINDOW (window)) {
1324 GtkWidget *header_view;
1325 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1326 MODEST_WIDGET_TYPE_HEADER_VIEW);
1330 /* Show sorting dialog */
1331 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1336 new_messages_arrived (ModestMailOperation *self,
1340 if (new_messages == 0)
1343 modest_platform_on_new_msg ();
1347 * This function performs the send & receive required actions. The
1348 * window is used to create the mail operation. Typically it should
1349 * always be the main window, but we pass it as argument in order to
1353 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1355 gchar *acc_name = NULL;
1356 ModestMailOperation *mail_op;
1358 /* If no account name was provided then get the current account, and if
1359 there is no current account then pick the default one: */
1360 if (!account_name) {
1361 acc_name = g_strdup (modest_window_get_active_account(win));
1363 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1365 g_printerr ("modest: cannot get default account\n");
1369 acc_name = g_strdup (account_name);
1372 /* Set send/receive operation in progress */
1373 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1375 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1377 modest_ui_actions_send_receive_error_handler,
1380 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1381 G_CALLBACK (_on_send_receive_progress_changed),
1384 /* Send & receive. */
1385 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1386 /* Receive and then send. The operation is tagged initially as
1387 a receive operation because the account update performs a
1388 receive and then a send. The operation changes its type
1389 internally, so the progress objects will receive the proper
1390 progress information */
1391 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1392 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1393 g_object_unref (G_OBJECT (mail_op));
1401 modest_ui_actions_do_cancel_send (const gchar *account_name,
1404 TnyTransportAccount *transport_account;
1405 TnySendQueue *send_queue = NULL;
1406 GError *error = NULL;
1408 /* Get transport account */
1410 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1411 (modest_runtime_get_account_store(),
1413 TNY_ACCOUNT_TYPE_TRANSPORT));
1414 if (!transport_account) {
1415 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1420 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1421 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1422 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1423 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1424 "modest: could not find send queue for account\n");
1426 /* Keeep messages in outbox folder */
1427 tny_send_queue_cancel (send_queue, FALSE, &error);
1431 if (transport_account != NULL)
1432 g_object_unref (G_OBJECT (transport_account));
1436 modest_ui_actions_cancel_send_all (ModestWindow *win)
1438 GSList *account_names, *iter;
1440 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1443 iter = account_names;
1445 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1446 iter = g_slist_next (iter);
1449 modest_account_mgr_free_account_names (account_names);
1450 account_names = NULL;
1454 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1457 /* Check if accounts exist */
1458 gboolean accounts_exist =
1459 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1461 /* If not, allow the user to create an account before trying to send/receive. */
1462 if (!accounts_exist)
1463 modest_ui_actions_on_accounts (NULL, win);
1465 /* Cancel all sending operaitons */
1466 modest_ui_actions_cancel_send_all (win);
1470 * Refreshes all accounts. This function will be used by automatic
1474 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1476 GSList *account_names, *iter;
1478 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1481 iter = account_names;
1483 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1484 iter = g_slist_next (iter);
1487 modest_account_mgr_free_account_names (account_names);
1488 account_names = NULL;
1492 * Handler of the click on Send&Receive button in the main toolbar
1495 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1497 /* Check if accounts exist */
1498 gboolean accounts_exist =
1499 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1501 /* If not, allow the user to create an account before trying to send/receive. */
1502 if (!accounts_exist)
1503 modest_ui_actions_on_accounts (NULL, win);
1505 /* Refresh currently selected folder. Note that if we only
1506 want to retrive the headers, then the refresh only will
1507 invoke a poke_status over all folders, i.e., only the
1508 total/unread count will be updated */
1509 if (MODEST_IS_MAIN_WINDOW (win)) {
1510 GtkWidget *header_view, *folder_view;
1511 TnyFolderStore *folder_store;
1513 /* Get folder and header view */
1515 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1516 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1518 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1520 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1522 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1523 MODEST_WIDGET_TYPE_HEADER_VIEW);
1525 /* We do not need to set the contents style
1526 because it hasn't changed. We also do not
1527 need to save the widget status. Just force
1529 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1530 TNY_FOLDER (folder_store),
1531 folder_refreshed_cb,
1532 MODEST_MAIN_WINDOW (win));
1536 g_object_unref (folder_store);
1539 /* Refresh the active account */
1540 modest_ui_actions_do_send_receive (NULL, win);
1545 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1548 GtkWidget *header_view;
1550 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1552 header_view = modest_main_window_get_child_widget (main_window,
1553 MODEST_WIDGET_TYPE_HEADER_VIEW);
1557 conf = modest_runtime_get_conf ();
1559 /* what is saved/restored is depending on the style; thus; we save with
1560 * old style, then update the style, and restore for this new style
1562 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1564 if (modest_header_view_get_style
1565 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1566 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1567 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1569 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1570 MODEST_HEADER_VIEW_STYLE_DETAILS);
1572 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1573 MODEST_CONF_HEADER_VIEW_KEY);
1578 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1580 ModestMainWindow *main_window)
1582 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1583 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1585 /* If no header has been selected then exit */
1590 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1591 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1593 /* Update Main window title */
1594 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1595 const gchar *subject = tny_header_get_subject (header);
1596 if (subject && strlen(subject) > 0)
1597 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1599 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1602 /* Update toolbar dimming state */
1603 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1607 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1609 ModestMainWindow *main_window)
1613 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1618 headers = tny_simple_list_new ();
1619 tny_list_prepend (headers, G_OBJECT (header));
1621 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1623 g_object_unref (headers);
1627 set_active_account_from_tny_account (TnyAccount *account,
1628 ModestWindow *window)
1630 const gchar *server_acc_name = tny_account_get_id (account);
1632 /* We need the TnyAccount provided by the
1633 account store because that is the one that
1634 knows the name of the Modest account */
1635 TnyAccount *modest_server_account = modest_server_account =
1636 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1637 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1640 const gchar *modest_acc_name =
1641 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1642 modest_window_set_active_account (window, modest_acc_name);
1643 g_object_unref (modest_server_account);
1648 folder_refreshed_cb (ModestMailOperation *mail_op,
1652 ModestMainWindow *win = NULL;
1653 GtkWidget *header_view;
1655 g_return_if_fail (TNY_IS_FOLDER (folder));
1657 win = MODEST_MAIN_WINDOW (user_data);
1659 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1661 /* Check if folder is empty and set headers view contents style */
1662 if (tny_folder_get_all_count (folder) == 0) {
1663 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1664 modest_main_window_set_contents_style (win,
1665 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1667 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1672 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1673 TnyFolderStore *folder_store,
1675 ModestMainWindow *main_window)
1678 GtkWidget *header_view;
1680 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1682 header_view = modest_main_window_get_child_widget(main_window,
1683 MODEST_WIDGET_TYPE_HEADER_VIEW);
1687 conf = modest_runtime_get_conf ();
1689 if (TNY_IS_ACCOUNT (folder_store)) {
1691 /* Update active account */
1692 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1693 /* Show account details */
1694 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1697 if (TNY_IS_FOLDER (folder_store) && selected) {
1699 /* Update the active account */
1700 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1702 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1703 g_object_unref (account);
1707 /* Set the header style by default, it could
1708 be changed later by the refresh callback to
1710 modest_main_window_set_contents_style (main_window,
1711 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1713 /* Set folder on header view. This function
1714 will call tny_folder_refresh_async so we
1715 pass a callback that will be called when
1716 finished. We use that callback to set the
1717 empty view if there are no messages */
1718 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1719 TNY_FOLDER (folder_store),
1720 folder_refreshed_cb,
1723 /* Restore configuration. We need to do this
1724 *after* the set_folder because the widget
1725 memory asks the header view about its
1727 modest_widget_memory_restore (modest_runtime_get_conf (),
1728 G_OBJECT(header_view),
1729 MODEST_CONF_HEADER_VIEW_KEY);
1731 /* Update the active account */
1732 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1733 /* Save only if we're seeing headers */
1734 if (modest_main_window_get_contents_style (main_window) ==
1735 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1736 modest_widget_memory_save (conf, G_OBJECT (header_view),
1737 MODEST_CONF_HEADER_VIEW_KEY);
1738 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1742 /* Update toolbar dimming state */
1743 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1747 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1754 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1756 online = tny_device_is_online (modest_runtime_get_device());
1759 /* already online -- the item is simply not there... */
1760 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1762 GTK_MESSAGE_WARNING,
1764 _("The %s you selected cannot be found"),
1766 gtk_dialog_run (GTK_DIALOG(dialog));
1768 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1772 GTK_RESPONSE_REJECT,
1774 GTK_RESPONSE_ACCEPT,
1776 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1777 "Do you want to get online?"), item);
1778 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1779 gtk_label_new (txt), FALSE, FALSE, 0);
1780 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1783 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1784 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1785 // modest_platform_connect_and_wait ();
1788 gtk_widget_destroy (dialog);
1792 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1795 /* g_message ("%s %s", __FUNCTION__, link); */
1800 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1803 modest_platform_activate_uri (link);
1807 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1810 modest_platform_show_uri_popup (link);
1814 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1817 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1821 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1822 const gchar *address,
1825 /* g_message ("%s %s", __FUNCTION__, address); */
1829 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1831 TnyTransportAccount *transport_account;
1832 ModestMailOperation *mail_operation;
1834 gchar *account_name, *from;
1835 ModestAccountMgr *account_mgr;
1836 gchar *info_text = NULL;
1837 TnyMsg *new_draft = NULL;
1839 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1841 data = modest_msg_edit_window_get_msg_data (edit_window);
1843 account_mgr = modest_runtime_get_account_mgr();
1844 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1846 account_name = modest_account_mgr_get_default_account (account_mgr);
1847 if (!account_name) {
1848 g_printerr ("modest: no account found\n");
1849 modest_msg_edit_window_free_msg_data (edit_window, data);
1853 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1854 account_name = g_strdup (data->account_name);
1858 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1859 (modest_runtime_get_account_store(),
1861 TNY_ACCOUNT_TYPE_TRANSPORT));
1862 if (!transport_account) {
1863 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1864 g_free (account_name);
1865 modest_msg_edit_window_free_msg_data (edit_window, data);
1868 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1870 /* Create the mail operation */
1871 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1872 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1874 new_draft = modest_mail_operation_save_to_drafts (mail_operation,
1885 data->priority_flags);
1888 g_free (account_name);
1889 g_object_unref (G_OBJECT (transport_account));
1890 g_object_unref (G_OBJECT (mail_operation));
1892 modest_msg_edit_window_free_msg_data (edit_window, data);
1894 modest_msg_edit_window_set_draft (edit_window, new_draft);
1895 if (new_draft != NULL)
1896 g_object_unref (new_draft);
1898 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1899 modest_platform_information_banner (NULL, NULL, info_text);
1903 /* For instance, when clicking the Send toolbar button when editing a message: */
1905 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1907 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1909 if (!modest_msg_edit_window_check_names (edit_window))
1912 /* Offer the connection dialog, if necessary: */
1913 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window)))
1916 /* FIXME: Code added just for testing. The final version will
1917 use the send queue provided by tinymail and some
1919 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1920 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1922 account_name = modest_account_mgr_get_default_account (account_mgr);
1924 if (!account_name) {
1925 g_printerr ("modest: no account found\n");
1929 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1931 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1932 account_name = g_strdup (data->account_name);
1935 /* Get the currently-active transport account for this modest account: */
1936 TnyTransportAccount *transport_account =
1937 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1938 (modest_runtime_get_account_store(),
1940 if (!transport_account) {
1941 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1942 g_free (account_name);
1943 modest_msg_edit_window_free_msg_data (edit_window, data);
1947 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1949 /* mail content checks and dialogs */
1950 if (data->subject == NULL || data->subject[0] == '\0') {
1951 GtkResponseType response;
1952 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1953 _("mcen_nc_subject_is_empty_send"));
1954 if (response == GTK_RESPONSE_CANCEL) {
1955 g_free (account_name);
1960 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1961 GtkResponseType response;
1962 gchar *note_message;
1963 gchar *note_subject = data->subject;
1964 if (note_subject == NULL || note_subject[0] == '\0')
1965 note_subject = _("mail_va_no_subject");
1966 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1967 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1969 g_free (note_message);
1970 if (response == GTK_RESPONSE_CANCEL) {
1971 g_free (account_name);
1976 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
1978 /* Create the mail operation */
1979 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1980 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1982 modest_mail_operation_send_new_mail (mail_operation,
1993 data->priority_flags);
1997 g_free (account_name);
1998 g_object_unref (G_OBJECT (transport_account));
1999 g_object_unref (G_OBJECT (mail_operation));
2001 modest_msg_edit_window_free_msg_data (edit_window, data);
2002 modest_msg_edit_window_set_sent (edit_window, TRUE);
2004 /* Save settings and close the window: */
2005 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2009 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2010 ModestMsgEditWindow *window)
2012 ModestMsgEditFormatState *format_state = NULL;
2014 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2015 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2017 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2020 format_state = modest_msg_edit_window_get_format_state (window);
2021 g_return_if_fail (format_state != NULL);
2023 format_state->bold = gtk_toggle_action_get_active (action);
2024 modest_msg_edit_window_set_format_state (window, format_state);
2025 g_free (format_state);
2030 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2031 ModestMsgEditWindow *window)
2033 ModestMsgEditFormatState *format_state = NULL;
2035 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2036 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2038 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2041 format_state = modest_msg_edit_window_get_format_state (window);
2042 g_return_if_fail (format_state != NULL);
2044 format_state->italics = gtk_toggle_action_get_active (action);
2045 modest_msg_edit_window_set_format_state (window, format_state);
2046 g_free (format_state);
2051 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2052 ModestMsgEditWindow *window)
2054 ModestMsgEditFormatState *format_state = NULL;
2056 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2057 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2059 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2062 format_state = modest_msg_edit_window_get_format_state (window);
2063 g_return_if_fail (format_state != NULL);
2065 format_state->bullet = gtk_toggle_action_get_active (action);
2066 modest_msg_edit_window_set_format_state (window, format_state);
2067 g_free (format_state);
2072 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2073 GtkRadioAction *selected,
2074 ModestMsgEditWindow *window)
2076 ModestMsgEditFormatState *format_state = NULL;
2077 GtkJustification value;
2079 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2081 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2084 value = gtk_radio_action_get_current_value (selected);
2086 format_state = modest_msg_edit_window_get_format_state (window);
2087 g_return_if_fail (format_state != NULL);
2089 format_state->justification = value;
2090 modest_msg_edit_window_set_format_state (window, format_state);
2091 g_free (format_state);
2095 modest_ui_actions_on_select_editor_color (GtkAction *action,
2096 ModestMsgEditWindow *window)
2098 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2099 g_return_if_fail (GTK_IS_ACTION (action));
2101 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2104 modest_msg_edit_window_select_color (window);
2108 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2109 ModestMsgEditWindow *window)
2111 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2112 g_return_if_fail (GTK_IS_ACTION (action));
2114 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2117 modest_msg_edit_window_select_background_color (window);
2121 modest_ui_actions_on_insert_image (GtkAction *action,
2122 ModestMsgEditWindow *window)
2124 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2125 g_return_if_fail (GTK_IS_ACTION (action));
2127 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2130 modest_msg_edit_window_insert_image (window);
2134 modest_ui_actions_on_attach_file (GtkAction *action,
2135 ModestMsgEditWindow *window)
2137 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2138 g_return_if_fail (GTK_IS_ACTION (action));
2140 modest_msg_edit_window_attach_file (window);
2144 modest_ui_actions_on_remove_attachments (GtkAction *action,
2145 ModestMsgEditWindow *window)
2147 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2148 g_return_if_fail (GTK_IS_ACTION (action));
2150 modest_msg_edit_window_remove_attachments (window, NULL);
2154 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2157 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2159 /* TODO: Note that folder creation might go wrong due to other
2160 * failures such as when the parent folder is non-writable. We can
2161 * query a GError* with modest_mail_operation_get_error(), but the
2162 * the error code (from tinymail) does not give us a clue about what
2163 * has gone wrong. We might use the error->message but it might come
2164 * from camel and not be suitable to show to the user directly. */
2165 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2166 _CS("ckdg_ib_folder_already_exists"));
2168 /* modest_platform_information_banner (GTK_WIDGET (window), NULL,
2169 modest_mail_operation_get_error (mail_op)->message);*/
2173 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2175 TnyFolderStore *parent_folder;
2176 GtkWidget *folder_view;
2178 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2180 folder_view = modest_main_window_get_child_widget (main_window,
2181 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2185 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2187 if (parent_folder) {
2188 gboolean finished = FALSE;
2190 gchar *folder_name = NULL, *suggested_name = NULL;
2192 /* Run the new folder dialog */
2194 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
2199 g_free (suggested_name);
2200 suggested_name = NULL;
2202 if (result == GTK_RESPONSE_REJECT) {
2205 ModestMailOperation *mail_op;
2206 TnyFolder *new_folder = NULL;
2208 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2209 G_OBJECT(main_window),
2210 modest_ui_actions_new_folder_error_handler,
2213 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2215 new_folder = modest_mail_operation_create_folder (mail_op,
2217 (const gchar *) folder_name);
2219 g_object_unref (new_folder);
2222 g_object_unref (mail_op);
2225 suggested_name = folder_name;
2229 g_object_unref (parent_folder);
2234 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2237 GObject *win = modest_mail_operation_get_source (mail_op);
2238 const GError *error = NULL;
2239 const gchar *message = NULL;
2241 /* Get error message */
2242 error = modest_mail_operation_get_error (mail_op);
2243 if (error != NULL && error->message != NULL) {
2244 message = error->message;
2246 message = _("!!! FIXME: Unable to rename");
2249 /* Show notification dialog */
2250 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
2251 g_object_unref (win);
2255 modest_ui_actions_on_rename_folder (GtkAction *action,
2256 ModestMainWindow *main_window)
2258 TnyFolderStore *folder;
2259 GtkWidget *folder_view;
2260 GtkWidget *header_view;
2262 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2264 folder_view = modest_main_window_get_child_widget (main_window,
2265 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2269 header_view = modest_main_window_get_child_widget (main_window,
2270 MODEST_WIDGET_TYPE_HEADER_VIEW);
2275 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2277 /* Offer the connection dialog if necessary: */
2278 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2279 g_object_unref (G_OBJECT (folder));
2284 if (folder && TNY_IS_FOLDER (folder)) {
2287 const gchar *current_name;
2289 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2290 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2291 current_name, &folder_name);
2293 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2294 ModestMailOperation *mail_op;
2297 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2298 G_OBJECT(main_window),
2299 modest_ui_actions_rename_folder_error_handler,
2303 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2306 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2308 modest_mail_operation_rename_folder (mail_op,
2309 TNY_FOLDER (folder),
2310 (const gchar *) folder_name);
2312 g_object_unref (mail_op);
2313 g_free (folder_name);
2315 g_object_unref (folder);
2320 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2323 GObject *win = modest_mail_operation_get_source (mail_op);
2325 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2326 _("mail_in_ui_folder_delete_error"));
2327 g_object_unref (win);
2331 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2333 TnyFolderStore *folder;
2334 GtkWidget *folder_view;
2338 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2340 folder_view = modest_main_window_get_child_widget (main_window,
2341 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2345 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2347 /* Show an error if it's an account */
2348 if (!TNY_IS_FOLDER (folder)) {
2349 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2350 _("mail_in_ui_folder_delete_error"));
2351 g_object_unref (G_OBJECT (folder));
2355 /* Offer the connection dialog if necessary: */
2356 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2357 g_object_unref (G_OBJECT (folder));
2362 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2363 tny_folder_get_name (TNY_FOLDER (folder)));
2364 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2365 (const gchar *) message);
2368 if (response == GTK_RESPONSE_OK) {
2369 ModestMailOperation *mail_op =
2370 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2371 G_OBJECT(main_window),
2372 modest_ui_actions_delete_folder_error_handler,
2375 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2377 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2378 g_object_unref (G_OBJECT (mail_op));
2381 g_object_unref (G_OBJECT (folder));
2385 modest_ui_actions_on_delete_folder (GtkAction *action,
2386 ModestMainWindow *main_window)
2388 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2390 delete_folder (main_window, FALSE);
2394 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2396 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2398 delete_folder (main_window, TRUE);
2402 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2403 const gchar* server_account_name,
2408 ModestMainWindow *main_window)
2410 g_return_if_fail(server_account_name);
2411 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2413 /* Initalize output parameters: */
2420 #ifdef MODEST_PLATFORM_MAEMO
2421 /* Maemo uses a different (awkward) button order,
2422 * It should probably just use gtk_alternative_dialog_button_order ().
2424 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2428 GTK_RESPONSE_ACCEPT,
2430 GTK_RESPONSE_REJECT,
2433 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2437 GTK_RESPONSE_REJECT,
2439 GTK_RESPONSE_ACCEPT,
2441 #endif /* MODEST_PLATFORM_MAEMO */
2443 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2445 gchar *server_name = modest_server_account_get_hostname (
2446 modest_runtime_get_account_mgr(), server_account_name);
2447 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2448 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2453 /* This causes a warning because the logical ID has no %s in it,
2454 * though the translation does, but there is not much we can do about that: */
2455 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2456 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2459 g_free (server_name);
2463 gchar *initial_username = modest_server_account_get_username (
2464 modest_runtime_get_account_mgr(), server_account_name);
2466 GtkWidget *entry_username = gtk_entry_new ();
2467 if (initial_username)
2468 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2469 /* Dim this if a connection has ever succeeded with this username,
2470 * as per the UI spec: */
2471 const gboolean username_known =
2472 modest_server_account_get_username_has_succeeded(
2473 modest_runtime_get_account_mgr(), server_account_name);
2474 gtk_widget_set_sensitive (entry_username, !username_known);
2476 #ifdef MODEST_PLATFORM_MAEMO
2477 /* Auto-capitalization is the default, so let's turn it off: */
2478 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2480 /* Create a size group to be used by all captions.
2481 * Note that HildonCaption does not create a default size group if we do not specify one.
2482 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2483 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2485 GtkWidget *caption = hildon_caption_new (sizegroup,
2486 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2487 gtk_widget_show (entry_username);
2488 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2489 FALSE, FALSE, MODEST_MARGIN_HALF);
2490 gtk_widget_show (caption);
2492 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2494 #endif /* MODEST_PLATFORM_MAEMO */
2497 GtkWidget *entry_password = gtk_entry_new ();
2498 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2499 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2501 #ifdef MODEST_PLATFORM_MAEMO
2502 /* Auto-capitalization is the default, so let's turn it off: */
2503 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2504 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2506 caption = hildon_caption_new (sizegroup,
2507 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2508 gtk_widget_show (entry_password);
2509 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2510 FALSE, FALSE, MODEST_MARGIN_HALF);
2511 gtk_widget_show (caption);
2512 g_object_unref (sizegroup);
2514 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2516 #endif /* MODEST_PLATFORM_MAEMO */
2518 /* This is not in the Maemo UI spec:
2519 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2520 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2524 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2526 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2528 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2530 modest_server_account_set_username (
2531 modest_runtime_get_account_mgr(), server_account_name,
2534 const gboolean username_was_changed =
2535 (strcmp (*username, initial_username) != 0);
2536 if (username_was_changed) {
2537 g_warning ("%s: tinymail does not yet support changing the "
2538 "username in the get_password() callback.\n", __FUNCTION__);
2543 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2545 /* We do not save the password in the configuration,
2546 * because this function is only called for passwords that should
2547 * not be remembered:
2548 modest_server_account_set_password (
2549 modest_runtime_get_account_mgr(), server_account_name,
2568 /* This is not in the Maemo UI spec:
2569 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2575 gtk_widget_destroy (dialog);
2577 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2581 modest_ui_actions_on_cut (GtkAction *action,
2582 ModestWindow *window)
2584 GtkWidget *focused_widget;
2586 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2587 if (GTK_IS_EDITABLE (focused_widget)) {
2588 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2589 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2590 GtkTextBuffer *buffer;
2591 GtkClipboard *clipboard;
2593 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2594 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2595 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2596 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2597 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2598 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2599 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2600 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2605 modest_ui_actions_on_copy (GtkAction *action,
2606 ModestWindow *window)
2608 GtkClipboard *clipboard;
2609 GtkWidget *focused_widget;
2611 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2612 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2614 if (GTK_IS_LABEL (focused_widget)) {
2615 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2616 } else if (GTK_IS_EDITABLE (focused_widget)) {
2617 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2618 } else if (GTK_IS_HTML (focused_widget)) {
2619 gtk_html_copy (GTK_HTML (focused_widget));
2620 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2621 GtkTextBuffer *buffer;
2622 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2623 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2624 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2625 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2626 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2627 TnyIterator *iter = tny_list_create_iterator (header_list);
2628 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2629 TnyFolder *folder = tny_header_get_folder (header);
2630 TnyAccount *account = tny_folder_get_account (folder);
2631 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2632 /* If it's POP then ask */
2633 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2634 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2635 g_object_unref (account);
2636 g_object_unref (folder);
2637 g_object_unref (header);
2638 g_object_unref (iter);
2640 /* Check that the messages have been previously downloaded */
2641 gboolean continue_download = TRUE;
2643 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window));
2644 if (continue_download)
2645 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2646 g_object_unref (header_list);
2647 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2648 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2651 /* Show information banner */
2652 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2657 modest_ui_actions_on_undo (GtkAction *action,
2658 ModestWindow *window)
2660 ModestEmailClipboard *clipboard = NULL;
2662 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2663 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2664 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2665 /* Clear clipboard source */
2666 clipboard = modest_runtime_get_email_clipboard ();
2667 modest_email_clipboard_clear (clipboard);
2670 g_return_if_reached ();
2675 modest_ui_actions_on_redo (GtkAction *action,
2676 ModestWindow *window)
2678 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2679 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2682 g_return_if_reached ();
2688 paste_msgs_cb (const GObject *object, gpointer user_data)
2690 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2691 g_return_if_fail (GTK_IS_WIDGET (user_data));
2693 /* destroy information note */
2694 gtk_widget_destroy (GTK_WIDGET(user_data));
2698 modest_ui_actions_on_paste (GtkAction *action,
2699 ModestWindow *window)
2701 GtkWidget *focused_widget = NULL;
2702 GtkWidget *inf_note = NULL;
2703 ModestMailOperation *mail_op = NULL;
2705 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2706 if (GTK_IS_EDITABLE (focused_widget)) {
2707 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2708 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2709 GtkTextBuffer *buffer;
2710 GtkClipboard *clipboard;
2712 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2713 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2714 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2715 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2716 ModestEmailClipboard *clipboard = NULL;
2717 TnyFolder *src_folder = NULL;
2718 TnyFolderStore *folder_store = NULL;
2719 TnyList *data = NULL;
2720 gboolean delete = FALSE;
2722 /* Check clipboard source */
2723 clipboard = modest_runtime_get_email_clipboard ();
2724 if (modest_email_clipboard_cleared (clipboard))
2727 /* Get elements to paste */
2728 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2730 /* Create a new mail operation */
2731 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2732 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2735 /* Get destination folder */
2736 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2738 /* Launch notification */
2739 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2740 _CS("ckct_nw_pasting"));
2741 if (inf_note != NULL) {
2742 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
2743 gtk_widget_show (GTK_WIDGET(inf_note));
2746 /* transfer messages */
2748 modest_mail_operation_xfer_msgs (mail_op,
2750 TNY_FOLDER (folder_store),
2755 } else if (src_folder != NULL) {
2756 modest_mail_operation_xfer_folder (mail_op,
2766 g_object_unref (data);
2767 if (src_folder != NULL)
2768 g_object_unref (src_folder);
2769 if (folder_store != NULL)
2770 g_object_unref (folder_store);
2776 modest_ui_actions_on_select_all (GtkAction *action,
2777 ModestWindow *window)
2779 GtkWidget *focused_widget;
2781 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2782 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2783 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2784 } else if (GTK_IS_LABEL (focused_widget)) {
2785 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2786 } else if (GTK_IS_EDITABLE (focused_widget)) {
2787 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2788 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2789 GtkTextBuffer *buffer;
2790 GtkTextIter start, end;
2792 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2793 gtk_text_buffer_get_start_iter (buffer, &start);
2794 gtk_text_buffer_get_end_iter (buffer, &end);
2795 gtk_text_buffer_select_range (buffer, &start, &end);
2796 } else if (GTK_IS_HTML (focused_widget)) {
2797 gtk_html_select_all (GTK_HTML (focused_widget));
2798 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2799 GtkWidget *header_view = focused_widget;
2800 GtkTreeSelection *selection = NULL;
2802 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2803 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2804 MODEST_WIDGET_TYPE_HEADER_VIEW);
2806 /* Select all messages */
2807 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2808 gtk_tree_selection_select_all (selection);
2810 /* Set focuse on header view */
2811 gtk_widget_grab_focus (header_view);
2817 modest_ui_actions_on_mark_as_read (GtkAction *action,
2818 ModestWindow *window)
2820 g_return_if_fail (MODEST_IS_WINDOW(window));
2822 /* Mark each header as read */
2823 do_headers_action (window, headers_action_mark_as_read, NULL);
2827 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2828 ModestWindow *window)
2830 g_return_if_fail (MODEST_IS_WINDOW(window));
2832 /* Mark each header as read */
2833 do_headers_action (window, headers_action_mark_as_unread, NULL);
2837 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2838 GtkRadioAction *selected,
2839 ModestWindow *window)
2843 value = gtk_radio_action_get_current_value (selected);
2844 if (MODEST_IS_WINDOW (window)) {
2845 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2849 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2850 GtkRadioAction *selected,
2851 ModestWindow *window)
2853 TnyHeaderFlags flags;
2854 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2856 flags = gtk_radio_action_get_current_value (selected);
2857 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2860 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2861 GtkRadioAction *selected,
2862 ModestWindow *window)
2866 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2868 file_format = gtk_radio_action_get_current_value (selected);
2869 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2874 modest_ui_actions_on_zoom_plus (GtkAction *action,
2875 ModestWindow *window)
2877 g_return_if_fail (MODEST_IS_WINDOW (window));
2879 modest_window_zoom_plus (MODEST_WINDOW (window));
2883 modest_ui_actions_on_zoom_minus (GtkAction *action,
2884 ModestWindow *window)
2886 g_return_if_fail (MODEST_IS_WINDOW (window));
2888 modest_window_zoom_minus (MODEST_WINDOW (window));
2892 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2893 ModestWindow *window)
2895 ModestWindowMgr *mgr;
2896 gboolean fullscreen, active;
2897 g_return_if_fail (MODEST_IS_WINDOW (window));
2899 mgr = modest_runtime_get_window_mgr ();
2901 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2902 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2904 if (active != fullscreen) {
2905 modest_window_mgr_set_fullscreen_mode (mgr, active);
2906 gtk_window_present (GTK_WINDOW (window));
2911 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2912 ModestWindow *window)
2914 ModestWindowMgr *mgr;
2915 gboolean fullscreen;
2917 g_return_if_fail (MODEST_IS_WINDOW (window));
2919 mgr = modest_runtime_get_window_mgr ();
2920 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2921 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2923 gtk_window_present (GTK_WINDOW (window));
2927 * Used by modest_ui_actions_on_details to call do_headers_action
2930 headers_action_show_details (TnyHeader *header,
2931 ModestWindow *window,
2938 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2941 gtk_widget_show_all (dialog);
2942 gtk_dialog_run (GTK_DIALOG (dialog));
2944 gtk_widget_destroy (dialog);
2948 * Show the folder details in a ModestDetailsDialog widget
2951 show_folder_details (TnyFolder *folder,
2957 dialog = modest_details_dialog_new_with_folder (window, folder);
2960 gtk_widget_show_all (dialog);
2961 gtk_dialog_run (GTK_DIALOG (dialog));
2963 gtk_widget_destroy (dialog);
2967 * Show the header details in a ModestDetailsDialog widget
2970 modest_ui_actions_on_details (GtkAction *action,
2973 TnyList * headers_list;
2977 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2980 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2983 g_object_unref (msg);
2985 headers_list = get_selected_headers (win);
2989 iter = tny_list_create_iterator (headers_list);
2991 header = TNY_HEADER (tny_iterator_get_current (iter));
2992 headers_action_show_details (header, win, NULL);
2993 g_object_unref (header);
2995 g_object_unref (iter);
2996 g_object_unref (headers_list);
2998 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2999 GtkWidget *folder_view, *header_view;
3001 /* Check which widget has the focus */
3002 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3003 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3004 if (gtk_widget_is_focus (folder_view)) {
3005 TnyFolderStore *folder_store
3006 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3007 if (!folder_store) {
3008 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3011 /* Show only when it's a folder */
3012 /* This function should not be called for account items,
3013 * because we dim the menu item for them. */
3014 if (TNY_IS_FOLDER (folder_store)) {
3015 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3018 g_object_unref (folder_store);
3021 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3022 MODEST_WIDGET_TYPE_HEADER_VIEW);
3023 /* Show details of each header */
3024 do_headers_action (win, headers_action_show_details, header_view);
3030 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3031 ModestMsgEditWindow *window)
3033 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3035 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3039 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3040 ModestMsgEditWindow *window)
3042 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3044 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3048 modest_ui_actions_toggle_folders_view (GtkAction *action,
3049 ModestMainWindow *main_window)
3051 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3053 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3054 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3056 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3060 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3061 ModestWindow *window)
3063 gboolean active, fullscreen = FALSE;
3064 ModestWindowMgr *mgr;
3066 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3068 /* Check if we want to toggle the toolbar vuew in fullscreen
3070 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3071 "ViewShowToolbarFullScreen")) {
3075 /* Toggle toolbar */
3076 mgr = modest_runtime_get_window_mgr ();
3077 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3081 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3082 ModestMsgEditWindow *window)
3084 modest_msg_edit_window_select_font (window);
3088 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3089 const gchar *display_name,
3092 /* Do not change the application name if the widget has not
3093 the focus. This callback could be called even if the folder
3094 view has not the focus, because the handled signal could be
3095 emitted when the folder view is redrawn */
3096 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3098 gtk_window_set_title (window, display_name);
3100 gtk_window_set_title (window, " ");
3105 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3107 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3108 modest_msg_edit_window_select_contacts (window);
3112 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3114 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3115 modest_msg_edit_window_check_names (window);
3120 create_move_to_dialog (ModestWindow *win,
3121 GtkWidget *folder_view,
3122 GtkWidget **tree_view)
3124 GtkWidget *dialog, *scroll;
3126 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3128 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3130 GTK_RESPONSE_ACCEPT,
3132 GTK_RESPONSE_REJECT,
3135 /* Create scrolled window */
3136 scroll = gtk_scrolled_window_new (NULL, NULL);
3137 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3138 GTK_POLICY_AUTOMATIC,
3139 GTK_POLICY_AUTOMATIC);
3141 /* Create folder view */
3142 *tree_view = modest_platform_create_folder_view (NULL);
3144 /* It could happen that we're trying to move a message from a
3145 window (msg window for example) after the main window was
3146 closed, so we can not just get the model of the folder
3148 if (MODEST_IS_FOLDER_VIEW (folder_view))
3149 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3150 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3152 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3153 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3155 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3157 /* Add scroll to dialog */
3158 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3159 scroll, FALSE, FALSE, 0);
3161 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3163 /* Select INBOX or local account */
3164 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (*tree_view));
3170 * Returns TRUE if at least one of the headers of the list belongs to
3171 * a message that has been fully retrieved.
3174 has_retrieved_msgs (TnyList *list)
3177 gboolean found = FALSE;
3179 iter = tny_list_create_iterator (list);
3180 while (tny_iterator_is_done (iter) && !found) {
3182 TnyHeaderFlags flags;
3184 header = TNY_HEADER (tny_iterator_get_current (iter));
3185 flags = tny_header_get_flags (header);
3186 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
3190 tny_iterator_next (iter);
3192 g_object_unref (iter);
3198 * Shows a confirmation dialog to the user when we're moving messages
3199 * from a remote server to the local storage. Returns the dialog
3200 * response. If it's other kind of movement the it always returns
3204 msgs_move_to_confirmation (GtkWindow *win,
3205 TnyFolder *dest_folder,
3208 gint response = GTK_RESPONSE_OK;
3210 /* If the destination is a local folder */
3211 if (modest_tny_folder_is_local_folder (dest_folder)) {
3212 TnyFolder *src_folder;
3216 /* Get source folder */
3217 iter = tny_list_create_iterator (headers);
3218 header = TNY_HEADER (tny_iterator_get_current (iter));
3219 src_folder = tny_header_get_folder (header);
3220 g_object_unref (header);
3221 g_object_unref (iter);
3223 /* if no src_folder, message may be an attahcment */
3224 if (src_folder == NULL)
3225 return GTK_RESPONSE_CANCEL;
3227 /* If the source is a remote folder */
3228 if (!modest_tny_folder_is_local_folder (src_folder)) {
3229 const gchar *message;
3231 if (has_retrieved_msgs (headers))
3232 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3233 tny_list_get_length (headers));
3235 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3236 tny_list_get_length (headers));
3238 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3239 (const gchar *) message);
3241 g_object_unref (src_folder);
3249 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3251 ModestMsgViewWindow *self = NULL;
3252 gboolean last, first;
3254 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3255 self = MODEST_MSG_VIEW_WINDOW (object);
3257 last = modest_msg_view_window_last_message_selected (self);
3258 first = modest_msg_view_window_first_message_selected (self);
3260 /* No more messages to view, so close this window */
3261 /* gboolean ret_value; */
3262 /* g_signal_emit_by_name (G_OBJECT (self), "delete-event", NULL, &ret_value); */
3263 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3265 modest_msg_view_window_select_previous_message (self);
3267 modest_msg_view_window_select_next_message (self);
3271 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3274 GObject *win = modest_mail_operation_get_source (mail_op);
3275 const GError *error = NULL;
3276 const gchar *message = NULL;
3278 /* Get error message */
3279 error = modest_mail_operation_get_error (mail_op);
3280 if (error != NULL && error->message != NULL) {
3281 message = error->message;
3283 message = _("mail_in_ui_folder_move_target_error");
3286 /* Show notification dialog */
3287 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3288 g_object_unref (win);
3292 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3295 GObject *win = modest_mail_operation_get_source (mail_op);
3296 const GError *error = modest_mail_operation_get_error (mail_op);
3298 g_return_if_fail (error != NULL);
3299 if (error->message != NULL)
3300 g_printerr ("modest: %s\n", error->message);
3302 g_printerr ("modest: unkonw error on send&receive operation");
3304 /* Show error message */
3305 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3306 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3307 /* _CS("sfil_ib_unable_to_receive")); */
3309 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3310 /* _CS("sfil_ib_unable_to_send")); */
3311 g_object_unref (win);
3315 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3322 gint pending_purges = 0;
3323 gboolean some_purged = FALSE;
3324 ModestWindow *win = MODEST_WINDOW (user_data);
3326 /* If there was any error */
3327 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
3330 /* Once the message has been retrieved for purging, we check if
3331 * it's all ok for purging */
3333 parts = tny_simple_list_new ();
3334 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3335 iter = tny_list_create_iterator (parts);
3337 while (!tny_iterator_is_done (iter)) {
3339 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3340 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)) {
3341 if (tny_mime_part_is_purged (part))
3346 tny_iterator_next (iter);
3349 if (pending_purges>0) {
3351 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3353 if (response == GTK_RESPONSE_OK) {
3354 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3355 tny_iterator_first (iter);
3356 while (!tny_iterator_is_done (iter)) {
3359 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3360 if (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))
3361 tny_mime_part_set_purged (part);
3362 tny_iterator_next (iter);
3365 tny_msg_rewrite_cache (msg);
3368 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3371 /* remove attachments */
3372 tny_iterator_first (iter);
3373 while (!tny_iterator_is_done (iter)) {
3376 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3377 g_object_unref (part);
3378 tny_iterator_next (iter);
3381 g_object_unref (iter);
3382 g_object_unref (parts);
3386 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3387 ModestMainWindow *win)
3389 GtkWidget *header_view;
3390 TnyList *header_list;
3393 TnyHeaderFlags flags;
3394 ModestWindow *msg_view_window = NULL;
3397 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3399 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3400 MODEST_WIDGET_TYPE_HEADER_VIEW);
3402 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3404 if (tny_list_get_length (header_list) == 1) {
3405 iter = tny_list_create_iterator (header_list);
3406 header = TNY_HEADER (tny_iterator_get_current (iter));
3407 g_object_unref (iter);
3412 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3413 header, &msg_view_window);
3414 flags = tny_header_get_flags (header);
3415 if (!(flags & TNY_HEADER_FLAG_CACHED))
3418 if (msg_view_window != NULL)
3419 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3421 /* do nothing; uid was registered before, so window is probably on it's way */
3422 g_warning ("debug: header %p has already been registered", header);
3425 ModestMailOperation *mail_op = NULL;
3426 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3427 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3429 modest_ui_actions_get_msgs_full_error_handler,
3431 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3432 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3434 g_object_unref (mail_op);
3437 g_object_unref (header);
3439 g_object_unref (header_list);
3443 * UI handler for the "Move to" action when invoked from the
3447 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3448 ModestMainWindow *win)
3450 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3451 GtkWidget *header_view = NULL;
3453 TnyFolderStore *folder_store = NULL;
3454 ModestMailOperation *mail_op = NULL;
3456 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3458 /* Get the folder view */
3459 folder_view = modest_main_window_get_child_widget (win,
3460 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3462 TnyFolderStore *src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3464 /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3465 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win), src_folder)) {
3467 g_object_unref (src_folder);
3473 /* Get header view */
3474 header_view = modest_main_window_get_child_widget (win,
3475 MODEST_WIDGET_TYPE_HEADER_VIEW);
3477 /* Create and run the dialog */
3478 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
3479 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3480 result = gtk_dialog_run (GTK_DIALOG(dialog));
3481 g_object_ref (tree_view);
3483 /* We do this to save an indentation level ;-) */
3484 if (result != GTK_RESPONSE_ACCEPT)
3487 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3489 if (TNY_IS_ACCOUNT (folder_store) &&
3490 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (folder_store))
3493 /* Offer the connection dialog if necessary: */
3494 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win), folder_store)) {
3498 /* Get folder or messages to transfer */
3499 if (gtk_widget_is_focus (folder_view)) {
3501 /* Clean folder on header view before moving it */
3502 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3504 if (TNY_IS_FOLDER (src_folder)) {
3506 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3508 modest_ui_actions_move_folder_error_handler,
3510 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3512 modest_mail_operation_xfer_folder (mail_op,
3513 TNY_FOLDER (src_folder),
3516 /* Unref mail operation */
3517 g_object_unref (G_OBJECT (mail_op));
3519 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3522 if (gtk_widget_is_focus (header_view)) {
3523 TnyList *headers = NULL;
3526 /* TODO: Check for connection if the headers are on a network account. */
3527 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3529 /* Ask for user confirmation */
3530 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3531 TNY_FOLDER (folder_store),
3534 /* Transfer messages */
3535 if (response == GTK_RESPONSE_OK) {
3537 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3539 modest_ui_actions_move_folder_error_handler,
3541 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3544 modest_mail_operation_xfer_msgs (mail_op,
3546 TNY_FOLDER (folder_store),
3551 g_object_unref (G_OBJECT (mail_op));
3553 g_object_unref (headers);
3559 g_object_unref (src_folder);
3562 g_object_unref (folder_store);
3564 gtk_widget_destroy (dialog);
3569 * UI handler for the "Move to" action when invoked from the
3570 * ModestMsgViewWindow
3573 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3574 ModestMsgViewWindow *win)
3576 GtkWidget *dialog, *folder_view, *tree_view = NULL;
3578 ModestMainWindow *main_window = NULL;
3579 TnyHeader *header = NULL;
3580 TnyList *headers = NULL;
3582 /* Get the folder view */
3583 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3585 folder_view = modest_main_window_get_child_widget (main_window,
3586 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3590 /* Create and run the dialog */
3591 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
3592 result = gtk_dialog_run (GTK_DIALOG(dialog));
3594 if (result == GTK_RESPONSE_ACCEPT) {
3595 TnyFolderStore *folder_store;
3598 /* Create header list */
3599 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3600 g_return_if_fail (header != NULL);
3602 /* Offer the connection dialog if necessary: */
3603 /* TODO: What's the extra g_object_ref() for? Isn't this leaking a ref? */
3604 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (g_object_ref (tree_view)));
3605 TnyFolder *header_folder = tny_header_get_folder(header);
3606 if (modest_platform_connect_and_wait_if_network_folderstore (NULL, folder_store) &&
3607 modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (header_folder))) {
3609 headers = tny_simple_list_new ();
3610 tny_list_prepend (headers, G_OBJECT (header));
3611 g_object_unref (header);
3613 /* Ask user for confirmation. MSG-NOT404 */
3614 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3615 TNY_FOLDER (folder_store),
3618 /* Transfer current msg */
3619 if (response == GTK_RESPONSE_OK) {
3620 ModestMailOperation *mail_op;
3622 /* Create mail op */
3623 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
3624 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3627 /* Transfer messages */
3628 modest_mail_operation_xfer_msgs (mail_op,
3630 TNY_FOLDER (folder_store),
3632 transfer_msgs_from_viewer_cb,
3634 g_object_unref (G_OBJECT (mail_op));
3639 g_object_unref (header_folder);
3642 g_object_unref (headers);
3645 g_object_unref (folder_store);
3648 gtk_widget_destroy (dialog);
3652 modest_ui_actions_on_move_to (GtkAction *action,
3655 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3656 MODEST_IS_MSG_VIEW_WINDOW (win));
3658 if (MODEST_IS_MAIN_WINDOW (win))
3659 modest_ui_actions_on_main_window_move_to (action,
3660 MODEST_MAIN_WINDOW (win));
3662 modest_ui_actions_on_msg_view_window_move_to (action,
3663 MODEST_MSG_VIEW_WINDOW (win));
3667 * Calls #HeadersFunc for each header already selected in the main
3668 * window or the message currently being shown in the msg view window
3671 do_headers_action (ModestWindow *win,
3675 TnyList *headers_list;
3681 headers_list = get_selected_headers (win);
3685 /* Get the folder */
3686 iter = tny_list_create_iterator (headers_list);
3687 header = TNY_HEADER (tny_iterator_get_current (iter));
3688 folder = tny_header_get_folder (header);
3689 g_object_unref (header);
3691 /* Call the function for each header */
3692 while (!tny_iterator_is_done (iter)) {
3693 header = TNY_HEADER (tny_iterator_get_current (iter));
3694 func (header, win, user_data);
3695 g_object_unref (header);
3696 tny_iterator_next (iter);
3699 /* Trick: do a poke status in order to speed up the signaling
3701 tny_folder_poke_status (folder);
3704 g_object_unref (folder);
3705 g_object_unref (iter);
3706 g_object_unref (headers_list);
3710 modest_ui_actions_view_attachment (GtkAction *action,
3711 ModestWindow *window)
3713 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3714 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3716 /* not supported window for this action */
3717 g_return_if_reached ();
3722 modest_ui_actions_save_attachments (GtkAction *action,
3723 ModestWindow *window)
3725 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3726 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3728 /* not supported window for this action */
3729 g_return_if_reached ();
3734 modest_ui_actions_remove_attachments (GtkAction *action,
3735 ModestWindow *window)
3737 if (MODEST_IS_MAIN_WINDOW (window)) {
3738 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
3739 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3740 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
3742 /* not supported window for this action */
3743 g_return_if_reached ();
3748 modest_ui_actions_on_settings (GtkAction *action,
3753 dialog = modest_platform_get_global_settings_dialog ();
3754 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3755 gtk_widget_show_all (dialog);
3757 gtk_dialog_run (GTK_DIALOG (dialog));
3759 gtk_widget_destroy (dialog);
3763 modest_ui_actions_on_help (GtkAction *action,
3766 const gchar *help_id = NULL;
3768 if (MODEST_IS_MAIN_WINDOW (win)) {
3769 const gchar *action_name;
3770 action_name = gtk_action_get_name (action);
3772 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3773 !strcmp (action_name, "HeaderViewCSMHelp")) {
3774 GtkWidget *folder_view;
3775 TnyFolderStore *folder_store;
3776 /* Get selected folder */
3777 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3778 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3779 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3781 /* Switch help_id */
3782 if (TNY_IS_FOLDER (folder_store)) {
3783 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
3784 case TNY_FOLDER_TYPE_NORMAL:
3785 help_id = "applications_email_userfolder";
3787 case TNY_FOLDER_TYPE_INBOX:
3788 help_id = "applications_email_inbox";
3790 case TNY_FOLDER_TYPE_OUTBOX:
3791 help_id = "applications_email_outbox";
3793 case TNY_FOLDER_TYPE_SENT:
3794 help_id = "applications_email_sent";
3796 case TNY_FOLDER_TYPE_DRAFTS:
3797 help_id = "applications_email_drafts";
3799 case TNY_FOLDER_TYPE_ARCHIVE:
3800 help_id = "applications_email_archive";
3803 help_id = "applications_email_mainview";
3806 help_id = "applications_email_mainview";
3808 g_object_unref (folder_store);
3810 help_id = "applications_email_mainview";
3812 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3813 help_id = "applications_email_viewer";
3814 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3815 help_id = "applications_email_editor";
3817 modest_platform_show_help (GTK_WINDOW (win), help_id);
3821 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3822 ModestWindow *window)
3824 ModestMailOperation *mail_op;
3828 headers = get_selected_headers (window);
3832 /* Create mail operation */
3833 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3835 modest_ui_actions_get_msgs_full_error_handler,
3837 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3838 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3841 g_object_unref (headers);
3842 g_object_unref (mail_op);
3846 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3847 ModestWindow *window)
3849 g_return_if_fail (MODEST_IS_WINDOW (window));
3852 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3856 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3857 ModestWindow *window)
3859 g_return_if_fail (MODEST_IS_WINDOW (window));
3862 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3866 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3867 ModestWindow *window)
3869 g_return_if_fail (MODEST_IS_WINDOW (window));
3872 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3876 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3877 ModestWindow *window)
3879 g_return_if_fail (MODEST_IS_WINDOW (window));
3882 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3886 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3887 ModestWindow *window)
3889 g_return_if_fail (MODEST_IS_WINDOW (window));
3892 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3896 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3897 ModestWindow *window)
3899 g_return_if_fail (MODEST_IS_WINDOW (window));
3902 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3906 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3907 ModestWindow *window)
3909 g_return_if_fail (MODEST_IS_WINDOW (window));
3912 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3916 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3917 ModestWindow *window)
3919 g_return_if_fail (MODEST_IS_WINDOW (window));
3922 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3926 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3928 g_return_if_fail (MODEST_IS_WINDOW (window));
3931 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3935 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3937 g_return_if_fail (MODEST_IS_WINDOW (window));
3939 modest_platform_show_search_messages (GTK_WINDOW (window));
3943 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3945 g_return_if_fail (MODEST_IS_WINDOW (win));
3946 modest_platform_show_addressbook (GTK_WINDOW (win));
3951 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3952 ModestWindow *window)
3954 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3956 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3960 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3961 ModestMailOperationState *state,
3964 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3966 /* Set send/receive operation finished */
3967 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3968 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));